From 41412df7800e7eac39308a1397c6dbfbefc12598 Mon Sep 17 00:00:00 2001
From: ruthwikdasyam <ruthwikdasyam@gmail.com>
Date: Thu, 7 May 2026 15:28:55 -0700
Subject: [PATCH 1/9] mem2 recording fixes

---
 dimos/control/tasks/teleop_task.py |  2 +-
 dimos/memory2/module.py            | 11 ++++++++---
 dimos/teleop/quest/blueprints.py   | 21 +++++++++++++++++++++
 3 files changed, 30 insertions(+), 4 deletions(-)

diff --git a/dimos/control/tasks/teleop_task.py b/dimos/control/tasks/teleop_task.py
index 359e425c57..78163c58e6 100644
--- a/dimos/control/tasks/teleop_task.py
+++ b/dimos/control/tasks/teleop_task.py
@@ -80,7 +80,7 @@ class TeleopIKTaskConfig:
     ee_joint_id: int
     priority: int = 10
     timeout: float = 0.5
-    max_joint_delta_deg: float = 5.0  # ~500°/s at 100Hz
+    max_joint_delta_deg: float = 50.0  # ~500°/s at 100Hz
     hand: Literal["left", "right"] | None = None
     gripper_joint: str | None = None
     gripper_open_pos: float = 0.0
diff --git a/dimos/memory2/module.py b/dimos/memory2/module.py
index a691bfb044..76ee4dfe12 100644
--- a/dimos/memory2/module.py
+++ b/dimos/memory2/module.py
@@ -33,7 +33,6 @@
 from dimos.memory2.transform import QualityWindow
 from dimos.memory2.type.observation import EmbeddedObservation, Observation
 from dimos.models.embedding.base import EmbeddingModel
-from dimos.models.embedding.clip import CLIPModel
 from dimos.msgs.geometry_msgs.PoseStamped import PoseStamped
 from dimos.msgs.sensor_msgs.Image import Image
 from dimos.utils.logging_config import setup_logger
@@ -198,7 +197,7 @@ def store(self) -> SqliteStore:
 
 
 class SemanticSearchConfig(MemoryModuleConfig):
-    embedding_model: type[EmbeddingModel] = CLIPModel
+    embedding_model: type[EmbeddingModel] | None = None
 
 
 class SemanticSearch(MemoryModule):
@@ -210,7 +209,13 @@ class SemanticSearch(MemoryModule):
     def start(self) -> None:
         super().start()
 
-        self.model = self.register_disposable(self.config.embedding_model())
+        embedding_cls = self.config.embedding_model
+        if embedding_cls is None:
+            from dimos.models.embedding.clip import CLIPModel
+
+            embedding_cls = CLIPModel
+
+        self.model = self.register_disposable(embedding_cls())
         self.model.start()
 
         self.embeddings = self.store.stream("color_image_embedded", Image)
diff --git a/dimos/teleop/quest/blueprints.py b/dimos/teleop/quest/blueprints.py
index b6fa1257a2..24c825a343 100644
--- a/dimos/teleop/quest/blueprints.py
+++ b/dimos/teleop/quest/blueprints.py
@@ -15,6 +15,8 @@
 
 """Teleop blueprints for testing and deployment."""
 
+from pathlib import Path
+
 from dimos.control.blueprints.teleop import (
     coordinator_teleop_dual,
     coordinator_teleop_piper,
@@ -25,7 +27,9 @@
     coordinator_teleop_xarm7,
 )
 from dimos.core.coordination.blueprints import autoconnect
+from dimos.core.stream import In
 from dimos.core.transport import LCMTransport
+from dimos.memory2.module import Recorder, RecorderConfig
 from dimos.msgs.geometry_msgs.PoseStamped import PoseStamped
 from dimos.teleop.quest.quest_extensions import ArmTeleopModule
 from dimos.teleop.quest.quest_types import Buttons
@@ -72,6 +76,21 @@
 )
 
 
+class TeleopRecorderConfig(RecorderConfig):
+    db_path: str | Path = "recording_teleop.db"
+
+
+class TeleopRecorder(Recorder):
+    """Records right-controller pose and button state from any quest teleop blueprint.
+
+    Compose at the CLI: ``dimos run teleop-quest-xarm7-sim teleop-recorder``.
+    """
+
+    right_controller_output: In[PoseStamped]
+    buttons: In[Buttons]
+    config: TeleopRecorderConfig
+
+
 # Single Piper teleop: left controller -> piper arm
 teleop_quest_piper = autoconnect(
     ArmTeleopModule.blueprint(task_names={"left": "teleop_piper"}),
@@ -146,6 +165,8 @@
 
 
 __all__ = [
+    "TeleopRecorder",
+    "TeleopRecorderConfig",
     "teleop_quest_dual",
     "teleop_quest_piper",
     "teleop_quest_piper_sim",

From 3d6adae1938c298c53784b757101687ad6b96f29 Mon Sep 17 00:00:00 2001
From: ruthwikdasyam <ruthwikdasyam@gmail.com>
Date: Thu, 7 May 2026 15:31:03 -0700
Subject: [PATCH 2/9] feat: hosted teleop module

---
 dimos/robot/all_blueprints.py                 |   4 +
 dimos/teleop/quest_hosted/blueprints.py       |  39 ++
 .../teleop/quest_hosted/hosted_extensions.py  |  86 ++++
 .../quest_hosted/hosted_teleop_module.py      | 469 ++++++++++++++++++
 dimos/teleop/quest_hosted/static/index.html   | 349 +++++++++++++
 5 files changed, 947 insertions(+)
 create mode 100644 dimos/teleop/quest_hosted/blueprints.py
 create mode 100644 dimos/teleop/quest_hosted/hosted_extensions.py
 create mode 100644 dimos/teleop/quest_hosted/hosted_teleop_module.py
 create mode 100644 dimos/teleop/quest_hosted/static/index.html

diff --git a/dimos/robot/all_blueprints.py b/dimos/robot/all_blueprints.py
index 48658a53bf..48fc969fb5 100644
--- a/dimos/robot/all_blueprints.py
+++ b/dimos/robot/all_blueprints.py
@@ -67,6 +67,7 @@
     "mid360-fastlio-voxels-native": "dimos.hardware.sensors.lidar.fastlio2.fastlio_blueprints:mid360_fastlio_voxels_native",
     "openarm-mock-planner-coordinator": "dimos.robot.manipulators.openarm.blueprints:openarm_mock_planner_coordinator",
     "openarm-planner-coordinator": "dimos.robot.manipulators.openarm.blueprints:openarm_planner_coordinator",
+    "teleop-hosted-xarm7-sim": "dimos.teleop.quest_hosted.blueprints:teleop_hosted_xarm7_sim",
     "teleop-phone": "dimos.teleop.phone.blueprints:teleop_phone",
     "teleop-phone-go2": "dimos.teleop.phone.blueprints:teleop_phone_go2",
     "teleop-phone-go2-fleet": "dimos.teleop.phone.blueprints:teleop_phone_go2_fleet",
@@ -149,6 +150,8 @@
     "grasp-gen-module": "dimos.manipulation.grasping.graspgen_module.GraspGenModule",
     "grasping-module": "dimos.manipulation.grasping.grasping.GraspingModule",
     "gstreamer-camera-module": "dimos.hardware.sensors.camera.gstreamer.gstreamer_camera.GstreamerCameraModule",
+    "hosted-arm-teleop-module": "dimos.teleop.quest_hosted.hosted_extensions.HostedArmTeleopModule",
+    "hosted-teleop-module": "dimos.teleop.quest_hosted.hosted_teleop_module.HostedTeleopModule",
     "joint-trajectory-controller": "dimos.manipulation.control.trajectory_controller.joint_trajectory_controller.JointTrajectoryController",
     "joystick-module": "dimos.robot.unitree.b1.joystick_module.JoystickModule",
     "keyboard-teleop": "dimos.robot.unitree.keyboard_teleop.KeyboardTeleop",
@@ -190,6 +193,7 @@
     "spatial-memory": "dimos.perception.spatial_perception.SpatialMemory",
     "speak-skill": "dimos.agents.skills.speak_skill.SpeakSkill",
     "temporal-memory": "dimos.perception.experimental.temporal_memory.temporal_memory.TemporalMemory",
+    "teleop-recorder": "dimos.teleop.quest.blueprints.TeleopRecorder",
     "twist-teleop-module": "dimos.teleop.quest.quest_extensions.TwistTeleopModule",
     "unitree-g1-skill-container": "dimos.robot.unitree.g1.skill_container.UnitreeG1SkillContainer",
     "unitree-skill-container": "dimos.robot.unitree.unitree_skill_container.UnitreeSkillContainer",
diff --git a/dimos/teleop/quest_hosted/blueprints.py b/dimos/teleop/quest_hosted/blueprints.py
new file mode 100644
index 0000000000..5ab1f8c850
--- /dev/null
+++ b/dimos/teleop/quest_hosted/blueprints.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# Copyright 2025-2026 Dimensional Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Hosted teleop blueprints (WebRTC transport, single XArm7 sim)."""
+
+from dimos.control.blueprints.teleop import coordinator_teleop_sim_xarm7
+from dimos.core.coordination.blueprints import autoconnect
+from dimos.core.transport import LCMTransport
+from dimos.msgs.geometry_msgs.PoseStamped import PoseStamped
+from dimos.teleop.quest.quest_types import Buttons
+from dimos.teleop.quest_hosted.hosted_extensions import HostedArmTeleopModule
+
+# Single XArm7 teleop in MuJoCo sim, using the hosted (WebRTC) client.
+teleop_hosted_xarm7_sim = autoconnect(
+    HostedArmTeleopModule.blueprint(task_names={"right": "teleop_xarm"}),
+    coordinator_teleop_sim_xarm7,
+).transports(
+    {
+        ("right_controller_output", PoseStamped): LCMTransport(
+            "/coordinator/cartesian_command", PoseStamped
+        ),
+        ("buttons", Buttons): LCMTransport("/teleop/buttons", Buttons),
+    }
+)
+
+
+__all__ = ["teleop_hosted_xarm7_sim"]
diff --git a/dimos/teleop/quest_hosted/hosted_extensions.py b/dimos/teleop/quest_hosted/hosted_extensions.py
new file mode 100644
index 0000000000..4d156dc177
--- /dev/null
+++ b/dimos/teleop/quest_hosted/hosted_extensions.py
@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# Copyright 2025-2026 Dimensional Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Hosted teleop subclasses (WebRTC-via-Cloudflare-Realtime transport).
+
+Mirrors the role of ``dimos/teleop/quest/quest_extensions.py`` but for the
+hosted module — small overrides on top of ``HostedTeleopModule`` for arm
+teleop (per-hand task names + analog trigger packing into button bits).
+"""
+
+from typing import Any
+
+from pydantic import Field
+
+from dimos.msgs.geometry_msgs.PoseStamped import PoseStamped
+from dimos.teleop.quest.quest_teleop_module import Hand
+from dimos.teleop.quest.quest_types import Buttons, QuestControllerState
+from dimos.teleop.quest_hosted.hosted_teleop_module import (
+    HostedTeleopConfig,
+    HostedTeleopModule,
+)
+
+
+class HostedArmTeleopConfig(HostedTeleopConfig):
+    """Adds ``task_names`` for routing per-hand commands to coordinator tasks.
+
+    ``task_names`` maps lower-case hand names (``"left"``, ``"right"``) to
+    the coordinator task name (e.g. ``"teleop_xarm"``). Used to set
+    ``frame_id`` on the published ``PoseStamped`` so the coordinator routes
+    to the correct ``TeleopIKTask``.
+    """
+
+    task_names: dict[str, str] = Field(default_factory=dict)
+
+
+class HostedArmTeleopModule(HostedTeleopModule):
+    """Hosted teleop with per-hand task_name routing + analog trigger packing.
+
+    Same overrides as ``ArmTeleopModule`` but on top of the WebRTC-via-broker
+    ``HostedTeleopModule`` instead of the local-WebSocket ``QuestTeleopModule``.
+    """
+
+    config: HostedArmTeleopConfig
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._task_names: dict[Hand, str] = {
+            Hand[k.upper()]: v for k, v in self.config.task_names.items()
+        }
+
+    def _publish_msg(self, hand: Hand, output_msg: PoseStamped) -> None:
+        """Stamp ``frame_id`` with the configured task name, then publish."""
+        task_name = self._task_names.get(hand)
+        if task_name:
+            output_msg = PoseStamped(
+                position=output_msg.position,
+                orientation=output_msg.orientation,
+                ts=output_msg.ts,
+                frame_id=task_name,
+            )
+        super()._publish_msg(hand, output_msg)
+
+    def _publish_button_state(
+        self,
+        left: QuestControllerState | None,
+        right: QuestControllerState | None,
+    ) -> None:
+        """Publish ``Buttons`` with analog triggers packed into bits 16-29."""
+        buttons = Buttons.from_controllers(left, right)
+        buttons.pack_analog_triggers(
+            left=left.trigger if left is not None else 0.0,
+            right=right.trigger if right is not None else 0.0,
+        )
+        self.buttons.publish(buttons)
diff --git a/dimos/teleop/quest_hosted/hosted_teleop_module.py b/dimos/teleop/quest_hosted/hosted_teleop_module.py
new file mode 100644
index 0000000000..1db829965e
--- /dev/null
+++ b/dimos/teleop/quest_hosted/hosted_teleop_module.py
@@ -0,0 +1,469 @@
+#!/usr/bin/env python3
+# Copyright 2025-2026 Dimensional Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Hosted Teleop Module — Cloudflare Realtime client.
+
+Robot is a CLIENT (not a server). On start it:
+
+  1. Builds an aiortc PeerConnection with one DataChannel ``cmd_unreliable``
+     (unordered, maxRetransmits=0 — UDP-like, drop stale frames).
+  2. POSTs the SDP offer to the broker microservice
+     (``{broker_url}/api/v1/sessions``). Broker proxies to Cloudflare
+     Realtime SFU, returns the SDP answer + a session_id.
+  3. Establishes the DataChannel; operator commands (PoseStamped + Joy)
+     start arriving as bytes on cmd_unreliable.
+  4. Heartbeats the broker at 1 Hz to keep the session listed.
+
+On stop, deregisters with broker and closes the PC.
+
+Iteration 1 — operator → robot only. State channels (robot → operator)
+to be added later.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from enum import IntEnum
+import threading
+import time
+from typing import Any
+
+from aiortc import (
+    RTCConfiguration,
+    RTCIceServer,
+    RTCPeerConnection,
+    RTCSessionDescription,
+)
+from dimos_lcm.geometry_msgs import PoseStamped as LCMPoseStamped
+from dimos_lcm.sensor_msgs import Joy as LCMJoy
+import httpx
+
+from dimos.core.core import rpc
+from dimos.core.module import Module, ModuleConfig
+from dimos.core.stream import Out
+from dimos.msgs.geometry_msgs.PoseStamped import PoseStamped
+from dimos.msgs.sensor_msgs.Joy import Joy
+from dimos.teleop.quest.quest_types import Buttons, QuestControllerState
+from dimos.teleop.utils.teleop_transforms import webxr_to_robot
+from dimos.utils.logging_config import setup_logger
+
+logger = setup_logger()
+
+
+class Hand(IntEnum):
+    LEFT = 0
+    RIGHT = 1
+
+
+class HostedTeleopConfig(ModuleConfig):
+    """Configuration for HostedTeleopModule."""
+
+    control_loop_hz: float = 50.0
+
+    # Broker — the microservice that mediates SDP exchange with Cloudflare
+    # Realtime. Robots and operators only ever talk to this; Cloudflare
+    # credentials live on the broker.
+    broker_url: str = "https://teleop.dimensional-apps.com"
+    broker_api_key: str = ""
+
+    # Robot identity for the broker's session list.
+    robot_id: str = ""
+    robot_name: str = ""
+
+    # ICE — STUN works in most cases; configure TURN for restrictive networks.
+    stun_urls: list[str] = ["stun:stun.cloudflare.com:3478"]
+    turn_urls: list[str] = []
+    turn_username: str = ""
+    turn_credential: str = ""
+
+    heartbeat_hz: float = 1.0
+
+
+class HostedTeleopModule(Module):
+    """Cloudflare-Realtime-based teleop client.
+
+    Outputs (operator → robot, published from received cmd_unreliable bytes):
+      - ``left_controller_output: Out[PoseStamped]``
+      - ``right_controller_output: Out[PoseStamped]``
+      - ``buttons: Out[Buttons]``
+
+    Subclass to override engagement, output formatting, or button packing —
+    same hooks as ``QuestTeleopModule``.
+    """
+
+    config: HostedTeleopConfig
+
+    left_controller_output: Out[PoseStamped]
+    right_controller_output: Out[PoseStamped]
+    buttons: Out[Buttons]
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        # Per-hand state
+        self._is_engaged: dict[Hand, bool] = {Hand.LEFT: False, Hand.RIGHT: False}
+        self._initial_poses: dict[Hand, PoseStamped | None] = {
+            Hand.LEFT: None,
+            Hand.RIGHT: None,
+        }
+        self._current_poses: dict[Hand, PoseStamped | None] = {
+            Hand.LEFT: None,
+            Hand.RIGHT: None,
+        }
+        self._controllers: dict[Hand, QuestControllerState | None] = {
+            Hand.LEFT: None,
+            Hand.RIGHT: None,
+        }
+        self._lock = threading.RLock()
+
+        # asyncio loop running in a dedicated thread (aiortc + httpx are async)
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._loop_thread: threading.Thread | None = None
+
+        # WebRTC + broker state
+        self._pc: RTCPeerConnection | None = None
+        self._http: httpx.AsyncClient | None = None
+        self._session_id: str | None = None
+
+        # Background threads
+        self._control_loop_thread: threading.Thread | None = None
+        self._heartbeat_thread: threading.Thread | None = None
+        self._stop_event = threading.Event()
+
+        # Fingerprint dispatch — fired in asyncio context from DataChannel.on_message
+        self._decoders: dict[bytes, Any] = {
+            LCMPoseStamped._get_packed_fingerprint(): self._on_pose_bytes,
+            LCMJoy._get_packed_fingerprint(): self._on_joy_bytes,
+        }
+
+    # ─── Lifecycle ───────────────────────────────────────────────────────────
+
+    @rpc
+    def start(self) -> None:
+        super().start()
+        self._start_event_loop()
+        self._connect_blocking()
+        self._start_heartbeat()
+        self._start_control_loop()
+        logger.info("HostedTeleopModule started")
+
+    @rpc
+    def stop(self) -> None:
+        self._stop_event.set()
+        if self._control_loop_thread is not None:
+            self._control_loop_thread.join(timeout=1.0)
+            self._control_loop_thread = None
+        if self._heartbeat_thread is not None:
+            self._heartbeat_thread.join(timeout=2.0)
+            self._heartbeat_thread = None
+        if self._loop is not None and self._loop.is_running():
+            try:
+                asyncio.run_coroutine_threadsafe(self._disconnect(), self._loop).result(timeout=5.0)
+            except Exception:
+                logger.exception("Error during disconnect")
+        self._stop_event_loop()
+        super().stop()
+
+    # ─── Event loop thread ───────────────────────────────────────────────────
+
+    def _start_event_loop(self) -> None:
+        ready = threading.Event()
+
+        def runner() -> None:
+            self._loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._loop)
+            ready.set()
+            self._loop.run_forever()
+
+        self._loop_thread = threading.Thread(target=runner, daemon=True, name="HostedTeleopLoop")
+        self._loop_thread.start()
+        ready.wait()
+
+    def _stop_event_loop(self) -> None:
+        if self._loop is not None and self._loop.is_running():
+            self._loop.call_soon_threadsafe(self._loop.stop)
+        if self._loop_thread is not None:
+            self._loop_thread.join(timeout=2.0)
+            self._loop_thread = None
+        self._loop = None
+
+    # ─── WebRTC + broker (async, runs on event loop thread) ──────────────────
+
+    def _connect_blocking(self) -> None:
+        """Sync wrapper: schedule _connect() and wait."""
+        assert self._loop is not None, "_start_event_loop() must be called first"
+        future = asyncio.run_coroutine_threadsafe(self._connect(), self._loop)
+        future.result(timeout=20.0)
+
+    async def _connect(self) -> None:
+        """Open a WebRTC connection via the broker.
+
+        Steps:
+          1. Build PC + DataChannel('cmd_unreliable', unordered, no-retransmit)
+          2. createOffer + setLocalDescription
+          3. Wait for ICE gathering complete (non-trickle)
+          4. POST {broker}/api/v1/sessions { sdp, type, robot_id, robot_name }
+          5. Apply the returned SDP answer
+        """
+        self._http = httpx.AsyncClient(timeout=10.0)
+
+        ice_servers = [RTCIceServer(urls=u) for u in self.config.stun_urls]
+        for url in self.config.turn_urls or []:
+            ice_servers.append(
+                RTCIceServer(
+                    urls=url,
+                    username=self.config.turn_username or None,
+                    credential=self.config.turn_credential or None,
+                )
+            )
+
+        self._pc = RTCPeerConnection(RTCConfiguration(iceServers=ice_servers))
+
+        # Create cmd_unreliable so the SDP advertises a data plane.
+        # Operator publishes onto this same channel from the browser; the
+        # SFU forwards. Bytes arrive here as on_message events.
+        cmd_channel = self._pc.createDataChannel(
+            "cmd_unreliable",
+            ordered=False,
+            maxRetransmits=0,
+        )
+
+        @cmd_channel.on("open")
+        def _on_open() -> None:
+            logger.info("cmd_unreliable channel open")
+
+        @cmd_channel.on("message")
+        def _on_message(data: Any) -> None:  # bytes from the operator
+            if isinstance(data, bytes):
+                self._dispatch_bytes(data)
+
+        @self._pc.on("connectionstatechange")
+        async def _on_state() -> None:
+            assert self._pc is not None
+            logger.info(f"PC state: {self._pc.connectionState}")
+
+        offer = await self._pc.createOffer()
+        await self._pc.setLocalDescription(offer)
+
+        # Non-trickle ICE: wait for gathering before posting.
+        if self._pc.iceGatheringState != "complete":
+            done: asyncio.Future[None] = asyncio.get_event_loop().create_future()
+
+            @self._pc.on("icegatheringstatechange")
+            def _on_gathering() -> None:
+                assert self._pc is not None
+                if self._pc.iceGatheringState == "complete" and not done.done():
+                    done.set_result(None)
+
+            await done
+
+        # Register with broker.
+        url = f"{self.config.broker_url.rstrip('/')}/api/v1/sessions"
+        headers = self._auth_headers()
+        body = {
+            "robot_id": self.config.robot_id,
+            "robot_name": self.config.robot_name,
+            "sdp": self._pc.localDescription.sdp,
+            "type": self._pc.localDescription.type,
+        }
+        resp = await self._http.post(url, json=body, headers=headers)
+        resp.raise_for_status()
+        data = resp.json()
+        self._session_id = data["session_id"]
+
+        await self._pc.setRemoteDescription(
+            RTCSessionDescription(sdp=data["sdp"], type=data["type"])
+        )
+        logger.info(f"Registered with broker: session_id={self._session_id}")
+
+    async def _disconnect(self) -> None:
+        if self._http is not None and self._session_id is not None:
+            try:
+                url = f"{self.config.broker_url.rstrip('/')}/api/v1/sessions/{self._session_id}"
+                await self._http.delete(url, headers=self._auth_headers())
+            except Exception:
+                logger.exception("Failed to deregister with broker")
+        if self._pc is not None:
+            await self._pc.close()
+            self._pc = None
+        if self._http is not None:
+            await self._http.aclose()
+            self._http = None
+        self._session_id = None
+
+    def _auth_headers(self) -> dict[str, str]:
+        if self.config.broker_api_key:
+            return {"Authorization": f"Bearer {self.config.broker_api_key}"}
+        return {}
+
+    # ─── Heartbeat ──────────────────────────────────────────────────────────
+
+    def _start_heartbeat(self) -> None:
+        def runner() -> None:
+            interval = 1.0 / max(self.config.heartbeat_hz, 0.1)
+            while not self._stop_event.is_set():
+                if self._loop is not None and self._loop.is_running() and self._session_id:
+                    try:
+                        asyncio.run_coroutine_threadsafe(self._heartbeat(), self._loop).result(
+                            timeout=2.0
+                        )
+                    except Exception:
+                        logger.warning("Heartbeat failed (broker unreachable?)")
+                self._stop_event.wait(interval)
+
+        self._heartbeat_thread = threading.Thread(
+            target=runner, daemon=True, name="HostedTeleopHeartbeat"
+        )
+        self._heartbeat_thread.start()
+
+    async def _heartbeat(self) -> None:
+        if self._http is None or self._session_id is None:
+            return
+        url = f"{self.config.broker_url.rstrip('/')}/api/v1/sessions/{self._session_id}/heartbeat"
+        await self._http.post(url, headers=self._auth_headers())
+
+    # ─── Bytes dispatch (operator → robot) ──────────────────────────────────
+
+    def _dispatch_bytes(self, data: bytes) -> None:
+        """Route raw LCM bytes to the right handler by 8-byte fingerprint."""
+        decoder = self._decoders.get(data[:8])
+        if decoder:
+            decoder(data)
+        else:
+            logger.warning(f"Unknown message fingerprint: {data[:8].hex()}")
+
+    def _on_pose_bytes(self, data: bytes) -> None:
+        msg = PoseStamped.lcm_decode(data)
+        try:
+            hand = self._resolve_hand(msg.frame_id)
+        except ValueError:
+            return
+        robot_pose = webxr_to_robot(msg, is_left_controller=(hand == Hand.LEFT))
+        with self._lock:
+            self._current_poses[hand] = robot_pose
+
+    def _on_joy_bytes(self, data: bytes) -> None:
+        msg = Joy.lcm_decode(data)
+        try:
+            hand = self._resolve_hand(msg.frame_id)
+        except ValueError:
+            return
+        try:
+            controller = QuestControllerState.from_joy(msg, is_left=(hand == Hand.LEFT))
+        except ValueError:
+            logger.warning(
+                f"Malformed Joy for {hand.name}: axes={len(msg.axes or [])}, "
+                f"buttons={len(msg.buttons or [])}"
+            )
+            return
+        with self._lock:
+            self._controllers[hand] = controller
+
+    @staticmethod
+    def _resolve_hand(frame_id: str) -> Hand:
+        if frame_id == "left":
+            return Hand.LEFT
+        if frame_id == "right":
+            return Hand.RIGHT
+        raise ValueError(f"Unexpected frame_id: {frame_id!r}")
+
+    # ─── Control loop (publishes Out streams) ───────────────────────────────
+
+    def _start_control_loop(self) -> None:
+        self._stop_event.clear()
+        self._control_loop_thread = threading.Thread(
+            target=self._control_loop,
+            daemon=True,
+            name="HostedTeleopControlLoop",
+        )
+        self._control_loop_thread.start()
+
+    def _control_loop(self) -> None:
+        period = 1.0 / self.config.control_loop_hz
+        while not self._stop_event.is_set():
+            loop_start = time.perf_counter()
+            try:
+                with self._lock:
+                    self._handle_engage()
+                    for hand in Hand:
+                        if not self._should_publish(hand):
+                            continue
+                        output_pose = self._get_output_pose(hand)
+                        if output_pose is not None:
+                            self._publish_msg(hand, output_pose)
+                    left = self._controllers.get(Hand.LEFT)
+                    right = self._controllers.get(Hand.RIGHT)
+                    self._publish_button_state(left, right)
+            except Exception:
+                logger.exception("Error in control loop")
+
+            elapsed = time.perf_counter() - loop_start
+            sleep_time = period - elapsed
+            if sleep_time > 0:
+                self._stop_event.wait(sleep_time)
+
+    def _handle_engage(self) -> None:
+        """Press-and-hold engage on each controller's primary button."""
+        for hand in Hand:
+            controller = self._controllers.get(hand)
+            if controller is None:
+                continue
+            if controller.primary:
+                if not self._is_engaged[hand]:
+                    pose = self._current_poses.get(hand)
+                    if pose is None:
+                        logger.error(
+                            f"Engage failed: {hand.name.lower()} controller has no pose data"
+                        )
+                        continue
+                    self._initial_poses[hand] = pose
+                    self._is_engaged[hand] = True
+                    logger.info(f"{hand.name} engaged.")
+            else:
+                if self._is_engaged[hand]:
+                    self._is_engaged[hand] = False
+                    logger.info(f"{hand.name} disengaged.")
+
+    def _should_publish(self, hand: Hand) -> bool:
+        return self._is_engaged[hand]
+
+    def _get_output_pose(self, hand: Hand) -> PoseStamped | None:
+        """Default: delta from initial engaged pose."""
+        current = self._current_poses.get(hand)
+        initial = self._initial_poses.get(hand)
+        if current is None or initial is None:
+            return None
+        delta = current - initial
+        return PoseStamped(
+            position=delta.position,
+            orientation=delta.orientation,
+            ts=current.ts,
+            frame_id=current.frame_id,
+        )
+
+    def _publish_msg(self, hand: Hand, output_msg: PoseStamped) -> None:
+        if hand == Hand.LEFT:
+            self.left_controller_output.publish(output_msg)
+        else:
+            self.right_controller_output.publish(output_msg)
+
+    def _publish_button_state(
+        self,
+        left: QuestControllerState | None,
+        right: QuestControllerState | None,
+    ) -> None:
+        buttons = Buttons.from_controllers(left, right)
+        self.buttons.publish(buttons)
diff --git a/dimos/teleop/quest_hosted/static/index.html b/dimos/teleop/quest_hosted/static/index.html
new file mode 100644
index 0000000000..642fca568e
--- /dev/null
+++ b/dimos/teleop/quest_hosted/static/index.html
@@ -0,0 +1,349 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>DimOS Teleop (Hosted)</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #fff; color: #333;
+            display: flex; flex-direction: column;
+            align-items: center; justify-content: center;
+            height: 100vh; overflow: hidden;
+        }
+        #ui {
+            position: absolute; inset: 0;
+            display: flex; flex-direction: column;
+            align-items: center; justify-content: center;
+            z-index: 100; gap: 16px;
+        }
+        h1 { font-size: 36px; font-weight: 600; color: #28283b; }
+        h2 { font-size: 18px; font-weight: 400; color: #6c757d; margin-bottom: 16px; }
+        #status {
+            font-size: 22px; font-weight: 500; color: #0077b6;
+            padding: 12px 24px; border: 2px solid #0077b6; border-radius: 12px;
+            min-width: 320px; text-align: center;
+        }
+        input, select {
+            font-size: 16px; padding: 10px 14px;
+            border: 1px solid #ccc; border-radius: 8px;
+            width: 360px; text-align: left;
+        }
+        button {
+            padding: 16px 36px; font-size: 20px; font-weight: 600;
+            color: white; background: #0077b6; border: none; border-radius: 12px;
+            cursor: pointer; transition: background-color .2s;
+        }
+        button:hover { background: #005f8a; }
+        button:disabled { background: #adb5bd; cursor: not-allowed; }
+        button.secondary { background: #6c757d; }
+        button.secondary:hover { background: #545b62; }
+        #canvas {
+            display: none; position: absolute; inset: 0;
+            width: 100%; height: 100%;
+        }
+        .hidden { display: none !important; }
+        .row { display: flex; gap: 8px; align-items: center; }
+    </style>
+</head>
+<body>
+    <div id="ui">
+        <h1>DimOS Teleop</h1>
+        <h2>Hosted client (Cloudflare Realtime)</h2>
+        <div id="status">Ready</div>
+
+        <input id="broker-input" type="text" placeholder="Broker URL (https://teleop.dimensional-apps.com)" />
+        <input id="api-key-input" type="password" placeholder="API key (optional)" />
+        <div class="row">
+            <button id="refreshBtn" onclick="refreshRobots()">List robots</button>
+        </div>
+        <select id="robot-select" class="hidden"></select>
+        <button id="connectBtn" class="hidden" onclick="connect()">Connect</button>
+        <button id="disconnectBtn" class="hidden secondary" onclick="disconnect()">Disconnect</button>
+    </div>
+    <canvas id="canvas"></canvas>
+
+    <script type="module">
+        window.onerror = (msg, url, line, col, error) => {
+            console.error(`[ERROR] ${msg} at ${url}:${line}:${col}`, error);
+            document.getElementById('status').textContent = `Error: ${msg}`;
+        };
+
+        import { geometry_msgs, std_msgs, sensor_msgs } from "https://esm.sh/jsr/@dimos/msgs@0.1.4";
+
+        // State
+        let pc = null;
+        let cmdChannel = null;
+        let xrSession = null;
+        let xrRefSpace = null;
+        let gl = null;
+        let lastSendTime = 0;
+        const sendInterval = 1000 / 80; // 80 Hz
+
+        // UI elements
+        const statusEl = document.getElementById('status');
+        const brokerInput = document.getElementById('broker-input');
+        const apiKeyInput = document.getElementById('api-key-input');
+        const refreshBtn = document.getElementById('refreshBtn');
+        const robotSelect = document.getElementById('robot-select');
+        const connectBtn = document.getElementById('connectBtn');
+        const disconnectBtn = document.getElementById('disconnectBtn');
+        const canvas = document.getElementById('canvas');
+
+        const urlParams = new URLSearchParams(window.location.search);
+        brokerInput.value = urlParams.get('broker') || localStorage.getItem('dimos_broker') || '';
+        apiKeyInput.value = urlParams.get('api_key') || localStorage.getItem('dimos_api_key') || '';
+
+        function setStatus(msg) { statusEl.textContent = msg; }
+
+        function authHeaders() {
+            const k = apiKeyInput.value.trim();
+            return k ? { 'Authorization': `Bearer ${k}` } : {};
+        }
+
+        function brokerUrl() {
+            const b = brokerInput.value.trim().replace(/\/$/, '');
+            if (!b) throw new Error('Enter the broker URL');
+            return b;
+        }
+
+        // GET /api/v1/sessions → populate robot dropdown
+        window.refreshRobots = async function() {
+            try {
+                refreshBtn.disabled = true;
+                setStatus('Fetching robot list...');
+                localStorage.setItem('dimos_broker', brokerInput.value.trim());
+                localStorage.setItem('dimos_api_key', apiKeyInput.value.trim());
+
+                const resp = await fetch(`${brokerUrl()}/api/v1/sessions`, {
+                    headers: { ...authHeaders() }
+                });
+                if (!resp.ok) throw new Error(`broker returned ${resp.status}`);
+                const robots = await resp.json();
+
+                robotSelect.innerHTML = '';
+                if (!Array.isArray(robots) || robots.length === 0) {
+                    setStatus('No robots online');
+                    robotSelect.classList.add('hidden');
+                    connectBtn.classList.add('hidden');
+                    return;
+                }
+                for (const r of robots) {
+                    const opt = document.createElement('option');
+                    opt.value = r.session_id;
+                    opt.textContent = `${r.robot_name || r.robot_id || r.session_id}`;
+                    robotSelect.appendChild(opt);
+                }
+                robotSelect.classList.remove('hidden');
+                connectBtn.classList.remove('hidden');
+                setStatus(`${robots.length} robot(s) available`);
+            } catch (e) {
+                console.error(e);
+                setStatus(`List failed: ${e.message}`);
+            } finally {
+                refreshBtn.disabled = false;
+            }
+        };
+
+        async function setupWebRTC(sessionId) {
+            setStatus('Negotiating WebRTC...');
+            pc = new RTCPeerConnection({
+                iceServers: [{ urls: 'stun:stun.cloudflare.com:3478' }]
+            });
+
+            // Operator → robot. UDP-like, drop stale frames.
+            cmdChannel = pc.createDataChannel('cmd_unreliable', {
+                ordered: false,
+                maxRetransmits: 0
+            });
+            cmdChannel.binaryType = 'arraybuffer';
+
+            const opened = new Promise((resolve, reject) => {
+                cmdChannel.onopen = () => resolve();
+                cmdChannel.onerror = (e) => reject(e);
+                pc.oniceconnectionstatechange = () => {
+                    if (pc.iceConnectionState === 'failed' ||
+                        pc.iceConnectionState === 'disconnected') {
+                        reject(new Error('ICE ' + pc.iceConnectionState));
+                    }
+                };
+            });
+
+            const offer = await pc.createOffer();
+            await pc.setLocalDescription(offer);
+
+            await new Promise(resolve => {
+                if (pc.iceGatheringState === 'complete') return resolve();
+                pc.onicegatheringstatechange = () => {
+                    if (pc.iceGatheringState === 'complete') resolve();
+                };
+            });
+
+            const resp = await fetch(`${brokerUrl()}/api/v1/sessions/${sessionId}/join`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...authHeaders() },
+                body: JSON.stringify({
+                    sdp: pc.localDescription.sdp,
+                    type: pc.localDescription.type
+                })
+            });
+            if (!resp.ok) throw new Error(`broker join failed: ${resp.status}`);
+            const answer = await resp.json();
+            await pc.setRemoteDescription(answer);
+
+            await opened;
+            setStatus('Connected');
+        }
+
+        function send(bytes) {
+            if (cmdChannel && cmdChannel.readyState === 'open') {
+                cmdChannel.send(bytes);
+            }
+        }
+
+        function initGL() {
+            gl = canvas.getContext('webgl', { xrCompatible: true, alpha: true });
+            if (!gl) throw new Error('WebGL not supported');
+            gl.clearColor(0, 0, 0, 0);
+        }
+
+        function processTracking(frame) {
+            const now = performance.now();
+            if (now - lastSendTime < sendInterval) return;
+            lastSendTime = now;
+
+            for (const inputSource of frame.session.inputSources) {
+                const trackingSpace = inputSource.gripSpace || inputSource.targetRaySpace;
+                if (!trackingSpace) continue;
+                const handedness = inputSource.handedness;
+                if (handedness !== 'left' && handedness !== 'right') continue;
+
+                const pose = frame.getPose(trackingSpace, xrRefSpace);
+                if (!pose) continue;
+
+                const pos = pose.transform.position;
+                const rot = pose.transform.orientation;
+                const nowMs = Date.now();
+
+                const poseStamped = new geometry_msgs.PoseStamped({
+                    header: new std_msgs.Header({
+                        stamp: new std_msgs.Time({
+                            sec: Math.floor(nowMs / 1000),
+                            nsec: (nowMs % 1000) * 1_000_000
+                        }),
+                        frame_id: handedness
+                    }),
+                    pose: new geometry_msgs.Pose({
+                        position: new geometry_msgs.Point({ x: pos.x, y: pos.y, z: pos.z }),
+                        orientation: new geometry_msgs.Quaternion({
+                            x: rot.x, y: rot.y, z: rot.z, w: rot.w
+                        })
+                    })
+                });
+                send(poseStamped.encode());
+
+                const gamepad = inputSource.gamepad;
+                if (gamepad) {
+                    const axes = [
+                        gamepad.axes[0] ?? 0.0,
+                        gamepad.axes[1] ?? 0.0,
+                        gamepad.buttons[0]?.value ?? 0.0,
+                        gamepad.buttons[1]?.value ?? 0.0
+                    ];
+                    const buttons = [];
+                    for (let i = 0; i < gamepad.buttons.length; i++) {
+                        buttons.push(gamepad.buttons[i]?.pressed ? 1 : 0);
+                    }
+                    const joyMsg = new sensor_msgs.Joy({
+                        header: new std_msgs.Header({
+                            stamp: new std_msgs.Time({
+                                sec: Math.floor(nowMs / 1000),
+                                nsec: (nowMs % 1000) * 1_000_000
+                            }),
+                            frame_id: handedness
+                        }),
+                        axes_length: axes.length,
+                        buttons_length: buttons.length,
+                        axes: axes,
+                        buttons: buttons
+                    });
+                    send(joyMsg.encode());
+                }
+            }
+        }
+
+        function onXRFrame(time, frame) {
+            if (!xrSession) return;
+            xrSession.requestAnimationFrame(onXRFrame);
+            processTracking(frame);
+            gl.clear(gl.COLOR_BUFFER_BIT);
+        }
+
+        async function startVR() {
+            setStatus('Initializing WebGL...');
+            initGL();
+            setStatus('Requesting VR session...');
+            let session = null;
+            try {
+                session = await navigator.xr.requestSession('immersive-ar', {
+                    requiredFeatures: ['local-floor'],
+                    optionalFeatures: ['hand-tracking']
+                });
+            } catch (e) {
+                session = await navigator.xr.requestSession('immersive-vr', {
+                    requiredFeatures: ['local-floor'],
+                    optionalFeatures: ['hand-tracking']
+                });
+            }
+            xrSession = session;
+            const glLayer = new XRWebGLLayer(session, gl);
+            await session.updateRenderState({ baseLayer: glLayer });
+            xrRefSpace = await session.requestReferenceSpace('local-floor');
+            setStatus('VR active');
+            session.addEventListener('end', () => {
+                setStatus('VR session ended');
+                xrSession = null;
+                disconnect();
+            });
+            session.requestAnimationFrame(onXRFrame);
+        }
+
+        window.connect = async function() {
+            try {
+                connectBtn.disabled = true;
+                if (!navigator.xr) throw new Error('WebXR not supported. Use Quest 3 browser.');
+                const sessionId = robotSelect.value;
+                if (!sessionId) throw new Error('Pick a robot first');
+                await setupWebRTC(sessionId);
+                await startVR();
+                connectBtn.classList.add('hidden');
+                disconnectBtn.classList.remove('hidden');
+                refreshBtn.classList.add('hidden');
+                robotSelect.classList.add('hidden');
+                brokerInput.classList.add('hidden');
+                apiKeyInput.classList.add('hidden');
+            } catch (e) {
+                setStatus(`Connection failed: ${e.message}`);
+                console.error(e);
+                connectBtn.disabled = false;
+            }
+        };
+
+        window.disconnect = async function() {
+            setStatus('Disconnecting...');
+            if (xrSession) { await xrSession.end().catch(console.error); xrSession = null; }
+            if (cmdChannel) { try { cmdChannel.close(); } catch (_) {} cmdChannel = null; }
+            if (pc)         { try { pc.close(); }         catch (_) {} pc = null; }
+            connectBtn.classList.remove('hidden');
+            connectBtn.disabled = false;
+            disconnectBtn.classList.add('hidden');
+            refreshBtn.classList.remove('hidden');
+            brokerInput.classList.remove('hidden');
+            apiKeyInput.classList.remove('hidden');
+            setStatus('Ready');
+        };
+    </script>
+</body>
+</html>

From 33c25719d1ac7a51ef88640b1c7c16af20d16d05 Mon Sep 17 00:00:00 2001
From: ruthwikdasyam <ruthwikdasyam@gmail.com>
Date: Thu, 7 May 2026 15:31:23 -0700
Subject: [PATCH 3/9] misc: hosted tests

---
 dimos/teleop/utils/latency_analyzer.ipynb | 303 ++++++++++++++++++++++
 1 file changed, 303 insertions(+)
 create mode 100644 dimos/teleop/utils/latency_analyzer.ipynb

diff --git a/dimos/teleop/utils/latency_analyzer.ipynb b/dimos/teleop/utils/latency_analyzer.ipynb
new file mode 100644
index 0000000000..ba0aefcea1
--- /dev/null
+++ b/dimos/teleop/utils/latency_analyzer.ipynb
@@ -0,0 +1,303 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "intro",
+      "metadata": {},
+      "source": [
+        "# Teleop recording stats\n",
+        "\n",
+        "Quick analysis of a `TeleopRecorder` SQLite recording \u2014 rate / jitter, pose trajectory, engagement windows.\n",
+        "\n",
+        "Recording schema: `right_controller_output` (PoseStamped) + `buttons` (Buttons). Edit `RECORDING_PATH` below."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "setup",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "recording: recording_teleop.db\n",
+            "  Stream(\"buttons\"): 6396 items, 2026-05-07 18:30:10 \u2014 2026-05-07 18:32:20 (130.4s)\n",
+            "  Stream(\"right_controller_output\"): 666 items, 2026-05-07 18:31:46 \u2014 2026-05-07 18:32:02 (15.7s)\n"
+          ]
+        }
+      ],
+      "source": [
+        "from pathlib import Path\n",
+        "\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "\n",
+        "from dimos.memory2.store.sqlite import SqliteStore\n",
+        "\n",
+        "RECORDING_PATH = Path(\"../../../recording_teleop.db\")\n",
+        "\n",
+        "store = SqliteStore(path=str(RECORDING_PATH))\n",
+        "obs = {name: stream.to_list() for name, stream in store.streams.items()}\n",
+        "\n",
+        "print(f\"recording: {RECORDING_PATH.name}\")\n",
+        "for name, items in obs.items():\n",
+        "    print(f\"  {store.streams[name].summary()}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "9830213d",
+      "metadata": {},
+      "source": "## Trace IDs & end-to-end latency\n\nEvery `Joy` / `PoseStamped` / `JointState` now carries a `trace_id` in its LCM `Header.seq`. Origin is `QuestTeleopModule._on_pose_bytes` (assigns at system entry); downstream stages forward the same id. Once you record more than one stage, you join by `obs.data.trace_id` to get exact per-message E2E latency without nearest-neighbor matching.\n\nFor now this recording only has `right_controller_output`, so we just show that trace_ids are populated, increasing, and unique."
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "d03d198c",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "pose = obs.get(\"right_controller_output\", [])\n",
+        "if not pose:\n",
+        "    print(\"no pose stream\")\n",
+        "else:\n",
+        "    tids = np.array([o.data.trace_id for o in pose], dtype=np.int64)\n",
+        "    untagged = (tids == 0).sum()\n",
+        "    unique = len(np.unique(tids[tids != 0]))\n",
+        "    monotonic = np.all(np.diff(tids[tids != 0]) >= 0)\n",
+        "    print(\n",
+        "        f\"pose msgs: {len(tids)}   untagged (trace_id=0): {untagged}   unique tagged: {unique}   monotonic: {monotonic}\"\n",
+        "    )\n",
+        "    if untagged == len(tids):\n",
+        "        print(\"  \u2192 recording predates trace_id support; re-record to enable.\")\n",
+        "    elif untagged:\n",
+        "        print(\"  \u2192 some msgs untagged; producer may be older. Drop them when joining.\")\n",
+        "    else:\n",
+        "        print(\n",
+        "            f\"  \u2192 trace_id range: [{tids.min()}, {tids.max()}], gap count: {(np.diff(tids[tids != 0]) > 1).sum()}\"\n",
+        "        )\n",
+        "\n",
+        "# When you record a second stage (e.g., joint_state), join like this:\n",
+        "#\n",
+        "#   pose_by_id = {o.data.trace_id: o for o in obs['right_controller_output']}\n",
+        "#   pairs = [(pose_by_id[js.data.trace_id], js) for js in obs['joint_state']\n",
+        "#            if js.data.trace_id and js.data.trace_id in pose_by_id]\n",
+        "#   lat_ms = np.array([(js.data.ts - p.data.ts) * 1000 for p, js in pairs])\n",
+        "#   print(f'E2E p50={np.median(lat_ms):.1f}  p95={np.percentile(lat_ms, 95):.1f}  p99={np.percentile(lat_ms, 99):.1f} ms')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "rate-md",
+      "metadata": {},
+      "source": [
+        "## Rate / jitter\n",
+        "\n",
+        "Inter-message intervals per stream. Tight distribution = stable rate; long tail = stalls."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "rate-code",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1100x520 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "fig, axes = plt.subplots(len(obs), 1, figsize=(11, 2.6 * len(obs)), squeeze=False)\n",
+        "for ax, (name, items) in zip(axes[:, 0], obs.items(), strict=False):\n",
+        "    if len(items) < 2:\n",
+        "        ax.set_title(f\"{name} (n<2)\")\n",
+        "        continue\n",
+        "    ts = np.sort(np.array([o.ts for o in items]))\n",
+        "    intervals = np.diff(ts) * 1000.0\n",
+        "    p50, p95, p99 = np.percentile(intervals, [50, 95, 99])\n",
+        "    rate = len(ts) / (ts[-1] - ts[0])\n",
+        "    ax.hist(intervals, bins=80, log=True, color=\"steelblue\", edgecolor=\"none\")\n",
+        "    for p, c, lbl in [(p50, \"black\", \"p50\"), (p95, \"orange\", \"p95\"), (p99, \"red\", \"p99\")]:\n",
+        "        ax.axvline(p, color=c, linestyle=\"--\", lw=0.8, label=f\"{lbl}={p:.1f}ms\")\n",
+        "    ax.set_title(f\"{name}: {len(ts)} msgs, {rate:.1f} Hz\")\n",
+        "    ax.set_xlabel(\"interval (ms)\")\n",
+        "    ax.set_ylabel(\"count (log)\")\n",
+        "    ax.legend(fontsize=8)\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "pose-md",
+      "metadata": {},
+      "source": [
+        "## Pose trajectory\n",
+        "\n",
+        "Position (x/y/z) and orientation (rpy) of the right controller over time."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "id": "pose-code",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1100x500 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "position range: x=0.283m  y=0.118m  z=0.118m\n"
+          ]
+        }
+      ],
+      "source": [
+        "pose = obs.get(\"right_controller_output\", [])\n",
+        "if not pose:\n",
+        "    print(\"no right_controller_output stream\")\n",
+        "else:\n",
+        "    ts = np.array([o.ts for o in pose])\n",
+        "    rel = ts - ts[0]\n",
+        "    xyz = np.array([[o.data.x, o.data.y, o.data.z] for o in pose])\n",
+        "    rpy = np.array([[o.data.roll, o.data.pitch, o.data.yaw] for o in pose])\n",
+        "\n",
+        "    fig, axes = plt.subplots(2, 1, figsize=(11, 5), sharex=True)\n",
+        "    for i, lbl in enumerate(\"xyz\"):\n",
+        "        axes[0].plot(rel, xyz[:, i], lw=0.8, label=lbl)\n",
+        "    axes[0].set_ylabel(\"position (m)\")\n",
+        "    axes[0].legend(fontsize=8)\n",
+        "    axes[0].grid(alpha=0.3)\n",
+        "    for i, lbl in enumerate([\"roll\", \"pitch\", \"yaw\"]):\n",
+        "        axes[1].plot(rel, rpy[:, i], lw=0.8, label=lbl)\n",
+        "    axes[1].set_ylabel(\"orientation (rad)\")\n",
+        "    axes[1].set_xlabel(\"time (s)\")\n",
+        "    axes[1].legend(fontsize=8)\n",
+        "    axes[1].grid(alpha=0.3)\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "    rng = np.ptp(xyz, axis=0)\n",
+        "    print(f\"position range: x={rng[0]:.3f}m  y={rng[1]:.3f}m  z={rng[2]:.3f}m\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "engage-md",
+      "metadata": {},
+      "source": [
+        "## Engagement windows\n",
+        "\n",
+        "Buttons are bit-packed; non-zero = something held. Adjacent non-zero samples (gap < 200 ms) get stitched into intervals = active teleop periods."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "id": "engage-code",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "4 engagement events, total held: 14.12s\n",
+            "  [0]  96.15s ->  97.65s  (1.50s)\n",
+            "  [1]  98.02s ->  99.60s  (1.58s)\n",
+            "  [2] 100.18s -> 109.86s  (9.69s)\n",
+            "  [3] 110.53s -> 111.88s  (1.35s)\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1100x250 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "btn = obs.get(\"buttons\", [])\n",
+        "if not btn:\n",
+        "    print(\"no buttons stream\")\n",
+        "else:\n",
+        "    t0 = btn[0].ts\n",
+        "    held = store.streams[\"buttons\"].filter(lambda o: o.data.data != 0).to_list()\n",
+        "    if not held:\n",
+        "        print(\"no engagement events (no non-zero button samples)\")\n",
+        "    else:\n",
+        "        held_ts = np.array([o.ts for o in held])\n",
+        "        breaks = np.where(np.diff(held_ts) > 0.2)[0]\n",
+        "        starts = np.concatenate([[held_ts[0]], held_ts[breaks + 1]]) - t0\n",
+        "        ends = np.concatenate([held_ts[breaks], [held_ts[-1]]]) - t0\n",
+        "        durations = ends - starts\n",
+        "        print(f\"{len(starts)} engagement events, total held: {durations.sum():.2f}s\")\n",
+        "        for i, (s, e, d) in enumerate(zip(starts, ends, durations, strict=False)):\n",
+        "            print(f\"  [{i}] {s:6.2f}s -> {e:6.2f}s  ({d:.2f}s)\")\n",
+        "\n",
+        "        fig, ax = plt.subplots(figsize=(11, 2.5))\n",
+        "        raw = np.array([o.data.data for o in btn], dtype=np.uint32)\n",
+        "        rel = np.array([o.ts for o in btn]) - t0\n",
+        "        ax.step(rel, raw, where=\"post\", lw=0.7, color=\"steelblue\")\n",
+        "        for s, e in zip(starts, ends, strict=False):\n",
+        "            ax.axvspan(s, e, color=\"orange\", alpha=0.2)\n",
+        "        ax.set_xlabel(\"time (s)\")\n",
+        "        ax.set_ylabel(\"buttons (uint32)\")\n",
+        "        ax.set_title(\"button state \u2014 orange = engagement window\")\n",
+        "        ax.grid(alpha=0.3)\n",
+        "        plt.tight_layout()\n",
+        "        plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "e1264323",
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "dimos (3.12.12)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.12.12"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

From fb43817a304542287ecc64bdcd6d32f148d4e3e0 Mon Sep 17 00:00:00 2001
From: ruthwikdasyam <ruthwikdasyam@gmail.com>
Date: Thu, 7 May 2026 16:22:50 -0700
Subject: [PATCH 4/9] misc: no-cloudflare broker

---
 dimos/teleop/quest_hosted/dev_broker.py | 320 ++++++++++++++++++++++++
 1 file changed, 320 insertions(+)
 create mode 100644 dimos/teleop/quest_hosted/dev_broker.py

diff --git a/dimos/teleop/quest_hosted/dev_broker.py b/dimos/teleop/quest_hosted/dev_broker.py
new file mode 100644
index 0000000000..b46a1078c0
--- /dev/null
+++ b/dimos/teleop/quest_hosted/dev_broker.py
@@ -0,0 +1,320 @@
+#!/usr/bin/env python3
+# Copyright 2025-2026 Dimensional Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Local dev broker for HostedTeleopModule end-to-end testing.
+
+Stand-in for the production Cloudflare Worker broker. Implements the same
+``/api/v1/sessions`` API spec, but bridges a robot ↔ operator pair using
+aiortc on the broker side instead of routing through Cloudflare's SFU.
+
+No internet, no Cloudflare account, no external dependencies — runs locally,
+designed for laptop testing.
+
+Architecture
+------------
+The broker creates one ``RTCPeerConnection`` per peer (robot, operator) and
+forwards DataChannel messages between them by channel label. Effectively a
+tiny in-process SFU. The four channels in your spec
+(``cmd_unreliable``/``cmd_reliable``/``state_unreliable``/``state_reliable``)
+will all bridge automatically — robot opens, operator opens same name,
+broker matches them and forwards bytes.
+
+Usage
+-----
+1. Start the broker::
+
+       python -m dimos.teleop.quest_hosted.dev_broker
+
+2. Run dimos pointing at this broker::
+
+       dimos run teleop-hosted-xarm7-sim \\
+         --hosted-arm-teleop-module.broker-url=http://localhost:8000 \\
+         --hosted-arm-teleop-module.robot-id=test-robot \\
+         --hosted-arm-teleop-module.robot-name="Test XArm7"
+
+3. Open the operator HTML in a browser. Easiest path: this broker also
+   serves it at ``http://localhost:8000/teleop``. Set the broker URL field
+   in the UI to ``http://localhost:8000``, click "List robots", connect.
+
+Networking notes
+----------------
+- For Quest-from-same-wifi: replace ``localhost`` with your laptop's LAN
+  IP (e.g. ``http://192.168.1.10:8000``) and make sure your firewall lets
+  port 8000 through.
+- WebXR (immersive-ar/vr) requires HTTPS. ``localhost`` is exempt for
+  desktop Chrome but **not** for the Quest browser — for Quest testing
+  you'll need an HTTPS tunnel (e.g., ``cloudflared tunnel`` or ``ngrok``)
+  pointing at this broker. For desktop Chrome the WebXR Emulator extension
+  is enough to validate the data plane.
+
+Limitations
+-----------
+- No auth (broker_api_key is ignored).
+- One operator per session (most recent join wins).
+- Process-local state (no KV / no persistence).
+- Don't deploy this; it's the dev fixture. Production broker = Cloudflare
+  Worker (separate task).
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import uvicorn
+from aiortc import RTCPeerConnection, RTCSessionDescription
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+)
+logger = logging.getLogger("dev_broker")
+
+STATIC_DIR = Path(__file__).parent / "static"
+
+
+# ─── Session state ──────────────────────────────────────────────────────────
+
+
+@dataclass
+class Session:
+    session_id: str
+    robot_id: str
+    robot_name: str
+    robot_pc: RTCPeerConnection
+    robot_channels: dict[str, Any] = field(default_factory=dict)
+    operator_pc: RTCPeerConnection | None = None
+    operator_channels: dict[str, Any] = field(default_factory=dict)
+
+
+_sessions: dict[str, Session] = {}
+
+
+def _wire_forwarding(label: str, src_channel: Any, dst_channels: dict[str, Any]) -> None:
+    """When src_channel receives a message, forward it to dst_channels[label]."""
+
+    @src_channel.on("message")
+    def _on_msg(data: Any) -> None:
+        dst = dst_channels.get(label)
+        if dst is not None and dst.readyState == "open":
+            dst.send(data)
+
+
+# ─── HTTP API ───────────────────────────────────────────────────────────────
+
+
+app = FastAPI(title="DimOS Teleop Dev Broker")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+class SDPBody(BaseModel):
+    sdp: str
+    type: str
+
+
+class RegisterBody(SDPBody):
+    robot_id: str = ""
+    robot_name: str = ""
+
+
+@app.post("/api/v1/sessions")
+async def register_robot(body: RegisterBody) -> dict[str, str]:
+    """Robot registers — broker becomes the WebRTC peer answering its offer."""
+    session_id = str(uuid.uuid4())
+    robot_pc = RTCPeerConnection()
+
+    session = Session(
+        session_id=session_id,
+        robot_id=body.robot_id or "unknown",
+        robot_name=body.robot_name or body.robot_id or "unknown",
+        robot_pc=robot_pc,
+    )
+
+    @robot_pc.on("datachannel")
+    def _on_robot_dc(channel: Any) -> None:
+        logger.info(f"[{session.robot_name}] robot channel: '{channel.label}'")
+        session.robot_channels[channel.label] = channel
+        _wire_forwarding(channel.label, channel, session.operator_channels)
+
+    @robot_pc.on("connectionstatechange")
+    async def _on_state() -> None:
+        logger.info(f"[{session.robot_name}] robot PC: {robot_pc.connectionState}")
+
+    await robot_pc.setRemoteDescription(
+        RTCSessionDescription(sdp=body.sdp, type=body.type)
+    )
+    answer = await robot_pc.createAnswer()
+    await robot_pc.setLocalDescription(answer)
+
+    _sessions[session_id] = session
+    logger.info(f"[{session.robot_name}] registered, session_id={session_id}")
+
+    return {
+        "session_id": session_id,
+        "sdp": robot_pc.localDescription.sdp,
+        "type": robot_pc.localDescription.type,
+    }
+
+
+@app.delete("/api/v1/sessions/{session_id}")
+async def deregister(session_id: str) -> dict[str, bool]:
+    session = _sessions.pop(session_id, None)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    await session.robot_pc.close()
+    if session.operator_pc:
+        await session.operator_pc.close()
+    logger.info(f"[{session.robot_name}] deregistered")
+    return {"ok": True}
+
+
+@app.post("/api/v1/sessions/{session_id}/heartbeat")
+async def heartbeat(session_id: str) -> dict[str, bool]:
+    if session_id not in _sessions:
+        raise HTTPException(404, "Session not found")
+    return {"ok": True}
+
+
+@app.get("/api/v1/sessions")
+async def list_sessions() -> list[dict[str, Any]]:
+    return [
+        {
+            "session_id": s.session_id,
+            "robot_id": s.robot_id,
+            "robot_name": s.robot_name,
+            "operator_connected": s.operator_pc is not None,
+        }
+        for s in _sessions.values()
+    ]
+
+
+@app.post("/api/v1/sessions/{session_id}/join")
+async def operator_join(session_id: str, body: SDPBody) -> dict[str, str]:
+    """Operator joins — broker becomes the WebRTC peer answering their offer."""
+    session = _sessions.get(session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+
+    if session.operator_pc is not None:
+        # Replace existing operator (most recent wins).
+        await session.operator_pc.close()
+        session.operator_channels.clear()
+
+    operator_pc = RTCPeerConnection()
+    session.operator_pc = operator_pc
+
+    @operator_pc.on("datachannel")
+    def _on_op_dc(channel: Any) -> None:
+        logger.info(f"[{session.robot_name}] operator channel: '{channel.label}'")
+        session.operator_channels[channel.label] = channel
+        _wire_forwarding(channel.label, channel, session.robot_channels)
+
+    @operator_pc.on("connectionstatechange")
+    async def _on_state() -> None:
+        logger.info(
+            f"[{session.robot_name}] operator PC: {operator_pc.connectionState}"
+        )
+
+    await operator_pc.setRemoteDescription(
+        RTCSessionDescription(sdp=body.sdp, type=body.type)
+    )
+    answer = await operator_pc.createAnswer()
+    await operator_pc.setLocalDescription(answer)
+
+    logger.info(f"[{session.robot_name}] operator joined")
+    return {
+        "sdp": operator_pc.localDescription.sdp,
+        "type": operator_pc.localDescription.type,
+    }
+
+
+@app.post("/api/v1/sessions/{session_id}/leave")
+async def operator_leave(session_id: str) -> dict[str, bool]:
+    session = _sessions.get(session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    if session.operator_pc:
+        await session.operator_pc.close()
+        session.operator_pc = None
+        session.operator_channels.clear()
+    logger.info(f"[{session.robot_name}] operator left")
+    return {"ok": True}
+
+
+@app.get("/")
+async def index() -> dict[str, Any]:
+    return {
+        "service": "DimOS Teleop Dev Broker",
+        "active_sessions": len(_sessions),
+        "endpoints": [
+            "POST   /api/v1/sessions",
+            "DELETE /api/v1/sessions/:id",
+            "POST   /api/v1/sessions/:id/heartbeat",
+            "GET    /api/v1/sessions",
+            "POST   /api/v1/sessions/:id/join",
+            "POST   /api/v1/sessions/:id/leave",
+        ],
+        "operator_html": "/teleop",
+    }
+
+
+# Convenience: also serve the operator HTML so you can load it from the
+# same origin during local testing.
+@app.get("/teleop", response_class=HTMLResponse)
+async def serve_operator_html() -> HTMLResponse:
+    return HTMLResponse(content=(STATIC_DIR / "index.html").read_text())
+
+
+# ─── Entry point ────────────────────────────────────────────────────────────
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Local dev broker for hosted teleop")
+    parser.add_argument(
+        "--host",
+        default="0.0.0.0",
+        help="Bind address (default 0.0.0.0 — accessible from LAN)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Port (default 8000)",
+    )
+    args = parser.parse_args()
+
+    logger.info(f"Starting dev broker on http://{args.host}:{args.port}")
+    logger.info("  • Point dimos with --hosted-arm-teleop-module.broker-url=...")
+    logger.info(f"  • Operator HTML available at http://{args.host}:{args.port}/teleop")
+    logger.info("  • Production: replace this with the Cloudflare Worker broker.")
+
+    uvicorn.run(app, host=args.host, port=args.port, log_level="info")
+
+
+if __name__ == "__main__":
+    main()

From 7b59671523ff6e0382941193615eb96bcf929b0c Mon Sep 17 00:00:00 2001
From: ruthwikdasyam <ruthwikdasyam@gmail.com>
Date: Fri, 8 May 2026 12:18:44 -0700
Subject: [PATCH 5/9] fix: auth updates

---
 .../quest_hosted/hosted_teleop_module.py      | 21 +++--
 dimos/teleop/quest_hosted/static/index.html   | 91 ++++++++++++++++---
 2 files changed, 91 insertions(+), 21 deletions(-)

diff --git a/dimos/teleop/quest_hosted/hosted_teleop_module.py b/dimos/teleop/quest_hosted/hosted_teleop_module.py
index 1db829965e..043e46213f 100644
--- a/dimos/teleop/quest_hosted/hosted_teleop_module.py
+++ b/dimos/teleop/quest_hosted/hosted_teleop_module.py
@@ -270,14 +270,14 @@ def _on_gathering() -> None:
 
             await done
 
-        # Register with broker.
+        # Register with broker. Field names match dimensional-teleop's
+        # POST /api/v1/sessions schema (sdp_offer in, sdp_answer out).
         url = f"{self.config.broker_url.rstrip('/')}/api/v1/sessions"
         headers = self._auth_headers()
         body = {
             "robot_id": self.config.robot_id,
             "robot_name": self.config.robot_name,
-            "sdp": self._pc.localDescription.sdp,
-            "type": self._pc.localDescription.type,
+            "sdp_offer": self._pc.localDescription.sdp,
         }
         resp = await self._http.post(url, json=body, headers=headers)
         resp.raise_for_status()
@@ -285,9 +285,12 @@ def _on_gathering() -> None:
         self._session_id = data["session_id"]
 
         await self._pc.setRemoteDescription(
-            RTCSessionDescription(sdp=data["sdp"], type=data["type"])
+            RTCSessionDescription(sdp=data["sdp_answer"], type="answer")
+        )
+        logger.info(
+            f"Registered with broker: session_id={self._session_id}, "
+            f"cf_session_id={data.get('cf_session_id')}"
         )
-        logger.info(f"Registered with broker: session_id={self._session_id}")
 
     async def _disconnect(self) -> None:
         if self._http is not None and self._session_id is not None:
@@ -305,8 +308,14 @@ async def _disconnect(self) -> None:
         self._session_id = None
 
     def _auth_headers(self) -> dict[str, str]:
+        """Robot auth header — dimensional-teleop expects ``X-Robot-API-Key``.
+
+        The configured key must be registered server-side and mapped to a
+        ``robot_id`` matching ``config.robot_id``. The dev broker
+        (``dev_broker.py``) ignores auth entirely.
+        """
         if self.config.broker_api_key:
-            return {"Authorization": f"Bearer {self.config.broker_api_key}"}
+            return {"X-Robot-API-Key": self.config.broker_api_key}
         return {}
 
     # ─── Heartbeat ──────────────────────────────────────────────────────────
diff --git a/dimos/teleop/quest_hosted/static/index.html b/dimos/teleop/quest_hosted/static/index.html
index 642fca568e..70234a7d9a 100644
--- a/dimos/teleop/quest_hosted/static/index.html
+++ b/dimos/teleop/quest_hosted/static/index.html
@@ -55,9 +55,11 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
         <div id="status">Ready</div>
 
         <input id="broker-input" type="text" placeholder="Broker URL (https://teleop.dimensional-apps.com)" />
-        <input id="api-key-input" type="password" placeholder="API key (optional)" />
+        <input id="email-input" type="email" placeholder="Email" />
+        <input id="password-input" type="password" placeholder="Password" />
         <div class="row">
-            <button id="refreshBtn" onclick="refreshRobots()">List robots</button>
+            <button id="loginBtn" onclick="login()">Log in</button>
+            <button id="refreshBtn" class="hidden" onclick="refreshRobots()">List robots</button>
         </div>
         <select id="robot-select" class="hidden"></select>
         <button id="connectBtn" class="hidden" onclick="connect()">Connect</button>
@@ -85,22 +87,25 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
         // UI elements
         const statusEl = document.getElementById('status');
         const brokerInput = document.getElementById('broker-input');
-        const apiKeyInput = document.getElementById('api-key-input');
+        const emailInput = document.getElementById('email-input');
+        const passwordInput = document.getElementById('password-input');
+        const loginBtn = document.getElementById('loginBtn');
         const refreshBtn = document.getElementById('refreshBtn');
         const robotSelect = document.getElementById('robot-select');
         const connectBtn = document.getElementById('connectBtn');
         const disconnectBtn = document.getElementById('disconnectBtn');
         const canvas = document.getElementById('canvas');
 
+        let jwt = '';
+
         const urlParams = new URLSearchParams(window.location.search);
         brokerInput.value = urlParams.get('broker') || localStorage.getItem('dimos_broker') || '';
-        apiKeyInput.value = urlParams.get('api_key') || localStorage.getItem('dimos_api_key') || '';
+        emailInput.value = urlParams.get('email') || localStorage.getItem('dimos_email') || '';
 
         function setStatus(msg) { statusEl.textContent = msg; }
 
         function authHeaders() {
-            const k = apiKeyInput.value.trim();
-            return k ? { 'Authorization': `Bearer ${k}` } : {};
+            return jwt ? { 'Authorization': `Bearer ${jwt}` } : {};
         }
 
         function brokerUrl() {
@@ -109,13 +114,58 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
             return b;
         }
 
+        // POST /api/v1/auth/login. If account doesn't exist (401), auto-register.
+        window.login = async function() {
+            try {
+                loginBtn.disabled = true;
+                setStatus('Logging in...');
+                localStorage.setItem('dimos_broker', brokerInput.value.trim());
+                localStorage.setItem('dimos_email', emailInput.value.trim());
+
+                const creds = {
+                    email: emailInput.value.trim(),
+                    password: passwordInput.value,
+                };
+                if (!creds.email || !creds.password) {
+                    throw new Error('Enter email + password');
+                }
+
+                let resp = await fetch(`${brokerUrl()}/api/v1/auth/login`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(creds),
+                });
+                if (resp.status === 401) {
+                    // Auto-register on first run.
+                    setStatus('Creating account...');
+                    resp = await fetch(`${brokerUrl()}/api/v1/auth/register`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(creds),
+                    });
+                }
+                if (!resp.ok) throw new Error(`auth failed: ${resp.status}`);
+                const tokenData = await resp.json();
+                jwt = tokenData.token;
+
+                emailInput.classList.add('hidden');
+                passwordInput.classList.add('hidden');
+                loginBtn.classList.add('hidden');
+                refreshBtn.classList.remove('hidden');
+                setStatus(`Logged in as ${tokenData.user_id}`);
+            } catch (e) {
+                console.error(e);
+                setStatus(`Login failed: ${e.message}`);
+            } finally {
+                loginBtn.disabled = false;
+            }
+        };
+
         // GET /api/v1/sessions → populate robot dropdown
         window.refreshRobots = async function() {
             try {
                 refreshBtn.disabled = true;
                 setStatus('Fetching robot list...');
-                localStorage.setItem('dimos_broker', brokerInput.value.trim());
-                localStorage.setItem('dimos_api_key', apiKeyInput.value.trim());
 
                 const resp = await fetch(`${brokerUrl()}/api/v1/sessions`, {
                     headers: { ...authHeaders() }
@@ -185,13 +235,13 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...authHeaders() },
                 body: JSON.stringify({
-                    sdp: pc.localDescription.sdp,
-                    type: pc.localDescription.type
+                    role: 'operator',
+                    sdp_offer: pc.localDescription.sdp
                 })
             });
             if (!resp.ok) throw new Error(`broker join failed: ${resp.status}`);
-            const answer = await resp.json();
-            await pc.setRemoteDescription(answer);
+            const data = await resp.json();
+            await pc.setRemoteDescription({ type: 'answer', sdp: data.sdp_answer });
 
             await opened;
             setStatus('Connected');
@@ -316,14 +366,26 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
                 if (!navigator.xr) throw new Error('WebXR not supported. Use Quest 3 browser.');
                 const sessionId = robotSelect.value;
                 if (!sessionId) throw new Error('Pick a robot first');
-                await setupWebRTC(sessionId);
+
+                // Start VR FIRST while the user-gesture activation is still
+                // fresh. WebXR requires requestSession() inside the gesture;
+                // setupWebRTC's awaits would otherwise consume the token.
+                // Pose/joy frames sent before the channel is open are no-ops
+                // (processTracking gates on cmdChannel.readyState).
                 await startVR();
+
+                try {
+                    await setupWebRTC(sessionId);
+                } catch (rtcError) {
+                    if (xrSession) { await xrSession.end().catch(() => {}); xrSession = null; }
+                    throw rtcError;
+                }
+
                 connectBtn.classList.add('hidden');
                 disconnectBtn.classList.remove('hidden');
                 refreshBtn.classList.add('hidden');
                 robotSelect.classList.add('hidden');
                 brokerInput.classList.add('hidden');
-                apiKeyInput.classList.add('hidden');
             } catch (e) {
                 setStatus(`Connection failed: ${e.message}`);
                 console.error(e);
@@ -341,7 +403,6 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
             disconnectBtn.classList.add('hidden');
             refreshBtn.classList.remove('hidden');
             brokerInput.classList.remove('hidden');
-            apiKeyInput.classList.remove('hidden');
             setStatus('Ready');
         };
     </script>

From 4e31bae2028088696d31b892329e6c330ab33b8a Mon Sep 17 00:00:00 2001
From: ruthwikdasyam <ruthwikdasyam@gmail.com>
Date: Fri, 8 May 2026 16:35:44 -0700
Subject: [PATCH 6/9] updated html + web address

---
 .../quest_hosted/hosted_teleop_module.py      |   6 +-
 dimos/teleop/quest_hosted/static/index.html   | 658 +++++++++++-------
 2 files changed, 421 insertions(+), 243 deletions(-)

diff --git a/dimos/teleop/quest_hosted/hosted_teleop_module.py b/dimos/teleop/quest_hosted/hosted_teleop_module.py
index 043e46213f..91f4b52ee4 100644
--- a/dimos/teleop/quest_hosted/hosted_teleop_module.py
+++ b/dimos/teleop/quest_hosted/hosted_teleop_module.py
@@ -76,7 +76,11 @@ class HostedTeleopConfig(ModuleConfig):
     # Broker — the microservice that mediates SDP exchange with Cloudflare
     # Realtime. Robots and operators only ever talk to this; Cloudflare
     # credentials live on the broker.
-    broker_url: str = "https://teleop.dimensional-apps.com"
+    # Production: https://teleop.dimensionalos.com (deployed from
+    # https://github.com/dimensionalOS/dimensional-teleop)
+    # Local dev:  http://localhost:8000 (dev_broker.py)
+    #             or http://localhost:8450 (dimensional-teleop run locally)
+    broker_url: str = "https://teleop.dimensionalos.com"
     broker_api_key: str = ""
 
     # Robot identity for the broker's session list.
diff --git a/dimos/teleop/quest_hosted/static/index.html b/dimos/teleop/quest_hosted/static/index.html
index 70234a7d9a..a627a587b7 100644
--- a/dimos/teleop/quest_hosted/static/index.html
+++ b/dimos/teleop/quest_hosted/static/index.html
@@ -3,210 +3,420 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>DimOS Teleop (Hosted)</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-            background: #fff; color: #333;
-            display: flex; flex-direction: column;
-            align-items: center; justify-content: center;
-            height: 100vh; overflow: hidden;
-        }
-        #ui {
-            position: absolute; inset: 0;
-            display: flex; flex-direction: column;
-            align-items: center; justify-content: center;
-            z-index: 100; gap: 16px;
-        }
-        h1 { font-size: 36px; font-weight: 600; color: #28283b; }
-        h2 { font-size: 18px; font-weight: 400; color: #6c757d; margin-bottom: 16px; }
-        #status {
-            font-size: 22px; font-weight: 500; color: #0077b6;
-            padding: 12px 24px; border: 2px solid #0077b6; border-radius: 12px;
-            min-width: 320px; text-align: center;
-        }
-        input, select {
-            font-size: 16px; padding: 10px 14px;
-            border: 1px solid #ccc; border-radius: 8px;
-            width: 360px; text-align: left;
-        }
-        button {
-            padding: 16px 36px; font-size: 20px; font-weight: 600;
-            color: white; background: #0077b6; border: none; border-radius: 12px;
-            cursor: pointer; transition: background-color .2s;
-        }
-        button:hover { background: #005f8a; }
-        button:disabled { background: #adb5bd; cursor: not-allowed; }
-        button.secondary { background: #6c757d; }
-        button.secondary:hover { background: #545b62; }
-        #canvas {
-            display: none; position: absolute; inset: 0;
-            width: 100%; height: 100%;
+    <title>DimOS Teleop</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script>
+        tailwind.config = {
+            theme: { extend: { colors: {
+                dim: { 50:'#f0f9ff',100:'#e0f2fe',500:'#0ea5e9',600:'#0284c7',700:'#0369a1',900:'#0c4a6e' }
+            }}}
         }
-        .hidden { display: none !important; }
-        .row { display: flex; gap: 8px; align-items: center; }
+    </script>
+    <style>
+        body { font-family: 'Inter', system-ui, sans-serif; }
+        .fade-in { animation: fadeIn 0.3s ease-in; }
+        @keyframes fadeIn { from { opacity: 0; transform: translateY(8px); } to { opacity: 1; transform: translateY(0); } }
+        .key-reveal { font-family: 'JetBrains Mono', monospace; word-break: break-all; }
+        #canvas { display: none; position: absolute; inset: 0; width: 100%; height: 100%; }
     </style>
 </head>
-<body>
-    <div id="ui">
-        <h1>DimOS Teleop</h1>
-        <h2>Hosted client (Cloudflare Realtime)</h2>
-        <div id="status">Ready</div>
-
-        <input id="broker-input" type="text" placeholder="Broker URL (https://teleop.dimensional-apps.com)" />
-        <input id="email-input" type="email" placeholder="Email" />
-        <input id="password-input" type="password" placeholder="Password" />
-        <div class="row">
-            <button id="loginBtn" onclick="login()">Log in</button>
-            <button id="refreshBtn" class="hidden" onclick="refreshRobots()">List robots</button>
-        </div>
-        <select id="robot-select" class="hidden"></select>
-        <button id="connectBtn" class="hidden" onclick="connect()">Connect</button>
-        <button id="disconnectBtn" class="hidden secondary" onclick="disconnect()">Disconnect</button>
-    </div>
+<body class="bg-gray-950 text-gray-100 min-h-screen">
+    <div id="app"></div>
     <canvas id="canvas"></canvas>
 
     <script type="module">
-        window.onerror = (msg, url, line, col, error) => {
-            console.error(`[ERROR] ${msg} at ${url}:${line}:${col}`, error);
-            document.getElementById('status').textContent = `Error: ${msg}`;
-        };
-
         import { geometry_msgs, std_msgs, sensor_msgs } from "https://esm.sh/jsr/@dimos/msgs@0.1.4";
 
-        // State
+        // ─── State ──────────────────────────────────────────────────────────
+        let token = localStorage.getItem('teleop_token') || '';
+        let userEmail = localStorage.getItem('teleop_email') || '';
+
+        // The broker is always the origin this page was served from. We do
+        // NOT accept a ?broker= override — that would be a credential-
+        // exfiltration vector (the login form would POST to whatever URL an
+        // attacker put in the query string). For local dev, run dev_broker.py
+        // which serves this HTML at /teleop on the same origin.
+
+        // WebRTC + WebXR state
         let pc = null;
         let cmdChannel = null;
         let xrSession = null;
         let xrRefSpace = null;
         let gl = null;
         let lastSendTime = 0;
-        const sendInterval = 1000 / 80; // 80 Hz
-
-        // UI elements
-        const statusEl = document.getElementById('status');
-        const brokerInput = document.getElementById('broker-input');
-        const emailInput = document.getElementById('email-input');
-        const passwordInput = document.getElementById('password-input');
-        const loginBtn = document.getElementById('loginBtn');
-        const refreshBtn = document.getElementById('refreshBtn');
-        const robotSelect = document.getElementById('robot-select');
-        const connectBtn = document.getElementById('connectBtn');
-        const disconnectBtn = document.getElementById('disconnectBtn');
-        const canvas = document.getElementById('canvas');
-
-        let jwt = '';
-
-        const urlParams = new URLSearchParams(window.location.search);
-        brokerInput.value = urlParams.get('broker') || localStorage.getItem('dimos_broker') || '';
-        emailInput.value = urlParams.get('email') || localStorage.getItem('dimos_email') || '';
-
-        function setStatus(msg) { statusEl.textContent = msg; }
-
-        function authHeaders() {
-            return jwt ? { 'Authorization': `Bearer ${jwt}` } : {};
+        let activeRobot = null;
+        const sendInterval = 1000 / 80;
+
+        // ─── API helpers ────────────────────────────────────────────────────
+        async function api(method, path, body = null) {
+            const opts = { method, headers: { 'Content-Type': 'application/json' } };
+            if (token) opts.headers['Authorization'] = `Bearer ${token}`;
+            if (body) opts.body = JSON.stringify(body);
+            const res = await fetch(`/api/v1${path}`, opts);
+            if (res.status === 401) { logout(); throw new Error('Unauthorized'); }
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok) throw new Error(data.detail || `HTTP ${res.status}`);
+            return data;
         }
 
-        function brokerUrl() {
-            const b = brokerInput.value.trim().replace(/\/$/, '');
-            if (!b) throw new Error('Enter the broker URL');
-            return b;
+        function logout() {
+            localStorage.removeItem('teleop_token');
+            localStorage.removeItem('teleop_email');
+            token = '';
+            userEmail = '';
+            navigate('auth');
         }
 
-        // POST /api/v1/auth/login. If account doesn't exist (401), auto-register.
-        window.login = async function() {
+        function escHtml(s) {
+            return s ? String(s).replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c])) : '';
+        }
+
+        function timeAgo(iso) {
+            const diff = Date.now() - new Date(iso).getTime();
+            const mins = Math.floor(diff / 60000);
+            if (mins < 1) return 'just now';
+            if (mins < 60) return `${mins}m ago`;
+            const hrs = Math.floor(mins / 60);
+            if (hrs < 24) return `${hrs}h ago`;
+            return `${Math.floor(hrs/24)}d ago`;
+        }
+
+        // ─── Router ─────────────────────────────────────────────────────────
+        function navigate(view) {
+            const app = document.getElementById('app');
+            if (view === 'auth') renderAuth(app);
+            else if (view === 'dashboard') renderDashboard(app);
+            else if (view === 'teleop') renderTeleop(app);
+        }
+
+        // ─── Auth view ──────────────────────────────────────────────────────
+        let authMode = 'login';
+
+        function renderAuth(c) {
+            c.innerHTML = `
+            <div class="min-h-screen flex items-center justify-center p-4">
+                <div class="w-full max-w-md">
+                    <div class="text-center mb-8">
+                        <h1 class="text-3xl font-bold text-white mb-2">DimOS Teleop</h1>
+                        <p class="text-gray-400">Remote robot teleoperation platform</p>
+                    </div>
+                    <div class="bg-gray-900 border border-gray-800 rounded-xl p-6 shadow-xl">
+                        <div class="flex mb-6 bg-gray-800 rounded-lg p-1">
+                            <button id="tab-login" class="flex-1 py-2 px-4 rounded-md text-sm font-medium bg-dim-600 text-white">Log In</button>
+                            <button id="tab-register" class="flex-1 py-2 px-4 rounded-md text-sm font-medium text-gray-400 hover:text-white">Sign Up</button>
+                        </div>
+                        <form id="auth-form">
+                            <div class="space-y-4">
+                                <div>
+                                    <label class="block text-sm font-medium text-gray-300 mb-1">Email</label>
+                                    <input id="email" type="email" required value="${escHtml(userEmail)}"
+                                        class="w-full px-4 py-2.5 bg-gray-800 border border-gray-700 rounded-lg text-white placeholder-gray-500 focus:outline-none focus:ring-2 focus:ring-dim-500"
+                                        placeholder="you@company.com">
+                                </div>
+                                <div>
+                                    <label class="block text-sm font-medium text-gray-300 mb-1">Password</label>
+                                    <input id="password" type="password" required
+                                        class="w-full px-4 py-2.5 bg-gray-800 border border-gray-700 rounded-lg text-white placeholder-gray-500 focus:outline-none focus:ring-2 focus:ring-dim-500"
+                                        placeholder="••••••••">
+                                </div>
+                                <div id="auth-error" class="text-red-400 text-sm hidden"></div>
+                                <button type="submit" class="w-full py-2.5 bg-dim-600 hover:bg-dim-700 text-white font-medium rounded-lg transition-colors">
+                                    <span id="auth-btn-text">Log In</span>
+                                </button>
+                            </div>
+                        </form>
+                    </div>
+                    <p class="text-center text-gray-500 text-sm mt-6">
+                        Powered by <a href="https://dimensionalos.com" class="text-dim-500 hover:text-dim-400">DimensionalOS</a>
+                    </p>
+                </div>
+            </div>`;
+
+            document.getElementById('tab-login').onclick = () => showAuthTab('login');
+            document.getElementById('tab-register').onclick = () => showAuthTab('register');
+            document.getElementById('auth-form').onsubmit = handleAuth;
+        }
+
+        function showAuthTab(mode) {
+            authMode = mode;
+            const active = 'flex-1 py-2 px-4 rounded-md text-sm font-medium bg-dim-600 text-white';
+            const inactive = 'flex-1 py-2 px-4 rounded-md text-sm font-medium text-gray-400 hover:text-white';
+            document.getElementById('tab-login').className = mode === 'login' ? active : inactive;
+            document.getElementById('tab-register').className = mode === 'register' ? active : inactive;
+            document.getElementById('auth-btn-text').textContent = mode === 'login' ? 'Log In' : 'Create Account';
+        }
+
+        async function handleAuth(e) {
+            e.preventDefault();
+            const email = document.getElementById('email').value.trim();
+            const password = document.getElementById('password').value;
+            const errEl = document.getElementById('auth-error');
+            errEl.classList.add('hidden');
             try {
-                loginBtn.disabled = true;
-                setStatus('Logging in...');
-                localStorage.setItem('dimos_broker', brokerInput.value.trim());
-                localStorage.setItem('dimos_email', emailInput.value.trim());
-
-                const creds = {
-                    email: emailInput.value.trim(),
-                    password: passwordInput.value,
-                };
-                if (!creds.email || !creds.password) {
-                    throw new Error('Enter email + password');
-                }
+                const endpoint = authMode === 'login' ? '/auth/login' : '/auth/register';
+                const data = await api('POST', endpoint, { email, password });
+                token = data.token;
+                userEmail = data.user_id;
+                localStorage.setItem('teleop_token', token);
+                localStorage.setItem('teleop_email', userEmail);
+                navigate('dashboard');
+            } catch (err) {
+                errEl.textContent = err.message;
+                errEl.classList.remove('hidden');
+            }
+        }
 
-                let resp = await fetch(`${brokerUrl()}/api/v1/auth/login`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(creds),
-                });
-                if (resp.status === 401) {
-                    // Auto-register on first run.
-                    setStatus('Creating account...');
-                    resp = await fetch(`${brokerUrl()}/api/v1/auth/register`, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify(creds),
-                    });
+        // ─── Dashboard view (API keys + robot list) ─────────────────────────
+        async function renderDashboard(c) {
+            c.innerHTML = `
+            <div class="max-w-4xl mx-auto p-6 fade-in">
+                <header class="flex items-center justify-between mb-8">
+                    <div>
+                        <h1 class="text-2xl font-bold text-white">Dashboard</h1>
+                        <p class="text-gray-400 text-sm">${escHtml(userEmail)}</p>
+                    </div>
+                    <button id="logoutBtn" class="px-4 py-2 text-sm text-gray-400 hover:text-white border border-gray-700 rounded-lg hover:border-gray-600 transition-colors">
+                        Log Out
+                    </button>
+                </header>
+
+                <!-- API Keys -->
+                <section class="bg-gray-900 border border-gray-800 rounded-xl p-6 mb-6">
+                    <div class="flex items-center justify-between mb-4">
+                        <div>
+                            <h2 class="text-lg font-semibold text-white">API Keys</h2>
+                            <p class="text-gray-400 text-sm">Authenticate your robots with the teleop service</p>
+                        </div>
+                        <button id="newKeyBtn" class="px-4 py-2 bg-dim-600 hover:bg-dim-700 text-white text-sm font-medium rounded-lg transition-colors">
+                            + New Key
+                        </button>
+                    </div>
+
+                    <div id="create-key-form" class="hidden mb-4 p-4 bg-gray-800 rounded-lg border border-gray-700">
+                        <div class="grid grid-cols-1 md:grid-cols-2 gap-3 mb-3">
+                            <input id="key-name" type="text" placeholder="Key name (e.g. Lab Robot 01)"
+                                class="px-3 py-2 bg-gray-900 border border-gray-700 rounded-lg text-white placeholder-gray-500 text-sm focus:outline-none focus:ring-2 focus:ring-dim-500">
+                            <input id="key-robot-id" type="text" placeholder="Robot ID (optional)"
+                                class="px-3 py-2 bg-gray-900 border border-gray-700 rounded-lg text-white placeholder-gray-500 text-sm focus:outline-none focus:ring-2 focus:ring-dim-500">
+                        </div>
+                        <div class="flex gap-2">
+                            <button id="generateKeyBtn" class="px-4 py-2 bg-dim-600 hover:bg-dim-700 text-white text-sm rounded-lg transition-colors">Generate Key</button>
+                            <button id="cancelKeyBtn" class="px-4 py-2 text-gray-400 hover:text-white text-sm rounded-lg transition-colors">Cancel</button>
+                        </div>
+                    </div>
+
+                    <div id="new-key-reveal" class="hidden mb-4 p-4 bg-green-900/20 border border-green-800 rounded-lg">
+                        <p class="text-green-400 text-sm font-medium mb-2">🔑 Key created! Copy it now — it won't be shown again.</p>
+                        <div class="flex items-center gap-2">
+                            <code id="new-key-value" class="key-reveal flex-1 px-3 py-2 bg-gray-900 rounded text-green-300 text-sm"></code>
+                            <button id="copyKeyBtn" class="px-3 py-2 bg-gray-700 hover:bg-gray-600 rounded text-sm text-white transition-colors">Copy</button>
+                        </div>
+                        <p class="text-gray-500 text-xs mt-2">Use it as <code>broker_api_key</code> when starting <code>HostedTeleopModule</code>.</p>
+                    </div>
+
+                    <div id="keys-list" class="space-y-2">
+                        <div class="text-gray-500 text-sm py-4 text-center">Loading...</div>
+                    </div>
+                </section>
+
+                <!-- Connected robots -->
+                <section class="bg-gray-900 border border-gray-800 rounded-xl p-6">
+                    <div class="flex items-center justify-between mb-4">
+                        <div>
+                            <h2 class="text-lg font-semibold text-white">Available Robots</h2>
+                            <p class="text-gray-400 text-sm">Robots online — click Connect to teleoperate</p>
+                        </div>
+                        <button id="refreshRobotsBtn" class="px-4 py-2 text-sm text-gray-300 border border-gray-700 rounded-lg hover:bg-gray-800 transition-colors">
+                            Refresh
+                        </button>
+                    </div>
+                    <div id="robots-list" class="space-y-2">
+                        <div class="text-gray-500 text-sm py-4 text-center">Loading...</div>
+                    </div>
+                </section>
+
+                <p class="text-center text-xs text-gray-600 mt-6">
+                    Broker: <code>${escHtml(window.location.origin)}</code>
+                </p>
+            </div>`;
+
+            document.getElementById('logoutBtn').onclick = logout;
+            document.getElementById('newKeyBtn').onclick = () => document.getElementById('create-key-form').classList.remove('hidden');
+            document.getElementById('cancelKeyBtn').onclick = () => document.getElementById('create-key-form').classList.add('hidden');
+            document.getElementById('generateKeyBtn').onclick = createKey;
+            document.getElementById('copyKeyBtn').onclick = copyKey;
+            document.getElementById('refreshRobotsBtn').onclick = loadRobots;
+
+            await Promise.all([loadKeys(), loadRobots()]);
+        }
+
+        // ─── API Keys ───────────────────────────────────────────────────────
+        async function createKey() {
+            const name = document.getElementById('key-name').value.trim();
+            const robotId = document.getElementById('key-robot-id').value.trim() || null;
+            if (!name) { alert('Please provide a key name'); return; }
+            try {
+                const data = await api('POST', '/keys', { name, robot_id: robotId });
+                document.getElementById('new-key-value').textContent = data.api_key;
+                document.getElementById('new-key-reveal').classList.remove('hidden');
+                document.getElementById('create-key-form').classList.add('hidden');
+                document.getElementById('key-name').value = '';
+                document.getElementById('key-robot-id').value = '';
+                await loadKeys();
+            } catch (err) {
+                alert('Failed to create key: ' + err.message);
+            }
+        }
+
+        function copyKey() {
+            const key = document.getElementById('new-key-value').textContent;
+            navigator.clipboard.writeText(key);
+            const btn = document.getElementById('copyKeyBtn');
+            btn.textContent = 'Copied!';
+            setTimeout(() => { btn.textContent = 'Copy'; }, 2000);
+        }
+
+        async function loadKeys() {
+            const listEl = document.getElementById('keys-list');
+            try {
+                const data = await api('GET', '/keys');
+                if (!data.keys || data.keys.length === 0) {
+                    listEl.innerHTML = '<p class="text-gray-500 text-sm py-4 text-center">No API keys yet. Create one to connect a robot.</p>';
+                    return;
                 }
-                if (!resp.ok) throw new Error(`auth failed: ${resp.status}`);
-                const tokenData = await resp.json();
-                jwt = tokenData.token;
-
-                emailInput.classList.add('hidden');
-                passwordInput.classList.add('hidden');
-                loginBtn.classList.add('hidden');
-                refreshBtn.classList.remove('hidden');
-                setStatus(`Logged in as ${tokenData.user_id}`);
-            } catch (e) {
-                console.error(e);
-                setStatus(`Login failed: ${e.message}`);
-            } finally {
-                loginBtn.disabled = false;
+                listEl.innerHTML = data.keys.map(k => `
+                    <div class="flex items-center justify-between p-3 bg-gray-800 rounded-lg">
+                        <div class="flex-1 min-w-0">
+                            <div class="flex items-center gap-2">
+                                <span class="text-white text-sm font-medium">${escHtml(k.name)}</span>
+                                ${k.robot_id ? `<span class="text-xs px-2 py-0.5 bg-gray-700 rounded text-gray-300">${escHtml(k.robot_id)}</span>` : ''}
+                            </div>
+                            <div class="flex items-center gap-3 mt-1">
+                                <code class="text-gray-400 text-xs">${escHtml(k.key_prefix)}...</code>
+                                <span class="text-gray-600 text-xs">${k.last_used_at ? 'Last used ' + timeAgo(k.last_used_at) : 'Never used'}</span>
+                            </div>
+                        </div>
+                        <button data-id="${k.id}" data-name="${escHtml(k.name)}"
+                            class="revoke-btn px-3 py-1.5 text-xs text-red-400 hover:text-red-300 hover:bg-red-900/20 rounded transition-colors">
+                            Revoke
+                        </button>
+                    </div>
+                `).join('');
+                listEl.querySelectorAll('.revoke-btn').forEach(btn => {
+                    btn.addEventListener('click', (e) => {
+                        revokeKey(e.target.dataset.id, e.target.dataset.name);
+                    });
+                });
+            } catch (err) {
+                listEl.innerHTML = `<p class="text-red-400 text-sm">${escHtml(err.message)}</p>`;
             }
-        };
+        }
 
-        // GET /api/v1/sessions → populate robot dropdown
-        window.refreshRobots = async function() {
+        async function revokeKey(id, name) {
+            if (!confirm(`Revoke key "${name}"? This cannot be undone.`)) return;
             try {
-                refreshBtn.disabled = true;
-                setStatus('Fetching robot list...');
+                await api('DELETE', `/keys/${id}`);
+                document.getElementById('new-key-reveal').classList.add('hidden');
+                await loadKeys();
+            } catch (err) {
+                alert('Failed to revoke: ' + err.message);
+            }
+        }
 
-                const resp = await fetch(`${brokerUrl()}/api/v1/sessions`, {
-                    headers: { ...authHeaders() }
-                });
-                if (!resp.ok) throw new Error(`broker returned ${resp.status}`);
-                const robots = await resp.json();
-
-                robotSelect.innerHTML = '';
-                if (!Array.isArray(robots) || robots.length === 0) {
-                    setStatus('No robots online');
-                    robotSelect.classList.add('hidden');
-                    connectBtn.classList.add('hidden');
+        // ─── Robot list ─────────────────────────────────────────────────────
+        async function loadRobots() {
+            const listEl = document.getElementById('robots-list');
+            try {
+                const robots = await api('GET', '/sessions');
+                // Broker returns a flat list per sessions.py:list_sessions response_model.
+                const arr = Array.isArray(robots) ? robots : (robots.sessions || []);
+                if (arr.length === 0) {
+                    listEl.innerHTML = '<p class="text-gray-500 text-sm py-4 text-center">No robots online. Start a robot with a registered API key.</p>';
                     return;
                 }
-                for (const r of robots) {
-                    const opt = document.createElement('option');
-                    opt.value = r.session_id;
-                    opt.textContent = `${r.robot_name || r.robot_id || r.session_id}`;
-                    robotSelect.appendChild(opt);
+                listEl.innerHTML = arr.map(s => `
+                    <div class="flex items-center justify-between p-3 bg-gray-800 rounded-lg">
+                        <div class="flex items-center gap-3">
+                            <div class="w-2 h-2 rounded-full ${s.state === 'active' ? 'bg-green-400' : s.state === 'idle' ? 'bg-yellow-400' : 'bg-gray-500'}"></div>
+                            <div>
+                                <span class="text-white text-sm font-medium">${escHtml(s.robot_name)}</span>
+                                <span class="text-gray-500 text-xs ml-2">${escHtml(s.robot_id)}</span>
+                                ${s.rtt_ms ? `<span class="text-gray-500 text-xs ml-2">${Math.round(s.rtt_ms)}ms</span>` : ''}
+                            </div>
+                        </div>
+                        <button data-id="${s.session_id}" data-name="${escHtml(s.robot_name)}"
+                            class="connect-btn px-4 py-2 bg-dim-600 hover:bg-dim-700 text-white text-sm rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+                            ${s.state === 'active' ? 'disabled' : ''}>
+                            ${s.state === 'active' ? 'Busy' : 'Connect'}
+                        </button>
+                    </div>
+                `).join('');
+                listEl.querySelectorAll('.connect-btn').forEach(btn => {
+                    btn.addEventListener('click', (e) => {
+                        connectToRobot(e.target.dataset.id, e.target.dataset.name);
+                    });
+                });
+            } catch (err) {
+                listEl.innerHTML = `<p class="text-red-400 text-sm py-4 text-center">${escHtml(err.message)}</p>`;
+            }
+        }
+
+        // ─── Connect (called from Connect button — user-gesture context) ────
+        async function connectToRobot(sessionId, robotName) {
+            activeRobot = { session_id: sessionId, robot_name: robotName };
+            try {
+                if (!navigator.xr) throw new Error('WebXR not supported. Use Quest 3 browser.');
+
+                navigate('teleop');
+                // VR FIRST — gesture activation must be alive when requestSession() runs.
+                await startVR();
+
+                try {
+                    await setupWebRTC(sessionId);
+                } catch (rtcError) {
+                    if (xrSession) { await xrSession.end().catch(() => {}); xrSession = null; }
+                    throw rtcError;
                 }
-                robotSelect.classList.remove('hidden');
-                connectBtn.classList.remove('hidden');
-                setStatus(`${robots.length} robot(s) available`);
+                setStatus(`Connected — ${robotName}`);
             } catch (e) {
                 console.error(e);
-                setStatus(`List failed: ${e.message}`);
-            } finally {
-                refreshBtn.disabled = false;
+                setStatus(`Connection failed: ${e.message}`);
+                setTimeout(() => navigate('dashboard'), 3000);
             }
-        };
+        }
+
+        // ─── Teleop view ────────────────────────────────────────────────────
+        function renderTeleop(c) {
+            c.innerHTML = `
+            <div class="min-h-screen flex flex-col items-center justify-center p-6 fade-in">
+                <div class="w-full max-w-md text-center">
+                    <h1 class="text-3xl font-bold text-white mb-2">${escHtml(activeRobot?.robot_name || 'Teleop')}</h1>
+                    <div id="teleop-status" class="text-lg text-gray-300 px-4 py-3 bg-gray-900 border border-gray-800 rounded-lg my-4">
+                        Negotiating...
+                    </div>
+                    <button id="disconnectBtn" class="mt-4 px-6 py-2.5 bg-gray-700 hover:bg-gray-600 text-white text-sm font-medium rounded-lg transition-colors">
+                        Disconnect
+                    </button>
+                </div>
+            </div>`;
+            document.getElementById('disconnectBtn').onclick = disconnect;
+        }
+
+        function setStatus(msg) {
+            const el = document.getElementById('teleop-status');
+            if (el) el.textContent = msg;
+        }
 
+        // ─── WebRTC ─────────────────────────────────────────────────────────
         async function setupWebRTC(sessionId) {
             setStatus('Negotiating WebRTC...');
             pc = new RTCPeerConnection({
                 iceServers: [{ urls: 'stun:stun.cloudflare.com:3478' }]
             });
 
-            // Operator → robot. UDP-like, drop stale frames.
             cmdChannel = pc.createDataChannel('cmd_unreliable', {
                 ordered: false,
-                maxRetransmits: 0
+                maxRetransmits: 0,
             });
             cmdChannel.binaryType = 'arraybuffer';
 
@@ -224,6 +434,7 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
             const offer = await pc.createOffer();
             await pc.setLocalDescription(offer);
 
+            // Non-trickle ICE
             await new Promise(resolve => {
                 if (pc.iceGatheringState === 'complete') return resolve();
                 pc.onicegatheringstatechange = () => {
@@ -231,20 +442,13 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
                 };
             });
 
-            const resp = await fetch(`${brokerUrl()}/api/v1/sessions/${sessionId}/join`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', ...authHeaders() },
-                body: JSON.stringify({
-                    role: 'operator',
-                    sdp_offer: pc.localDescription.sdp
-                })
+            const data = await api('POST', `/sessions/${sessionId}/join`, {
+                role: 'operator',
+                sdp_offer: pc.localDescription.sdp,
             });
-            if (!resp.ok) throw new Error(`broker join failed: ${resp.status}`);
-            const data = await resp.json();
             await pc.setRemoteDescription({ type: 'answer', sdp: data.sdp_answer });
 
             await opened;
-            setStatus('Connected');
         }
 
         function send(bytes) {
@@ -253,7 +457,9 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
             }
         }
 
+        // ─── WebXR ──────────────────────────────────────────────────────────
         function initGL() {
+            const canvas = document.getElementById('canvas');
             gl = canvas.getContext('webgl', { xrCompatible: true, alpha: true });
             if (!gl) throw new Error('WebGL not supported');
             gl.clearColor(0, 0, 0, 0);
@@ -276,21 +482,17 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
                 const pos = pose.transform.position;
                 const rot = pose.transform.orientation;
                 const nowMs = Date.now();
+                const stamp = new std_msgs.Time({
+                    sec: Math.floor(nowMs / 1000),
+                    nsec: (nowMs % 1000) * 1_000_000,
+                });
 
                 const poseStamped = new geometry_msgs.PoseStamped({
-                    header: new std_msgs.Header({
-                        stamp: new std_msgs.Time({
-                            sec: Math.floor(nowMs / 1000),
-                            nsec: (nowMs % 1000) * 1_000_000
-                        }),
-                        frame_id: handedness
-                    }),
+                    header: new std_msgs.Header({ stamp, frame_id: handedness }),
                     pose: new geometry_msgs.Pose({
                         position: new geometry_msgs.Point({ x: pos.x, y: pos.y, z: pos.z }),
-                        orientation: new geometry_msgs.Quaternion({
-                            x: rot.x, y: rot.y, z: rot.z, w: rot.w
-                        })
-                    })
+                        orientation: new geometry_msgs.Quaternion({ x: rot.x, y: rot.y, z: rot.z, w: rot.w }),
+                    }),
                 });
                 send(poseStamped.encode());
 
@@ -300,24 +502,18 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
                         gamepad.axes[0] ?? 0.0,
                         gamepad.axes[1] ?? 0.0,
                         gamepad.buttons[0]?.value ?? 0.0,
-                        gamepad.buttons[1]?.value ?? 0.0
+                        gamepad.buttons[1]?.value ?? 0.0,
                     ];
                     const buttons = [];
                     for (let i = 0; i < gamepad.buttons.length; i++) {
                         buttons.push(gamepad.buttons[i]?.pressed ? 1 : 0);
                     }
                     const joyMsg = new sensor_msgs.Joy({
-                        header: new std_msgs.Header({
-                            stamp: new std_msgs.Time({
-                                sec: Math.floor(nowMs / 1000),
-                                nsec: (nowMs % 1000) * 1_000_000
-                            }),
-                            frame_id: handedness
-                        }),
+                        header: new std_msgs.Header({ stamp, frame_id: handedness }),
                         axes_length: axes.length,
                         buttons_length: buttons.length,
-                        axes: axes,
-                        buttons: buttons
+                        axes,
+                        buttons,
                     });
                     send(joyMsg.encode());
                 }
@@ -332,79 +528,57 @@ <h2>Hosted client (Cloudflare Realtime)</h2>
         }
 
         async function startVR() {
-            setStatus('Initializing WebGL...');
+            const canvas = document.getElementById('canvas');
+            canvas.style.display = 'block';
             initGL();
-            setStatus('Requesting VR session...');
+
             let session = null;
             try {
                 session = await navigator.xr.requestSession('immersive-ar', {
                     requiredFeatures: ['local-floor'],
-                    optionalFeatures: ['hand-tracking']
+                    optionalFeatures: ['hand-tracking'],
                 });
             } catch (e) {
                 session = await navigator.xr.requestSession('immersive-vr', {
                     requiredFeatures: ['local-floor'],
-                    optionalFeatures: ['hand-tracking']
+                    optionalFeatures: ['hand-tracking'],
                 });
             }
+
             xrSession = session;
             const glLayer = new XRWebGLLayer(session, gl);
             await session.updateRenderState({ baseLayer: glLayer });
             xrRefSpace = await session.requestReferenceSpace('local-floor');
-            setStatus('VR active');
+
             session.addEventListener('end', () => {
-                setStatus('VR session ended');
                 xrSession = null;
                 disconnect();
             });
             session.requestAnimationFrame(onXRFrame);
         }
 
-        window.connect = async function() {
+        // ─── Disconnect ─────────────────────────────────────────────────────
+        async function disconnect() {
             try {
-                connectBtn.disabled = true;
-                if (!navigator.xr) throw new Error('WebXR not supported. Use Quest 3 browser.');
-                const sessionId = robotSelect.value;
-                if (!sessionId) throw new Error('Pick a robot first');
-
-                // Start VR FIRST while the user-gesture activation is still
-                // fresh. WebXR requires requestSession() inside the gesture;
-                // setupWebRTC's awaits would otherwise consume the token.
-                // Pose/joy frames sent before the channel is open are no-ops
-                // (processTracking gates on cmdChannel.readyState).
-                await startVR();
-
-                try {
-                    await setupWebRTC(sessionId);
-                } catch (rtcError) {
-                    if (xrSession) { await xrSession.end().catch(() => {}); xrSession = null; }
-                    throw rtcError;
+                if (activeRobot && token) {
+                    api('POST', `/sessions/${activeRobot.session_id}/leave`, { reason: 'user_initiated' })
+                        .catch(() => {});
                 }
+            } catch (_) {}
 
-                connectBtn.classList.add('hidden');
-                disconnectBtn.classList.remove('hidden');
-                refreshBtn.classList.add('hidden');
-                robotSelect.classList.add('hidden');
-                brokerInput.classList.add('hidden');
-            } catch (e) {
-                setStatus(`Connection failed: ${e.message}`);
-                console.error(e);
-                connectBtn.disabled = false;
-            }
-        };
-
-        window.disconnect = async function() {
-            setStatus('Disconnecting...');
-            if (xrSession) { await xrSession.end().catch(console.error); xrSession = null; }
+            if (xrSession) { await xrSession.end().catch(() => {}); xrSession = null; }
             if (cmdChannel) { try { cmdChannel.close(); } catch (_) {} cmdChannel = null; }
-            if (pc)         { try { pc.close(); }         catch (_) {} pc = null; }
-            connectBtn.classList.remove('hidden');
-            connectBtn.disabled = false;
-            disconnectBtn.classList.add('hidden');
-            refreshBtn.classList.remove('hidden');
-            brokerInput.classList.remove('hidden');
-            setStatus('Ready');
-        };
+            if (pc) { try { pc.close(); } catch (_) {} pc = null; }
+
+            const canvas = document.getElementById('canvas');
+            canvas.style.display = 'none';
+            activeRobot = null;
+            navigate('dashboard');
+        }
+
+        // ─── Init ───────────────────────────────────────────────────────────
+        if (token) navigate('dashboard');
+        else navigate('auth');
     </script>
 </body>
 </html>

From ed2d275473e7c854d73bd6d1cf655df8839f067b Mon Sep 17 00:00:00 2001
From: ruthwikdasyam <ruthwikdasyam@gmail.com>
Date: Fri, 8 May 2026 19:25:36 -0700
Subject: [PATCH 7/9] working commit

---
 .../quest_hosted/hosted_teleop_module.py      | 192 ++++++++----------
 dimos/teleop/quest_hosted/static/index.html   |  28 ++-
 2 files changed, 112 insertions(+), 108 deletions(-)

diff --git a/dimos/teleop/quest_hosted/hosted_teleop_module.py b/dimos/teleop/quest_hosted/hosted_teleop_module.py
index 91f4b52ee4..7709f7830a 100644
--- a/dimos/teleop/quest_hosted/hosted_teleop_module.py
+++ b/dimos/teleop/quest_hosted/hosted_teleop_module.py
@@ -13,24 +13,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""
-Hosted Teleop Module — Cloudflare Realtime client.
-
-Robot is a CLIENT (not a server). On start it:
-
-  1. Builds an aiortc PeerConnection with one DataChannel ``cmd_unreliable``
-     (unordered, maxRetransmits=0 — UDP-like, drop stale frames).
-  2. POSTs the SDP offer to the broker microservice
-     (``{broker_url}/api/v1/sessions``). Broker proxies to Cloudflare
-     Realtime SFU, returns the SDP answer + a session_id.
-  3. Establishes the DataChannel; operator commands (PoseStamped + Joy)
-     start arriving as bytes on cmd_unreliable.
-  4. Heartbeats the broker at 1 Hz to keep the session listed.
-
-On stop, deregisters with broker and closes the PC.
+"""Hosted Teleop Module — Cloudflare Realtime SFU client.
 
-Iteration 1 — operator → robot only. State channels (robot → operator)
-to be added later.
+Robot dials out to a broker (``dimensional-teleop``); operator commands
+arrive on a negotiated ``cmd_unreliable`` DataChannel bound to an SCTP id
+the broker hands us via heartbeat ack after an operator joins.
 """
 
 from __future__ import annotations
@@ -69,25 +56,13 @@ class Hand(IntEnum):
 
 
 class HostedTeleopConfig(ModuleConfig):
-    """Configuration for HostedTeleopModule."""
-
     control_loop_hz: float = 50.0
 
-    # Broker — the microservice that mediates SDP exchange with Cloudflare
-    # Realtime. Robots and operators only ever talk to this; Cloudflare
-    # credentials live on the broker.
-    # Production: https://teleop.dimensionalos.com (deployed from
-    # https://github.com/dimensionalOS/dimensional-teleop)
-    # Local dev:  http://localhost:8000 (dev_broker.py)
-    #             or http://localhost:8450 (dimensional-teleop run locally)
     broker_url: str = "https://teleop.dimensionalos.com"
     broker_api_key: str = ""
-
-    # Robot identity for the broker's session list.
     robot_id: str = ""
     robot_name: str = ""
 
-    # ICE — STUN works in most cases; configure TURN for restrictive networks.
     stun_urls: list[str] = ["stun:stun.cloudflare.com:3478"]
     turn_urls: list[str] = []
     turn_username: str = ""
@@ -99,13 +74,8 @@ class HostedTeleopConfig(ModuleConfig):
 class HostedTeleopModule(Module):
     """Cloudflare-Realtime-based teleop client.
 
-    Outputs (operator → robot, published from received cmd_unreliable bytes):
-      - ``left_controller_output: Out[PoseStamped]``
-      - ``right_controller_output: Out[PoseStamped]``
-      - ``buttons: Out[Buttons]``
-
-    Subclass to override engagement, output formatting, or button packing —
-    same hooks as ``QuestTeleopModule``.
+    Override hooks: ``_handle_engage``, ``_should_publish``,
+    ``_get_output_pose``, ``_publish_msg``, ``_publish_button_state``.
     """
 
     config: HostedTeleopConfig
@@ -117,44 +87,34 @@ class HostedTeleopModule(Module):
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
 
-        # Per-hand state
         self._is_engaged: dict[Hand, bool] = {Hand.LEFT: False, Hand.RIGHT: False}
-        self._initial_poses: dict[Hand, PoseStamped | None] = {
-            Hand.LEFT: None,
-            Hand.RIGHT: None,
-        }
-        self._current_poses: dict[Hand, PoseStamped | None] = {
-            Hand.LEFT: None,
-            Hand.RIGHT: None,
-        }
-        self._controllers: dict[Hand, QuestControllerState | None] = {
-            Hand.LEFT: None,
-            Hand.RIGHT: None,
-        }
+        self._initial_poses: dict[Hand, PoseStamped | None] = {Hand.LEFT: None, Hand.RIGHT: None}
+        self._current_poses: dict[Hand, PoseStamped | None] = {Hand.LEFT: None, Hand.RIGHT: None}
+        self._controllers: dict[Hand, QuestControllerState | None] = {Hand.LEFT: None, Hand.RIGHT: None}
         self._lock = threading.RLock()
 
-        # asyncio loop running in a dedicated thread (aiortc + httpx are async)
+        # aiortc + httpx are async; run them on a dedicated event loop thread.
         self._loop: asyncio.AbstractEventLoop | None = None
         self._loop_thread: threading.Thread | None = None
 
-        # WebRTC + broker state
         self._pc: RTCPeerConnection | None = None
         self._http: httpx.AsyncClient | None = None
         self._session_id: str | None = None
 
-        # Background threads
+        # cmd_unreliable is opened lazily as a negotiated channel once the
+        # broker reports an SCTP id via heartbeat ack (after an operator joins).
+        self._cmd_channel = None
+        self._cmd_channel_id: int | None = None
+
         self._control_loop_thread: threading.Thread | None = None
         self._heartbeat_thread: threading.Thread | None = None
         self._stop_event = threading.Event()
 
-        # Fingerprint dispatch — fired in asyncio context from DataChannel.on_message
         self._decoders: dict[bytes, Any] = {
             LCMPoseStamped._get_packed_fingerprint(): self._on_pose_bytes,
             LCMJoy._get_packed_fingerprint(): self._on_joy_bytes,
         }
 
-    # ─── Lifecycle ───────────────────────────────────────────────────────────
-
     @rpc
     def start(self) -> None:
         super().start()
@@ -181,8 +141,6 @@ def stop(self) -> None:
         self._stop_event_loop()
         super().stop()
 
-    # ─── Event loop thread ───────────────────────────────────────────────────
-
     def _start_event_loop(self) -> None:
         ready = threading.Event()
 
@@ -204,24 +162,12 @@ def _stop_event_loop(self) -> None:
             self._loop_thread = None
         self._loop = None
 
-    # ─── WebRTC + broker (async, runs on event loop thread) ──────────────────
-
     def _connect_blocking(self) -> None:
-        """Sync wrapper: schedule _connect() and wait."""
-        assert self._loop is not None, "_start_event_loop() must be called first"
+        assert self._loop is not None
         future = asyncio.run_coroutine_threadsafe(self._connect(), self._loop)
         future.result(timeout=20.0)
 
     async def _connect(self) -> None:
-        """Open a WebRTC connection via the broker.
-
-        Steps:
-          1. Build PC + DataChannel('cmd_unreliable', unordered, no-retransmit)
-          2. createOffer + setLocalDescription
-          3. Wait for ICE gathering complete (non-trickle)
-          4. POST {broker}/api/v1/sessions { sdp, type, robot_id, robot_name }
-          5. Apply the returned SDP answer
-        """
         self._http = httpx.AsyncClient(timeout=10.0)
 
         ice_servers = [RTCIceServer(urls=u) for u in self.config.stun_urls]
@@ -236,23 +182,10 @@ async def _connect(self) -> None:
 
         self._pc = RTCPeerConnection(RTCConfiguration(iceServers=ice_servers))
 
-        # Create cmd_unreliable so the SDP advertises a data plane.
-        # Operator publishes onto this same channel from the browser; the
-        # SFU forwards. Bytes arrive here as on_message events.
-        cmd_channel = self._pc.createDataChannel(
-            "cmd_unreliable",
-            ordered=False,
-            maxRetransmits=0,
-        )
-
-        @cmd_channel.on("open")
-        def _on_open() -> None:
-            logger.info("cmd_unreliable channel open")
-
-        @cmd_channel.on("message")
-        def _on_message(data: Any) -> None:  # bytes from the operator
-            if isinstance(data, bytes):
-                self._dispatch_bytes(data)
+        # Throwaway DataChannel — forces an SCTP m-line into the offer so
+        # the SFU has a transport to bind cmd_unreliable to later. Closed
+        # as soon as the answer is applied.
+        sctp_init = self._pc.createDataChannel("_sctp_init")
 
         @self._pc.on("connectionstatechange")
         async def _on_state() -> None:
@@ -274,16 +207,13 @@ def _on_gathering() -> None:
 
             await done
 
-        # Register with broker. Field names match dimensional-teleop's
-        # POST /api/v1/sessions schema (sdp_offer in, sdp_answer out).
         url = f"{self.config.broker_url.rstrip('/')}/api/v1/sessions"
-        headers = self._auth_headers()
         body = {
             "robot_id": self.config.robot_id,
             "robot_name": self.config.robot_name,
             "sdp_offer": self._pc.localDescription.sdp,
         }
-        resp = await self._http.post(url, json=body, headers=headers)
+        resp = await self._http.post(url, json=body, headers=self._auth_headers())
         resp.raise_for_status()
         data = resp.json()
         self._session_id = data["session_id"]
@@ -291,6 +221,12 @@ def _on_gathering() -> None:
         await self._pc.setRemoteDescription(
             RTCSessionDescription(sdp=data["sdp_answer"], type="answer")
         )
+
+        try:
+            sctp_init.close()
+        except Exception:
+            pass
+
         logger.info(
             f"Registered with broker: session_id={self._session_id}, "
             f"cf_session_id={data.get('cf_session_id')}"
@@ -303,6 +239,8 @@ async def _disconnect(self) -> None:
                 await self._http.delete(url, headers=self._auth_headers())
             except Exception:
                 logger.exception("Failed to deregister with broker")
+        self._close_cmd_channel()
+        self._cmd_channel_id = None
         if self._pc is not None:
             await self._pc.close()
             self._pc = None
@@ -312,18 +250,10 @@ async def _disconnect(self) -> None:
         self._session_id = None
 
     def _auth_headers(self) -> dict[str, str]:
-        """Robot auth header — dimensional-teleop expects ``X-Robot-API-Key``.
-
-        The configured key must be registered server-side and mapped to a
-        ``robot_id`` matching ``config.robot_id``. The dev broker
-        (``dev_broker.py``) ignores auth entirely.
-        """
         if self.config.broker_api_key:
             return {"X-Robot-API-Key": self.config.broker_api_key}
         return {}
 
-    # ─── Heartbeat ──────────────────────────────────────────────────────────
-
     def _start_heartbeat(self) -> None:
         def runner() -> None:
             interval = 1.0 / max(self.config.heartbeat_hz, 0.1)
@@ -346,12 +276,66 @@ async def _heartbeat(self) -> None:
         if self._http is None or self._session_id is None:
             return
         url = f"{self.config.broker_url.rstrip('/')}/api/v1/sessions/{self._session_id}/heartbeat"
-        await self._http.post(url, headers=self._auth_headers())
+        try:
+            # Broker's HeartbeatRequest requires a JSON body; {} hits the defaults.
+            resp = await self._http.post(url, json={}, headers=self._auth_headers())
+            resp.raise_for_status()
+        except Exception as e:
+            logger.warning(f"Heartbeat POST failed: {e}")
+            return
+
+        try:
+            data = resp.json()
+        except Exception:
+            return
+
+        sub_id = data.get("cmd_channel_subscriber_id")
+        sub_id_int = int(sub_id) if sub_id is not None else None
+
+        if sub_id_int != self._cmd_channel_id:
+            self._close_cmd_channel()
+            self._cmd_channel_id = sub_id_int
+            if sub_id_int is not None:
+                self._open_cmd_channel(sub_id_int)
+
+    def _open_cmd_channel(self, sctp_id: int) -> None:
+        if self._pc is None:
+            return
+        logger.info(
+            f"Operator joined — opening negotiated cmd_unreliable on SCTP id {sctp_id}"
+        )
+        channel = self._pc.createDataChannel(
+            "cmd_unreliable",
+            ordered=False,
+            maxRetransmits=0,
+            negotiated=True,
+            id=sctp_id,
+        )
 
-    # ─── Bytes dispatch (operator → robot) ──────────────────────────────────
+        @channel.on("open")
+        def _on_open() -> None:
+            logger.info("cmd_unreliable channel OPEN")
+
+        @channel.on("message")
+        def _on_message(data: Any) -> None:
+            if isinstance(data, bytes):
+                self._dispatch_bytes(data)
+
+        @channel.on("close")
+        def _on_close() -> None:
+            logger.info("cmd_unreliable channel closed")
+
+        self._cmd_channel = channel
+
+    def _close_cmd_channel(self) -> None:
+        if self._cmd_channel is not None:
+            try:
+                self._cmd_channel.close()
+            except Exception:
+                pass
+            self._cmd_channel = None
 
     def _dispatch_bytes(self, data: bytes) -> None:
-        """Route raw LCM bytes to the right handler by 8-byte fingerprint."""
         decoder = self._decoders.get(data[:8])
         if decoder:
             decoder(data)
@@ -393,8 +377,6 @@ def _resolve_hand(frame_id: str) -> Hand:
             return Hand.RIGHT
         raise ValueError(f"Unexpected frame_id: {frame_id!r}")
 
-    # ─── Control loop (publishes Out streams) ───────────────────────────────
-
     def _start_control_loop(self) -> None:
         self._stop_event.clear()
         self._control_loop_thread = threading.Thread(
@@ -429,7 +411,6 @@ def _control_loop(self) -> None:
                 self._stop_event.wait(sleep_time)
 
     def _handle_engage(self) -> None:
-        """Press-and-hold engage on each controller's primary button."""
         for hand in Hand:
             controller = self._controllers.get(hand)
             if controller is None:
@@ -454,7 +435,6 @@ def _should_publish(self, hand: Hand) -> bool:
         return self._is_engaged[hand]
 
     def _get_output_pose(self, hand: Hand) -> PoseStamped | None:
-        """Default: delta from initial engaged pose."""
         current = self._current_poses.get(hand)
         initial = self._initial_poses.get(hand)
         if current is None or initial is None:
diff --git a/dimos/teleop/quest_hosted/static/index.html b/dimos/teleop/quest_hosted/static/index.html
index a627a587b7..2ad00df80b 100644
--- a/dimos/teleop/quest_hosted/static/index.html
+++ b/dimos/teleop/quest_hosted/static/index.html
@@ -380,11 +380,35 @@ <h2 class="text-lg font-semibold text-white">Available Robots</h2>
                 setStatus(`Connected — ${robotName}`);
             } catch (e) {
                 console.error(e);
-                setStatus(`Connection failed: ${e.message}`);
-                setTimeout(() => navigate('dashboard'), 3000);
+                // Persist the error so you can see it after auto-disconnect from
+                // VR, AND don't auto-redirect — wait for the user to dismiss.
+                const msg = `Connection failed: ${e.message || e}`;
+                localStorage.setItem('teleop_last_error', msg);
+                setStatus(msg);
+                showErrorPanel(msg);
             }
         }
 
+        function showErrorPanel(msg) {
+            // Replace the status panel with a sticky error + back button.
+            const c = document.getElementById('app');
+            c.innerHTML = `
+            <div class="min-h-screen flex flex-col items-center justify-center p-6">
+                <div class="w-full max-w-md text-center">
+                    <h1 class="text-2xl font-bold text-red-400 mb-4">Connection failed</h1>
+                    <pre class="text-sm text-red-300 px-4 py-3 bg-gray-900 border border-red-800 rounded-lg my-4 whitespace-pre-wrap text-left">${escHtml(msg)}</pre>
+                    <button id="errorBackBtn" class="mt-4 px-6 py-2.5 bg-gray-700 hover:bg-gray-600 text-white text-sm font-medium rounded-lg">
+                        Back to dashboard
+                    </button>
+                </div>
+            </div>`;
+            document.getElementById('errorBackBtn').onclick = () => {
+                const canvas = document.getElementById('canvas');
+                if (canvas) canvas.style.display = 'none';
+                navigate('dashboard');
+            };
+        }
+
         // ─── Teleop view ────────────────────────────────────────────────────
         function renderTeleop(c) {
             c.innerHTML = `

From b6914e91ec99ceee45c289898c03a84a81817ac2 Mon Sep 17 00:00:00 2001
From: ruthwikdasyam <ruthwikdasyam@gmail.com>
Date: Sat, 9 May 2026 15:47:13 -0700
Subject: [PATCH 8/9] feat/workingcommit/keyboard-teleop

---
 dimos/robot/all_blueprints.py                 |   2 +
 dimos/teleop/quest_hosted/blueprints.py       |  19 +-
 .../teleop/quest_hosted/hosted_extensions.py  |  43 ++-
 .../quest_hosted/hosted_teleop_module.py      |  13 +
 dimos/teleop/quest_hosted/static/index.html   | 275 +++++++++++++++---
 5 files changed, 310 insertions(+), 42 deletions(-)

diff --git a/dimos/robot/all_blueprints.py b/dimos/robot/all_blueprints.py
index 48fc969fb5..1c3fae7e6c 100644
--- a/dimos/robot/all_blueprints.py
+++ b/dimos/robot/all_blueprints.py
@@ -67,6 +67,7 @@
     "mid360-fastlio-voxels-native": "dimos.hardware.sensors.lidar.fastlio2.fastlio_blueprints:mid360_fastlio_voxels_native",
     "openarm-mock-planner-coordinator": "dimos.robot.manipulators.openarm.blueprints:openarm_mock_planner_coordinator",
     "openarm-planner-coordinator": "dimos.robot.manipulators.openarm.blueprints:openarm_planner_coordinator",
+    "teleop-hosted-go2": "dimos.teleop.quest_hosted.blueprints:teleop_hosted_go2",
     "teleop-hosted-xarm7-sim": "dimos.teleop.quest_hosted.blueprints:teleop_hosted_xarm7_sim",
     "teleop-phone": "dimos.teleop.phone.blueprints:teleop_phone",
     "teleop-phone-go2": "dimos.teleop.phone.blueprints:teleop_phone_go2",
@@ -152,6 +153,7 @@
     "gstreamer-camera-module": "dimos.hardware.sensors.camera.gstreamer.gstreamer_camera.GstreamerCameraModule",
     "hosted-arm-teleop-module": "dimos.teleop.quest_hosted.hosted_extensions.HostedArmTeleopModule",
     "hosted-teleop-module": "dimos.teleop.quest_hosted.hosted_teleop_module.HostedTeleopModule",
+    "hosted-twist-teleop-module": "dimos.teleop.quest_hosted.hosted_extensions.HostedTwistTeleopModule",
     "joint-trajectory-controller": "dimos.manipulation.control.trajectory_controller.joint_trajectory_controller.JointTrajectoryController",
     "joystick-module": "dimos.robot.unitree.b1.joystick_module.JoystickModule",
     "keyboard-teleop": "dimos.robot.unitree.keyboard_teleop.KeyboardTeleop",
diff --git a/dimos/teleop/quest_hosted/blueprints.py b/dimos/teleop/quest_hosted/blueprints.py
index 5ab1f8c850..e757ffae35 100644
--- a/dimos/teleop/quest_hosted/blueprints.py
+++ b/dimos/teleop/quest_hosted/blueprints.py
@@ -13,14 +13,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Hosted teleop blueprints (WebRTC transport, single XArm7 sim)."""
+"""Hosted teleop blueprints (WebRTC transport)."""
 
 from dimos.control.blueprints.teleop import coordinator_teleop_sim_xarm7
 from dimos.core.coordination.blueprints import autoconnect
 from dimos.core.transport import LCMTransport
 from dimos.msgs.geometry_msgs.PoseStamped import PoseStamped
+from dimos.robot.unitree.go2.blueprints.basic.unitree_go2_basic import unitree_go2_basic
 from dimos.teleop.quest.quest_types import Buttons
-from dimos.teleop.quest_hosted.hosted_extensions import HostedArmTeleopModule
+from dimos.teleop.quest_hosted.hosted_extensions import (
+    HostedArmTeleopModule,
+    HostedTwistTeleopModule,
+)
 
 # Single XArm7 teleop in MuJoCo sim, using the hosted (WebRTC) client.
 teleop_hosted_xarm7_sim = autoconnect(
@@ -35,5 +39,14 @@
     }
 )
 
+# Unitree Go2 keyboard teleop. Operator types WASD in browser → TwistStamped
+# over WebRTC → HostedTwistTeleopModule scales by linear/angular_speed and
+# publishes Twist on cmd_vel → GO2Connection.cmd_vel (via unitree_go2_basic,
+# which also brings in vis + clock sync; no coordinator in path).
+teleop_hosted_go2 = autoconnect(
+    HostedTwistTeleopModule.blueprint(),
+    unitree_go2_basic,
+)
+
 
-__all__ = ["teleop_hosted_xarm7_sim"]
+__all__ = ["teleop_hosted_xarm7_sim", "teleop_hosted_go2"]
diff --git a/dimos/teleop/quest_hosted/hosted_extensions.py b/dimos/teleop/quest_hosted/hosted_extensions.py
index 4d156dc177..37dc8b1b21 100644
--- a/dimos/teleop/quest_hosted/hosted_extensions.py
+++ b/dimos/teleop/quest_hosted/hosted_extensions.py
@@ -16,8 +16,12 @@
 """Hosted teleop subclasses (WebRTC-via-Cloudflare-Realtime transport).
 
 Mirrors the role of ``dimos/teleop/quest/quest_extensions.py`` but for the
-hosted module — small overrides on top of ``HostedTeleopModule`` for arm
-teleop (per-hand task names + analog trigger packing into button bits).
+hosted module — small overrides on top of ``HostedTeleopModule``:
+
+  - ``HostedArmTeleopModule``: per-hand task_name routing + analog trigger
+    packing (Quest VR mode, arm robots).
+  - ``HostedTwistTeleopModule``: scales incoming Twist by configured
+    linear/angular speeds (keyboard mode, mobile-base robots like Go2).
 """
 
 from typing import Any
@@ -25,6 +29,9 @@
 from pydantic import Field
 
 from dimos.msgs.geometry_msgs.PoseStamped import PoseStamped
+from dimos.msgs.geometry_msgs.Twist import Twist
+from dimos.msgs.geometry_msgs.TwistStamped import TwistStamped
+from dimos.msgs.geometry_msgs.Vector3 import Vector3
 from dimos.teleop.quest.quest_teleop_module import Hand
 from dimos.teleop.quest.quest_types import Buttons, QuestControllerState
 from dimos.teleop.quest_hosted.hosted_teleop_module import (
@@ -84,3 +91,35 @@ def _publish_button_state(
             right=right.trigger if right is not None else 0.0,
         )
         self.buttons.publish(buttons)
+
+
+class HostedTwistTeleopConfig(HostedTeleopConfig):
+    """Adds ``linear_speed`` / ``angular_speed`` for scaling incoming Twist.
+
+    The operator's keyboard sends normalized commands in [-1, 1] (with
+    Shift = 2x, Ctrl = 0.5x). The robot side multiplies by these speeds
+    to get final m/s and rad/s. Defaults are reasonable for an indoor Go2.
+    """
+
+    linear_speed: float = 0.5
+    angular_speed: float = 0.8
+
+
+class HostedTwistTeleopModule(HostedTeleopModule):
+    """Hosted teleop variant for mobile-base robots (Go2, wheeled, etc.).
+
+    Same as ``HostedTeleopModule`` but scales incoming Twist commands by
+    the configured ``linear_speed`` / ``angular_speed`` before publishing.
+    """
+
+    config: HostedTwistTeleopConfig
+
+    def _on_twist_bytes(self, data: bytes) -> None:
+        msg = TwistStamped.lcm_decode(data)
+        ls = self.config.linear_speed
+        as_ = self.config.angular_speed
+        twist = Twist(
+            linear=Vector3(msg.linear.x * ls, msg.linear.y * ls, msg.linear.z * ls),
+            angular=Vector3(msg.angular.x * as_, msg.angular.y * as_, msg.angular.z * as_),
+        )
+        self.cmd_vel.publish(twist)
diff --git a/dimos/teleop/quest_hosted/hosted_teleop_module.py b/dimos/teleop/quest_hosted/hosted_teleop_module.py
index 7709f7830a..ebf7e62f81 100644
--- a/dimos/teleop/quest_hosted/hosted_teleop_module.py
+++ b/dimos/teleop/quest_hosted/hosted_teleop_module.py
@@ -35,6 +35,7 @@
     RTCSessionDescription,
 )
 from dimos_lcm.geometry_msgs import PoseStamped as LCMPoseStamped
+from dimos_lcm.geometry_msgs import TwistStamped as LCMTwistStamped
 from dimos_lcm.sensor_msgs import Joy as LCMJoy
 import httpx
 
@@ -42,6 +43,8 @@
 from dimos.core.module import Module, ModuleConfig
 from dimos.core.stream import Out
 from dimos.msgs.geometry_msgs.PoseStamped import PoseStamped
+from dimos.msgs.geometry_msgs.Twist import Twist
+from dimos.msgs.geometry_msgs.TwistStamped import TwistStamped
 from dimos.msgs.sensor_msgs.Joy import Joy
 from dimos.teleop.quest.quest_types import Buttons, QuestControllerState
 from dimos.teleop.utils.teleop_transforms import webxr_to_robot
@@ -83,6 +86,7 @@ class HostedTeleopModule(Module):
     left_controller_output: Out[PoseStamped]
     right_controller_output: Out[PoseStamped]
     buttons: Out[Buttons]
+    cmd_vel: Out[Twist]
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
@@ -113,6 +117,7 @@ def __init__(self, **kwargs: Any) -> None:
         self._decoders: dict[bytes, Any] = {
             LCMPoseStamped._get_packed_fingerprint(): self._on_pose_bytes,
             LCMJoy._get_packed_fingerprint(): self._on_joy_bytes,
+            LCMTwistStamped._get_packed_fingerprint(): self._on_twist_bytes,
         }
 
     @rpc
@@ -369,6 +374,14 @@ def _on_joy_bytes(self, data: bytes) -> None:
         with self._lock:
             self._controllers[hand] = controller
 
+    def _on_twist_bytes(self, data: bytes) -> None:
+        # Keyboard mode — no engagement gating. Wire format is TwistStamped
+        # (carries timestamp); strip the header and publish plain Twist on
+        # cmd_vel (matches GO2Connection.cmd_vel and most ROS-style bases).
+        msg = TwistStamped.lcm_decode(data)
+        twist = Twist(linear=msg.linear, angular=msg.angular)
+        self.cmd_vel.publish(twist)
+
     @staticmethod
     def _resolve_hand(frame_id: str) -> Hand:
         if frame_id == "left":
diff --git a/dimos/teleop/quest_hosted/static/index.html b/dimos/teleop/quest_hosted/static/index.html
index 2ad00df80b..37ccd7d5cb 100644
--- a/dimos/teleop/quest_hosted/static/index.html
+++ b/dimos/teleop/quest_hosted/static/index.html
@@ -18,6 +18,19 @@
         @keyframes fadeIn { from { opacity: 0; transform: translateY(8px); } to { opacity: 1; transform: translateY(0); } }
         .key-reveal { font-family: 'JetBrains Mono', monospace; word-break: break-all; }
         #canvas { display: none; position: absolute; inset: 0; width: 100%; height: 100%; }
+        .kb-key {
+            width: 56px; height: 56px;
+            display: flex; align-items: center; justify-content: center;
+            background: #1f2937; border: 1px solid #374151;
+            border-radius: 8px; font-family: monospace; font-weight: 600;
+            color: #d1d5db;
+            user-select: none;
+        }
+        .kb-key.wide { width: 96px; font-size: 0.85rem; }
+        .kb-key.pressed {
+            background: #0284c7; border-color: #38bdf8;
+            color: white;
+        }
     </style>
 </head>
 <body class="bg-gray-950 text-gray-100 min-h-screen">
@@ -30,12 +43,7 @@
         // ─── State ──────────────────────────────────────────────────────────
         let token = localStorage.getItem('teleop_token') || '';
         let userEmail = localStorage.getItem('teleop_email') || '';
-
-        // The broker is always the origin this page was served from. We do
-        // NOT accept a ?broker= override — that would be a credential-
-        // exfiltration vector (the login form would POST to whatever URL an
-        // attacker put in the query string). For local dev, run dev_broker.py
-        // which serves this HTML at /teleop on the same origin.
+        let brokerOverride = new URLSearchParams(window.location.search).get('broker') || '';
 
         // WebRTC + WebXR state
         let pc = null;
@@ -47,12 +55,25 @@
         let activeRobot = null;
         const sendInterval = 1000 / 80;
 
+        // Probed once at boot. Quest browser → true; desktop/mobile → false.
+        let xrSupported = false;
+        const xrDetection = (async () => {
+            if (!navigator.xr) return false;
+            const ar = await navigator.xr.isSessionSupported('immersive-ar').catch(() => false);
+            if (ar) return true;
+            return await navigator.xr.isSessionSupported('immersive-vr').catch(() => false);
+        })().then(v => { xrSupported = v; return v; });
+
         // ─── API helpers ────────────────────────────────────────────────────
+        function brokerOrigin() {
+            return brokerOverride || window.location.origin;
+        }
+
         async function api(method, path, body = null) {
             const opts = { method, headers: { 'Content-Type': 'application/json' } };
             if (token) opts.headers['Authorization'] = `Bearer ${token}`;
             if (body) opts.body = JSON.stringify(body);
-            const res = await fetch(`/api/v1${path}`, opts);
+            const res = await fetch(`${brokerOrigin()}/api/v1${path}`, opts);
             if (res.status === 401) { logout(); throw new Error('Unauthorized'); }
             const data = await res.json().catch(() => ({}));
             if (!res.ok) throw new Error(data.detail || `HTTP ${res.status}`);
@@ -87,6 +108,7 @@
             if (view === 'auth') renderAuth(app);
             else if (view === 'dashboard') renderDashboard(app);
             else if (view === 'teleop') renderTeleop(app);
+            else if (view === 'keyboard') renderKeyboard(app);
         }
 
         // ─── Auth view ──────────────────────────────────────────────────────
@@ -236,7 +258,7 @@ <h2 class="text-lg font-semibold text-white">Available Robots</h2>
                 </section>
 
                 <p class="text-center text-xs text-gray-600 mt-6">
-                    Broker: <code>${escHtml(window.location.origin)}</code>
+                    Broker: <code>${escHtml(brokerOrigin())}</code>
                 </p>
             </div>`;
 
@@ -326,6 +348,7 @@ <h2 class="text-lg font-semibold text-white">Available Robots</h2>
         // ─── Robot list ─────────────────────────────────────────────────────
         async function loadRobots() {
             const listEl = document.getElementById('robots-list');
+            await xrDetection;
             try {
                 const robots = await api('GET', '/sessions');
                 // Broker returns a flat list per sessions.py:list_sessions response_model.
@@ -351,9 +374,10 @@ <h2 class="text-lg font-semibold text-white">Available Robots</h2>
                         </button>
                     </div>
                 `).join('');
+                const handler = xrSupported ? connectToRobot : connectKeyboard;
                 listEl.querySelectorAll('.connect-btn').forEach(btn => {
                     btn.addEventListener('click', (e) => {
-                        connectToRobot(e.target.dataset.id, e.target.dataset.name);
+                        handler(e.target.dataset.id, e.target.dataset.name);
                     });
                 });
             } catch (err) {
@@ -380,35 +404,165 @@ <h2 class="text-lg font-semibold text-white">Available Robots</h2>
                 setStatus(`Connected — ${robotName}`);
             } catch (e) {
                 console.error(e);
-                // Persist the error so you can see it after auto-disconnect from
-                // VR, AND don't auto-redirect — wait for the user to dismiss.
-                const msg = `Connection failed: ${e.message || e}`;
-                localStorage.setItem('teleop_last_error', msg);
-                setStatus(msg);
-                showErrorPanel(msg);
+                setStatus(`Connection failed: ${e.message}`);
+                setTimeout(() => navigate('dashboard'), 3000);
+            }
+        }
+
+        // ─── Keyboard mode ──────────────────────────────────────────────────
+        // WASD-driven TwistStamped over the same cmd_unreliable channel as VR,
+        // sent at the shared `sendInterval` (80 Hz).
+        let kbInterval = null;
+        const kbKeys = new Set();
+
+        async function connectKeyboard(sessionId, robotName) {
+            activeRobot = { session_id: sessionId, robot_name: robotName };
+            try {
+                navigate('keyboard');
+                await setupWebRTC(sessionId);
+                setStatus(`Connected — ${robotName}`);
+                startKeyboardLoop();
+            } catch (e) {
+                console.error(e);
+                setStatus(`Connection failed: ${e.message}`);
+                setTimeout(() => navigate('dashboard'), 3000);
             }
         }
 
-        function showErrorPanel(msg) {
-            // Replace the status panel with a sticky error + back button.
-            const c = document.getElementById('app');
+        function renderKeyboard(c) {
             c.innerHTML = `
-            <div class="min-h-screen flex flex-col items-center justify-center p-6">
-                <div class="w-full max-w-md text-center">
-                    <h1 class="text-2xl font-bold text-red-400 mb-4">Connection failed</h1>
-                    <pre class="text-sm text-red-300 px-4 py-3 bg-gray-900 border border-red-800 rounded-lg my-4 whitespace-pre-wrap text-left">${escHtml(msg)}</pre>
-                    <button id="errorBackBtn" class="mt-4 px-6 py-2.5 bg-gray-700 hover:bg-gray-600 text-white text-sm font-medium rounded-lg">
-                        Back to dashboard
+            <div class="min-h-screen flex flex-col items-center justify-center p-6 fade-in select-none">
+                <div class="w-full max-w-xl text-center">
+                    <h1 class="text-3xl font-bold text-white mb-2">${escHtml(activeRobot?.robot_name || 'Keyboard teleop')}</h1>
+                    <div id="teleop-status" class="text-lg text-gray-300 px-4 py-3 bg-gray-900 border border-gray-800 rounded-lg my-4">
+                        Negotiating...
+                    </div>
+
+                    <div class="grid grid-cols-2 gap-4 my-6 text-left">
+                        <div class="bg-gray-900 border border-gray-800 rounded-lg p-4">
+                            <div class="text-xs text-gray-500 mb-2">Controls</div>
+                            <div class="text-sm text-gray-300 space-y-1">
+                                <div><kbd class="px-2 py-0.5 bg-gray-800 rounded font-mono">W</kbd> / <kbd class="px-2 py-0.5 bg-gray-800 rounded font-mono">S</kbd> — forward / back</div>
+                                <div><kbd class="px-2 py-0.5 bg-gray-800 rounded font-mono">A</kbd> / <kbd class="px-2 py-0.5 bg-gray-800 rounded font-mono">D</kbd> — turn left / right</div>
+                                <div><kbd class="px-2 py-0.5 bg-gray-800 rounded font-mono">Shift</kbd> — 2× faster (any)</div>
+                                <div><kbd class="px-2 py-0.5 bg-gray-800 rounded font-mono">Ctrl</kbd>+<kbd class="px-2 py-0.5 bg-gray-800 rounded font-mono">W</kbd>/<kbd class="px-2 py-0.5 bg-gray-800 rounded font-mono">S</kbd> — slow (½×)</div>
+                                <div><kbd class="px-2 py-0.5 bg-gray-800 rounded font-mono">Ctrl</kbd>+<kbd class="px-2 py-0.5 bg-gray-800 rounded font-mono">A</kbd>/<kbd class="px-2 py-0.5 bg-gray-800 rounded font-mono">D</kbd> — strafe</div>
+                            </div>
+                        </div>
+                        <div class="bg-gray-900 border border-gray-800 rounded-lg p-4">
+                            <div class="text-xs text-gray-500 mb-2">Live twist</div>
+                            <pre id="twist-readout" class="text-sm text-green-300 font-mono">linear.x  = 0
+linear.y  = 0
+linear.z  = 0
+angular.z = 0</pre>
+                        </div>
+                    </div>
+
+                    <div class="bg-gray-900 border border-gray-800 rounded-lg p-6 my-6">
+                        <div class="flex flex-col items-center gap-2">
+                            <div id="key-w" class="kb-key">W</div>
+                            <div class="flex gap-2">
+                                <div id="key-a" class="kb-key">A</div>
+                                <div id="key-s" class="kb-key">S</div>
+                                <div id="key-d" class="kb-key">D</div>
+                            </div>
+                            <div class="flex gap-2 mt-3">
+                                <div id="key-shift" class="kb-key wide">Shift</div>
+                                <div id="key-ctrl" class="kb-key wide">Ctrl</div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <button id="disconnectBtn" class="mt-4 px-6 py-2.5 bg-gray-700 hover:bg-gray-600 text-white text-sm font-medium rounded-lg transition-colors">
+                        Disconnect
                     </button>
                 </div>
             </div>`;
-            document.getElementById('errorBackBtn').onclick = () => {
-                const canvas = document.getElementById('canvas');
-                if (canvas) canvas.style.display = 'none';
-                navigate('dashboard');
+            document.getElementById('disconnectBtn').onclick = disconnect;
+        }
+
+        function trackedKey(e) {
+            if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA') return null;
+            const k = e.key.toLowerCase();
+            if (k === 'w' || k === 'a' || k === 's' || k === 'd') return k;
+            if (e.key === 'Shift' || e.key === 'Control') return e.key;
+            return null;
+        }
+        function onKeyDown(e) {
+            const k = trackedKey(e);
+            if (k === null) return;
+            kbKeys.add(k);
+            e.preventDefault();
+        }
+        function onKeyUp(e) {
+            const k = trackedKey(e);
+            if (k === null) return;
+            kbKeys.delete(k);
+        }
+
+        function buildTwist() {
+            // Shift = 2×, Ctrl + W/S = ½×, Ctrl + A/D = strafe; both held = neither.
+            const shift = kbKeys.has('Shift') && !kbKeys.has('Control');
+            const ctrl  = kbKeys.has('Control') && !kbKeys.has('Shift');
+            const fwd = (kbKeys.has('w') ? 1 : 0) - (kbKeys.has('s') ? 1 : 0);
+            const lr  = (kbKeys.has('a') ? 1 : 0) - (kbKeys.has('d') ? 1 : 0);
+
+            const fwdScale = shift ? 2.0 : (ctrl ? 0.5 : 1.0);
+            const lrScale  = shift ? 2.0 : 1.0;
+            return {
+                linear_x:  fwd * fwdScale,
+                linear_y:  ctrl ? lr : 0,
+                linear_z:  0,
+                angular_z: ctrl ? 0  : lr * lrScale,
             };
         }
 
+        function startKeyboardLoop() {
+            window.addEventListener('keydown', onKeyDown);
+            window.addEventListener('keyup', onKeyUp);
+            kbInterval = setInterval(() => {
+                // Always update key visuals; only send/readout when channel is up.
+                updateKeyVisuals();
+                if (!cmdChannel || cmdChannel.readyState !== 'open') return;
+                const t = buildTwist();
+                const nowMs = Date.now();
+                const ts = new std_msgs.Time({
+                    sec: Math.floor(nowMs / 1000),
+                    nsec: (nowMs % 1000) * 1_000_000,
+                });
+                const twist = new geometry_msgs.TwistStamped({
+                    header: new std_msgs.Header({ stamp: ts, frame_id: 'keyboard' }),
+                    twist: new geometry_msgs.Twist({
+                        linear: new geometry_msgs.Vector3({ x: t.linear_x, y: t.linear_y, z: t.linear_z }),
+                        angular: new geometry_msgs.Vector3({ x: 0, y: 0, z: t.angular_z }),
+                    }),
+                });
+                cmdChannel.send(twist.encode());
+                const out = document.getElementById('twist-readout');
+                if (out) out.textContent =
+                    `linear.x  = ${t.linear_x.toFixed(2)}\n` +
+                    `linear.y  = ${t.linear_y.toFixed(2)}\n` +
+                    `linear.z  = ${t.linear_z.toFixed(2)}\n` +
+                    `angular.z = ${t.angular_z.toFixed(2)}`;
+            }, sendInterval);
+        }
+
+        function updateKeyVisuals() {
+            const map = { 'w': 'key-w', 's': 'key-s', 'a': 'key-a', 'd': 'key-d',
+                          'Shift': 'key-shift', 'Control': 'key-ctrl' };
+            for (const [k, id] of Object.entries(map)) {
+                const el = document.getElementById(id);
+                if (el) el.classList.toggle('pressed', kbKeys.has(k));
+            }
+        }
+
+        function stopKeyboardLoop() {
+            window.removeEventListener('keydown', onKeyDown);
+            window.removeEventListener('keyup', onKeyUp);
+            if (kbInterval) { clearInterval(kbInterval); kbInterval = null; }
+            kbKeys.clear();
+        }
+
         // ─── Teleop view ────────────────────────────────────────────────────
         function renderTeleop(c) {
             c.innerHTML = `
@@ -438,15 +592,9 @@ <h1 class="text-3xl font-bold text-white mb-2">${escHtml(activeRobot?.robot_name
                 iceServers: [{ urls: 'stun:stun.cloudflare.com:3478' }]
             });
 
-            cmdChannel = pc.createDataChannel('cmd_unreliable', {
-                ordered: false,
-                maxRetransmits: 0,
-            });
-            cmdChannel.binaryType = 'arraybuffer';
+            const sctpPlaceholder = pc.createDataChannel('_sctp_init');
 
-            const opened = new Promise((resolve, reject) => {
-                cmdChannel.onopen = () => resolve();
-                cmdChannel.onerror = (e) => reject(e);
+            const iceFailed = new Promise((_, reject) => {
                 pc.oniceconnectionstatechange = () => {
                     if (pc.iceConnectionState === 'failed' ||
                         pc.iceConnectionState === 'disconnected') {
@@ -472,7 +620,45 @@ <h1 class="text-3xl font-bold text-white mb-2">${escHtml(activeRobot?.robot_name
             });
             await pc.setRemoteDescription({ type: 'answer', sdp: data.sdp_answer });
 
-            await opened;
+            // CF rejects /datachannels/new until the PC is 'connected'.
+            await Promise.race([
+                new Promise((resolve, reject) => {
+                    const check = () => {
+                        if (pc.connectionState === 'connected') resolve();
+                        else if (pc.connectionState === 'failed' ||
+                                 pc.connectionState === 'closed') {
+                            reject(new Error('PC ' + pc.connectionState));
+                        }
+                    };
+                    check();
+                    pc.addEventListener('connectionstatechange', check);
+                }),
+                iceFailed,
+            ]);
+
+            try { sctpPlaceholder.close(); } catch (_) {}
+
+            const bridge = await api('POST', `/sessions/${sessionId}/bridge-datachannel`);
+            if (bridge.cmd_channel_id == null) {
+                throw new Error('Broker did not return cmd_channel_id');
+            }
+
+            cmdChannel = pc.createDataChannel('cmd_unreliable', {
+                negotiated: true,
+                id: bridge.cmd_channel_id,
+                ordered: false,
+                maxRetransmits: 0,
+            });
+            cmdChannel.binaryType = 'arraybuffer';
+
+            await Promise.race([
+                new Promise((resolve, reject) => {
+                    if (cmdChannel.readyState === 'open') return resolve();
+                    cmdChannel.onopen = () => resolve();
+                    cmdChannel.onerror = (e) => reject(e);
+                }),
+                iceFailed,
+            ]);
         }
 
         function send(bytes) {
@@ -590,6 +776,7 @@ <h1 class="text-3xl font-bold text-white mb-2">${escHtml(activeRobot?.robot_name
                 }
             } catch (_) {}
 
+            stopKeyboardLoop();
             if (xrSession) { await xrSession.end().catch(() => {}); xrSession = null; }
             if (cmdChannel) { try { cmdChannel.close(); } catch (_) {} cmdChannel = null; }
             if (pc) { try { pc.close(); } catch (_) {} pc = null; }
@@ -603,6 +790,20 @@ <h1 class="text-3xl font-bold text-white mb-2">${escHtml(activeRobot?.robot_name
         // ─── Init ───────────────────────────────────────────────────────────
         if (token) navigate('dashboard');
         else navigate('auth');
+
+        // DevTools-only preview hook — no broker required.
+        window._teleopDev = {
+            previewKeyboard() {
+                cmdChannel = { readyState: 'open', send: () => {} };
+                activeRobot = { session_id: 'preview', robot_name: 'Preview Bot' };
+                navigate('keyboard');
+            },
+            previewVR() {
+                activeRobot = { session_id: 'preview', robot_name: 'Preview Bot' };
+                navigate('teleop');
+            },
+            navigate,
+        };
     </script>
 </body>
 </html>

From 027dae005ec4c84d0da59862dff0d8a8a8a776b1 Mon Sep 17 00:00:00 2001
From: ruthwikdasyam <ruthwikdasyam@gmail.com>
Date: Sat, 9 May 2026 19:26:25 -0700
Subject: [PATCH 9/9] feat/TwistStamped + recording msgs

---
 dimos/robot/all_blueprints.py                 |   1 +
 dimos/robot/unitree/type/lidar.py             |   2 +-
 dimos/teleop/quest_hosted/blueprints.py       |  34 ++-
 .../teleop/quest_hosted/hosted_extensions.py  |   9 +-
 .../quest_hosted/hosted_teleop_module.py      |  11 +-
 .../teleop/utils/latency_analyzer_twist.ipynb | 249 ++++++++++++++++++
 6 files changed, 295 insertions(+), 11 deletions(-)
 create mode 100644 dimos/teleop/utils/latency_analyzer_twist.ipynb

diff --git a/dimos/robot/all_blueprints.py b/dimos/robot/all_blueprints.py
index 1c3fae7e6c..a6528ee55c 100644
--- a/dimos/robot/all_blueprints.py
+++ b/dimos/robot/all_blueprints.py
@@ -153,6 +153,7 @@
     "gstreamer-camera-module": "dimos.hardware.sensors.camera.gstreamer.gstreamer_camera.GstreamerCameraModule",
     "hosted-arm-teleop-module": "dimos.teleop.quest_hosted.hosted_extensions.HostedArmTeleopModule",
     "hosted-teleop-module": "dimos.teleop.quest_hosted.hosted_teleop_module.HostedTeleopModule",
+    "hosted-teleop-recorder": "dimos.teleop.quest_hosted.blueprints.HostedTeleopRecorder",
     "hosted-twist-teleop-module": "dimos.teleop.quest_hosted.hosted_extensions.HostedTwistTeleopModule",
     "joint-trajectory-controller": "dimos.manipulation.control.trajectory_controller.joint_trajectory_controller.JointTrajectoryController",
     "joystick-module": "dimos.robot.unitree.b1.joystick_module.JoystickModule",
diff --git a/dimos/robot/unitree/type/lidar.py b/dimos/robot/unitree/type/lidar.py
index fe7ef26b2a..117d404b80 100644
--- a/dimos/robot/unitree/type/lidar.py
+++ b/dimos/robot/unitree/type/lidar.py
@@ -100,7 +100,7 @@ def _repair(item: T) -> T:
         if prev_good[0] is not None and item.ts <= prev_good[0]:
             old = item.ts
             item.ts = prev_good[0] + default_period
-            logger.warning("repair_stale_ts: stale stamp %.6f → %.6f", old, item.ts)
+            logger.debug("repair_stale_ts: stale stamp %.6f → %.6f", old, item.ts)
         prev_good[0] = item.ts
         return item
 
diff --git a/dimos/teleop/quest_hosted/blueprints.py b/dimos/teleop/quest_hosted/blueprints.py
index e757ffae35..15d42b8ebf 100644
--- a/dimos/teleop/quest_hosted/blueprints.py
+++ b/dimos/teleop/quest_hosted/blueprints.py
@@ -15,10 +15,15 @@
 
 """Hosted teleop blueprints (WebRTC transport)."""
 
+from pathlib import Path
+
 from dimos.control.blueprints.teleop import coordinator_teleop_sim_xarm7
 from dimos.core.coordination.blueprints import autoconnect
+from dimos.core.stream import In
 from dimos.core.transport import LCMTransport
+from dimos.memory2.module import Recorder, RecorderConfig
 from dimos.msgs.geometry_msgs.PoseStamped import PoseStamped
+from dimos.msgs.geometry_msgs.TwistStamped import TwistStamped
 from dimos.robot.unitree.go2.blueprints.basic.unitree_go2_basic import unitree_go2_basic
 from dimos.teleop.quest.quest_types import Buttons
 from dimos.teleop.quest_hosted.hosted_extensions import (
@@ -49,4 +54,31 @@
 )
 
 
-__all__ = ["teleop_hosted_xarm7_sim", "teleop_hosted_go2"]
+class HostedTeleopRecorderConfig(RecorderConfig):
+    db_path: str | Path = "recording_hosted_3.db"
+
+
+class HostedTeleopRecorder(Recorder):
+    """Records hosted teleop streams. Captures whatever the connected blueprint
+    produces — VR controller poses + buttons (xarm7 sim), or cmd_vel_stamped
+    (go2). Unconnected ports stay empty in the DB.
+
+    Compose at the CLI::
+
+        dimos run teleop-hosted-xarm7-sim hosted-teleop-recorder
+        dimos run teleop-hosted-go2       hosted-teleop-recorder
+    """
+
+    right_controller_output: In[PoseStamped]
+    left_controller_output: In[PoseStamped]
+    buttons: In[Buttons]
+    cmd_vel_stamped: In[TwistStamped]
+    config: HostedTeleopRecorderConfig
+
+
+__all__ = [
+    "HostedTeleopRecorder",
+    "HostedTeleopRecorderConfig",
+    "teleop_hosted_xarm7_sim",
+    "teleop_hosted_go2",
+]
diff --git a/dimos/teleop/quest_hosted/hosted_extensions.py b/dimos/teleop/quest_hosted/hosted_extensions.py
index 37dc8b1b21..d9ac885e77 100644
--- a/dimos/teleop/quest_hosted/hosted_extensions.py
+++ b/dimos/teleop/quest_hosted/hosted_extensions.py
@@ -118,8 +118,9 @@ def _on_twist_bytes(self, data: bytes) -> None:
         msg = TwistStamped.lcm_decode(data)
         ls = self.config.linear_speed
         as_ = self.config.angular_speed
-        twist = Twist(
-            linear=Vector3(msg.linear.x * ls, msg.linear.y * ls, msg.linear.z * ls),
-            angular=Vector3(msg.angular.x * as_, msg.angular.y * as_, msg.angular.z * as_),
+        linear = Vector3(msg.linear.x * ls, msg.linear.y * ls, msg.linear.z * ls)
+        angular = Vector3(msg.angular.x * as_, msg.angular.y * as_, msg.angular.z * as_)
+        self.cmd_vel.publish(Twist(linear=linear, angular=angular))
+        self.cmd_vel_stamped.publish(
+            TwistStamped(ts=msg.ts, frame_id=msg.frame_id, linear=linear, angular=angular)
         )
-        self.cmd_vel.publish(twist)
diff --git a/dimos/teleop/quest_hosted/hosted_teleop_module.py b/dimos/teleop/quest_hosted/hosted_teleop_module.py
index ebf7e62f81..38ec9224b4 100644
--- a/dimos/teleop/quest_hosted/hosted_teleop_module.py
+++ b/dimos/teleop/quest_hosted/hosted_teleop_module.py
@@ -87,6 +87,7 @@ class HostedTeleopModule(Module):
     right_controller_output: Out[PoseStamped]
     buttons: Out[Buttons]
     cmd_vel: Out[Twist]
+    cmd_vel_stamped: Out[TwistStamped]
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
@@ -375,12 +376,12 @@ def _on_joy_bytes(self, data: bytes) -> None:
             self._controllers[hand] = controller
 
     def _on_twist_bytes(self, data: bytes) -> None:
-        # Keyboard mode — no engagement gating. Wire format is TwistStamped
-        # (carries timestamp); strip the header and publish plain Twist on
-        # cmd_vel (matches GO2Connection.cmd_vel and most ROS-style bases).
+        # Keyboard mode — no engagement gating. Wire format is TwistStamped;
+        # publish on both cmd_vel (plain, for GO2 / standard consumers) and
+        # cmd_vel_stamped (with header, for recorders / latency analyzers).
         msg = TwistStamped.lcm_decode(data)
-        twist = Twist(linear=msg.linear, angular=msg.angular)
-        self.cmd_vel.publish(twist)
+        self.cmd_vel.publish(Twist(linear=msg.linear, angular=msg.angular))
+        self.cmd_vel_stamped.publish(msg)
 
     @staticmethod
     def _resolve_hand(frame_id: str) -> Hand:
diff --git a/dimos/teleop/utils/latency_analyzer_twist.ipynb b/dimos/teleop/utils/latency_analyzer_twist.ipynb
new file mode 100644
index 0000000000..968747f15a
--- /dev/null
+++ b/dimos/teleop/utils/latency_analyzer_twist.ipynb
@@ -0,0 +1,249 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "intro",
+   "metadata": {},
+   "source": [
+    "# Hosted teleop TwistStamped latency\n",
+    "\n",
+    "End-to-end latency for the keyboard → Cloudflare WebRTC → robot path.\n",
+    "\n",
+    "- **Source stamp** (`o.data.ts`): set in the browser when the key/state was sampled, encoded into the `TwistStamped.header.stamp`.\n",
+    "- **Recorder stamp** (`o.ts`): time the recorder ingested the published message on the robot.\n",
+    "\n",
+    "`latency = o.ts - o.data.ts` covers send → WebRTC SFU → decode → republish → record. Assumes browser and robot clocks are roughly NTP-synced; if they aren't, the histogram shape is still meaningful (jitter), only the absolute offset is off."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "recording: recording_hosted_3.db\n",
+      "  Stream(\"buttons\"): 7164 items, 2026-05-10 00:39:11 — 2026-05-10 00:42:07 (176.5s)\n",
+      "  Stream(\"cmd_vel_stamped\"): 10613 items, 2026-05-10 00:39:24 — 2026-05-10 00:42:07 (163.0s)\n",
+      "  Stream(\"left_controller_output\"): empty\n",
+      "  Stream(\"right_controller_output\"): empty\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "from dimos.memory2.store.sqlite import SqliteStore\n",
+    "\n",
+    "RECORDING_PATH = Path(\"../../../recording_hosted_3.db\")\n",
+    "\n",
+    "store = SqliteStore(path=str(RECORDING_PATH))\n",
+    "obs = {name: stream.to_list() for name, stream in store.streams.items()}\n",
+    "\n",
+    "print(f\"recording: {RECORDING_PATH.name}\")\n",
+    "for name in obs:\n",
+    "    print(f\"  {store.streams[name].summary()}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "lat-md",
+   "metadata": {},
+   "source": [
+    "## Latency: source → recorder\n",
+    "\n",
+    "Histogram (log y) with p50/p95/p99 markers. Negative values = browser clock ahead of robot clock; large positive tail = network/process stalls."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "lat-code",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dropped 480/10613 outliers outside [-8.5, 158.6] ms\n",
+      "n=10133  min=49.3  p50=66.3  p95=130.1  p99=149.2  max=158.6  mean=75.9 ms\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x320 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Tukey IQR fence — drop samples outside [Q1 - K*IQR, Q3 + K*IQR].\n",
+    "OUTLIER_K = 1.5\n",
+    "\n",
+    "twist = obs.get(\"cmd_vel_stamped\", [])\n",
+    "if not twist:\n",
+    "    print(\"no cmd_vel_stamped stream\")\n",
+    "else:\n",
+    "    src = np.array([o.data.ts for o in twist])\n",
+    "    rec = np.array([o.ts for o in twist])\n",
+    "    lat_ms_all = (rec - src) * 1000.0\n",
+    "\n",
+    "    q1, q3 = np.percentile(lat_ms_all, [25, 75])\n",
+    "    iqr = q3 - q1\n",
+    "    lo, hi = q1 - OUTLIER_K * iqr, q3 + OUTLIER_K * iqr\n",
+    "    mask = (lat_ms_all >= lo) & (lat_ms_all <= hi)\n",
+    "    lat_ms = lat_ms_all[mask]\n",
+    "    rec_inlier = rec[mask]\n",
+    "    dropped = len(lat_ms_all) - len(lat_ms)\n",
+    "    print(f\"dropped {dropped}/{len(lat_ms_all)} outliers outside [{lo:.1f}, {hi:.1f}] ms\")\n",
+    "\n",
+    "    p50, p95, p99 = np.percentile(lat_ms, [50, 95, 99])\n",
+    "    print(\n",
+    "        f\"n={len(lat_ms)}  min={lat_ms.min():.1f}  p50={p50:.1f}  p95={p95:.1f}  \"\n",
+    "        f\"p99={p99:.1f}  max={lat_ms.max():.1f}  mean={lat_ms.mean():.1f} ms\"\n",
+    "    )\n",
+    "\n",
+    "    fig, ax = plt.subplots(figsize=(11, 3.2))\n",
+    "    ax.hist(lat_ms, bins=80, log=True, color=\"steelblue\", edgecolor=\"none\")\n",
+    "    for p, c, lbl in [(p50, \"black\", \"p50\"), (p95, \"orange\", \"p95\"), (p99, \"red\", \"p99\")]:\n",
+    "        ax.axvline(p, color=c, linestyle=\"--\", lw=0.8, label=f\"{lbl}={p:.1f}ms\")\n",
+    "    ax.set_title(\n",
+    "        f\"cmd_vel_stamped latency (source → recorder), n={len(lat_ms)} ({dropped} outliers dropped)\"\n",
+    "    )\n",
+    "    ax.set_xlabel(\"latency (ms)\")\n",
+    "    ax.set_ylabel(\"count (log)\")\n",
+    "    ax.legend(fontsize=8)\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ts-md",
+   "metadata": {},
+   "source": [
+    "## Latency over time\n",
+    "\n",
+    "Drift or burst stalls show up here. Steady horizontal band = stable transport; ramps = clock drift; spikes = network jitter / SFU / GC."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "ts-code",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x320 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if twist:\n",
+    "    rel = rec_inlier - rec_inlier[0]\n",
+    "    fig, ax = plt.subplots(figsize=(11, 3.2))\n",
+    "    ax.plot(rel, lat_ms, lw=0.5, color=\"steelblue\")\n",
+    "    ax.axhline(p50, color=\"black\", ls=\"--\", lw=0.8, label=f\"p50={p50:.1f}\")\n",
+    "    ax.axhline(p95, color=\"orange\", ls=\"--\", lw=0.8, label=f\"p95={p95:.1f}\")\n",
+    "    ax.set_xlabel(\"time since first sample (s)\")\n",
+    "    ax.set_ylabel(\"latency (ms)\")\n",
+    "    ax.set_title(\"latency over time (outliers removed)\")\n",
+    "    ax.legend(fontsize=8)\n",
+    "    ax.grid(alpha=0.3)\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "rate-md",
+   "metadata": {},
+   "source": [
+    "## Inter-arrival jitter\n",
+    "\n",
+    "Source-side cadence (browser sendInterval) vs recorder-side cadence. If recorder intervals are much wider than source intervals, the transport is bunching/dropping."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "rate-code",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x320 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if twist:\n",
+    "    src_iv = np.diff(np.sort(src)) * 1000.0\n",
+    "    rec_iv = np.diff(np.sort(rec)) * 1000.0\n",
+    "    fig, axes = plt.subplots(1, 2, figsize=(11, 3.2), sharey=True)\n",
+    "    for ax, iv, lbl in [(axes[0], src_iv, \"source (browser)\"), (axes[1], rec_iv, \"recorder (robot)\")]:\n",
+    "        rate = 1000.0 / np.median(iv)\n",
+    "        p50, p95 = np.percentile(iv, [50, 95])\n",
+    "        ax.hist(iv, bins=80, log=True, color=\"steelblue\", edgecolor=\"none\")\n",
+    "        ax.axvline(p50, color=\"black\", ls=\"--\", lw=0.8, label=f\"p50={p50:.1f}\")\n",
+    "        ax.axvline(p95, color=\"orange\", ls=\"--\", lw=0.8, label=f\"p95={p95:.1f}\")\n",
+    "        ax.set_title(f\"{lbl}: ~{rate:.1f} Hz\")\n",
+    "        ax.set_xlabel(\"interval (ms)\")\n",
+    "        ax.legend(fontsize=8)\n",
+    "    axes[0].set_ylabel(\"count (log)\")\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "963205d0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dimos (3.12.12)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}