feat(viz): add RerunWebSocketServer for dimos-viewer remote mode

dimos/core/docker_module.py

@@ -30,7 +30,7 @@
 from dimos.core.rpc_client import ModuleProxyProtocol, RpcCall
 from dimos.protocol.rpc.pubsubrpc import LCMRPC
 from dimos.utils.logging_config import setup_logger
-from dimos.visualization.rerun.bridge import RERUN_GRPC_PORT, RERUN_WEB_PORT
+from dimos.visualization.constants import RERUN_GRPC_PORT, RERUN_WEB_PORT
 
 if TYPE_CHECKING:
     from collections.abc import Callable

dimos/core/global_config.py

@@ -13,13 +13,16 @@
 # limitations under the License.
 
 import re
-from typing import Literal, TypeAlias
 
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from dimos.models.vl.types import VlModelName
-
-ViewerBackend: TypeAlias = Literal["rerun", "rerun-web", "rerun-connect", "foxglove", "none"]
+from dimos.visualization.constants import (
+    RERUN_ENABLE_WEB,
+    RERUN_OPEN_DEFAULT,
+    RerunOpenOption,
+    ViewerBackend,
+)
 
 
 def _get_all_numbers(s: str) -> list[float]:
@@ -37,6 +40,8 @@ class GlobalConfig(BaseSettings):
     replay_dir: str = "go2_sf_office"
     new_memory: bool = False
     viewer: ViewerBackend = "rerun"
+    rerun_open: RerunOpenOption = RERUN_OPEN_DEFAULT
+    rerun_web: bool = RERUN_ENABLE_WEB
     n_workers: int = 2
     memory_limit: str = "auto"
     mujoco_camera_position: str | None = None

dimos/hardware/sensors/camera/module.py

@@ -22,6 +22,7 @@
 from dimos.agents.annotation import skill
 from dimos.core.coordination.blueprints import autoconnect
 from dimos.core.core import rpc
+from dimos.core.global_config import global_config
 from dimos.core.module import Module, ModuleConfig
 from dimos.core.stream import Out
 from dimos.hardware.sensors.camera.spec import CameraHardware
@@ -32,7 +33,7 @@
 from dimos.msgs.sensor_msgs.CameraInfo import CameraInfo
 from dimos.msgs.sensor_msgs.Image import Image, sharpness_barrier
 from dimos.spec import perception
-from dimos.visualization.rerun.bridge import RerunBridgeModule
+from dimos.visualization.vis_module import vis_module
 
 
 def default_transform() -> Transform:
@@ -120,5 +121,5 @@ def stop(self) -> None:
 
 demo_camera = autoconnect(
     CameraModule.blueprint(),
-    RerunBridgeModule.blueprint(),
+    vis_module(viewer_backend=global_config.viewer),
 )

dimos/hardware/sensors/lidar/fastlio2/fastlio_blueprints.py

@@ -15,36 +15,45 @@
 from dimos.core.coordination.blueprints import autoconnect
 from dimos.hardware.sensors.lidar.fastlio2.module import FastLio2
 from dimos.mapping.voxels import VoxelGridMapper
-from dimos.visualization.rerun.bridge import RerunBridgeModule
+from dimos.visualization.vis_module import vis_module
 
 voxel_size = 0.05
 
 mid360_fastlio = autoconnect(
     FastLio2.blueprint(voxel_size=voxel_size, map_voxel_size=voxel_size, map_freq=-1),
-    RerunBridgeModule.blueprint(
-        visual_override={
-            "world/lidar": lambda grid: grid.to_rerun(voxel_size=voxel_size, mode="boxes"),
-        }
+    vis_module(
+        "rerun",
+        rerun_config={
+            "visual_override": {
+                "world/lidar": lambda grid: grid.to_rerun(voxel_size=voxel_size, mode="boxes"),
+            },
+        },
     ),
 ).global_config(n_workers=2, robot_model="mid360_fastlio2")
 
 mid360_fastlio_voxels = autoconnect(
     FastLio2.blueprint(),
     VoxelGridMapper.blueprint(publish_interval=1.0, voxel_size=voxel_size, carve_columns=False),
-    RerunBridgeModule.blueprint(
-        visual_override={
-            "world/global_map": lambda grid: grid.to_rerun(voxel_size=voxel_size, mode="boxes"),
-            "world/lidar": None,
-        }
+    vis_module(
+        "rerun",
+        rerun_config={
+            "visual_override": {
+                "world/global_map": lambda grid: grid.to_rerun(voxel_size=voxel_size, mode="boxes"),
+                "world/lidar": None,
+            },
+        },
     ),
 ).global_config(n_workers=3, robot_model="mid360_fastlio2_voxels")
 
 mid360_fastlio_voxels_native = autoconnect(
     FastLio2.blueprint(voxel_size=voxel_size, map_voxel_size=voxel_size, map_freq=3.0),
-    RerunBridgeModule.blueprint(
-        visual_override={
-            "world/lidar": None,
-            "world/global_map": lambda grid: grid.to_rerun(voxel_size=voxel_size, mode="boxes"),
-        }
+    vis_module(
+        "rerun",
+        rerun_config={
+            "visual_override": {
+                "world/lidar": None,
+                "world/global_map": lambda grid: grid.to_rerun(voxel_size=voxel_size, mode="boxes"),
+            },
+        },
     ),
 ).global_config(n_workers=2, robot_model="mid360_fastlio2")

dimos/hardware/sensors/lidar/livox/livox_blueprints.py

@@ -14,9 +14,9 @@
 
 from dimos.core.coordination.blueprints import autoconnect
 from dimos.hardware.sensors.lidar.livox.module import Mid360
-from dimos.visualization.rerun.bridge import RerunBridgeModule
+from dimos.visualization.vis_module import vis_module
 
 mid360 = autoconnect(
     Mid360.blueprint(),
-    RerunBridgeModule.blueprint(),
+    vis_module("rerun"),
 ).global_config(n_workers=2, robot_model="mid360")

dimos/manipulation/grasping/demo_grasping.py

@@ -22,7 +22,7 @@
 from dimos.manipulation.grasping.grasping import GraspingModule
 from dimos.perception.detection.detectors.yoloe import YoloePromptMode
 from dimos.perception.object_scene_registration import ObjectSceneRegistrationModule
-from dimos.robot.foxglove_bridge import FoxgloveBridge
+from dimos.visualization.vis_module import vis_module
 
 camera_module = RealSenseCamera.blueprint(enable_pointcloud=False)
 
@@ -44,7 +44,7 @@
             ("/tmp", "/tmp", "rw")
         ],  # Grasp visualization debug standalone: python -m dimos.manipulation.grasping.visualize_grasps
     ),
-    FoxgloveBridge.blueprint(),
+    vis_module("foxglove"),
     McpServer.blueprint(),
     McpClient.blueprint(),
 ).global_config(viewer="foxglove")

dimos/navigation/cmd_vel_mux.py

@@ -0,0 +1,122 @@
+# Copyright 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.
+
+"""CmdVelMux: merges nav and teleop velocity commands.
+
+Teleop (tele_cmd_vel) takes priority over autonomous navigation
+(nav_cmd_vel). When teleop is active, nav commands are suppressed
+and a stop_movement signal is published. After a cooldown period
+with no teleop input, nav commands resume.
+"""
+
+from __future__ import annotations
+
+import threading
+from typing import Any
+
+from dimos_lcm.std_msgs import Bool
+
+from dimos.core.core import rpc
+from dimos.core.module import Module, ModuleConfig
+from dimos.core.stream import In, Out
+from dimos.msgs.geometry_msgs.Twist import Twist
+from dimos.utils.logging_config import setup_logger
+
+logger = setup_logger()
+
+
+class CmdVelMuxConfig(ModuleConfig):
+    teleop_cooldown_sec: float = 1.0
+
+
+class CmdVelMux(Module[CmdVelMuxConfig]):
+    """Multiplexes nav_cmd_vel and tele_cmd_vel into a single cmd_vel output.
+
+    When teleop input arrives, stop_movement is published so downstream
+    modules (planner, explorer) can cancel their active goals.
+
+    Ports:
+        nav_cmd_vel (In[Twist]): Velocity from the autonomous planner.
+        tele_cmd_vel (In[Twist]): Velocity from keyboard/joystick teleop.
+        cmd_vel (Out[Twist]): Merged output — teleop wins when active.
+        stop_movement (Out[Bool]): Published when teleop begins.
+    """
+
+    default_config = CmdVelMuxConfig
+
+    nav_cmd_vel: In[Twist]
+    tele_cmd_vel: In[Twist]
+    cmd_vel: Out[Twist]
+    stop_movement: Out[Bool]
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._teleop_active = False
+        self._lock = threading.Lock()
+        self._timer: threading.Timer | None = None
+
+    def __getstate__(self) -> dict[str, Any]:
+        state: dict[str, Any] = super().__getstate__()  # type: ignore[no-untyped-call]
+        state.pop("_lock", None)
+        state.pop("_timer", None)
+        return state
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        super().__setstate__(state)
+        self._lock = threading.Lock()
+        self._timer = None
+
+    @rpc
+    def start(self) -> None:
+        self.nav_cmd_vel.subscribe(self._on_nav)
+        self.tele_cmd_vel.subscribe(self._on_teleop)
+
+    @rpc
+    def stop(self) -> None:
+        with self._lock:
+            if self._timer is not None:
+                self._timer.cancel()
+                self._timer = None
+        super().stop()
+
+    def _on_nav(self, msg: Twist) -> None:
+        with self._lock:
+            if self._teleop_active:
+                return
+        self.cmd_vel.publish(msg)
+
+    def _on_teleop(self, msg: Twist) -> None:
+        was_active: bool
+        with self._lock:
+            was_active = self._teleop_active
+            self._teleop_active = True
+            if self._timer is not None:
+                self._timer.cancel()
+            self._timer = threading.Timer(
+                self.config.teleop_cooldown_sec,
+                self._end_teleop,
+            )
+            self._timer.daemon = True
+            self._timer.start()
+
+        if not was_active:
+            self.stop_movement.publish(Bool(data=True))
+            logger.info("Teleop active — published stop_movement")
+
+        self.cmd_vel.publish(msg)
+
+    def _end_teleop(self) -> None:
+        with self._lock:
+            self._teleop_active = False
+            self._timer = None

dimos/navigation/frontier_exploration/wavefront_frontier_goal_selector.py

@@ -115,6 +115,7 @@ class WavefrontFrontierExplorer(Module[WavefrontConfig]):
     goal_reached: In[Bool]
     explore_cmd: In[Bool]
     stop_explore_cmd: In[Bool]
+    stop_movement: In[Bool]
 
     # LCM outputs
     goal_request: Out[PoseStamped]
@@ -171,6 +172,10 @@ def start(self) -> None:
             unsub = self.stop_explore_cmd.subscribe(self._on_stop_explore_cmd)
             self._disposables.add(Disposable(unsub))
 
+        if self.stop_movement.transport is not None:
+            unsub = self.stop_movement.subscribe(self._on_stop_movement)
+            self._disposables.add(Disposable(unsub))
+
     @rpc
     def stop(self) -> None:
         self.stop_exploration()
@@ -201,6 +206,12 @@ def _on_stop_explore_cmd(self, msg: Bool) -> None:
             logger.info("Received exploration stop command via LCM")
             self.stop_exploration()
 
+    def _on_stop_movement(self, msg: Bool) -> None:
+        """Handle stop movement from teleop — cancel active exploration."""
+        if msg.data and self.exploration_active:
+            logger.info("WavefrontFrontierExplorer: stop_movement received, stopping exploration")
+            self.stop_exploration()
+
     def _count_costmap_information(self, costmap: OccupancyGrid) -> int:
         """
         Count the amount of information in a costmap (free space + obstacles).

dimos/navigation/replanning_a_star/module.py

@@ -21,6 +21,9 @@
 from dimos.core.core import rpc
 from dimos.core.module import Module
 from dimos.core.stream import In, Out
+from dimos.utils.logging_config import setup_logger
+
+logger = setup_logger()
 from dimos.msgs.geometry_msgs.PointStamped import PointStamped
 from dimos.msgs.geometry_msgs.PoseStamped import PoseStamped
 from dimos.msgs.geometry_msgs.Twist import Twist
@@ -36,10 +39,11 @@ class ReplanningAStarPlanner(Module, NavigationInterface):
     goal_request: In[PoseStamped]
     clicked_point: In[PointStamped]
     target: In[PoseStamped]
+    stop_movement: In[Bool]
 
     goal_reached: Out[Bool]
     navigation_state: Out[String]  # TODO: set it
-    cmd_vel: Out[Twist]
+    nav_cmd_vel: Out[Twist]
     path: Out[Path]
     navigation_costmap: Out[OccupancyGrid]
 
@@ -70,9 +74,12 @@ def start(self) -> None:
             )
         )
 
+        if self.stop_movement.transport is not None:
+            self._disposables.add(Disposable(self.stop_movement.subscribe(self._on_stop_movement)))
+
         self._disposables.add(self._planner.path.subscribe(self.path.publish))
 
-        self._disposables.add(self._planner.cmd_vel.subscribe(self.cmd_vel.publish))
+        self._disposables.add(self._planner.cmd_vel.subscribe(self.nav_cmd_vel.publish))
 
         self._disposables.add(self._planner.goal_reached.subscribe(self.goal_reached.publish))
 
@@ -90,6 +97,11 @@ def stop(self) -> None:
 
         super().stop()
 
+    def _on_stop_movement(self, msg: Bool) -> None:
+        if msg.data:
+            logger.info("ReplanningAStarPlanner: stop_movement received, cancelling goal")
+            self.cancel_goal()
+
     @rpc
     def set_goal(self, goal: PoseStamped) -> bool:
         self._planner.handle_goal_request(goal)