Team JAMJAM

[HaroldGin931]

Summary

Build something you would like to use everyday!

This PR is based on the jamjam branch.

This time, we used DimOS to build a focus helper: the robot dog helps keep your phone away from you during a specific period of time, so you can stay focused.

Video link: Click here
Deck link: Click here
Thanks to our lovely designer.

This was our original idea.

What We Implemented

• BBox-based selection module, used to activate a specific task module.
• An interactive web UI for the robot. Thanks to our senior Harry Potter fan.
• A degraded action strategy: after selecting a bbox, we calculate the spatial coordinate and generate a near point and a far point.

What We Did Not Implement

• Continuous tracking.

On macOS, DimOS MuJoCo also calls OpenCV. When our custom module needs to call OpenCV too, it can cause a multithreading conflict and crash, so we could not finish continuous tracking in time.

What We Love

We really love the design of Module and Blueprint. They can be freely combined, just like LEGO bricks.

Some people on our team work on BSP and a little bit of circuit design, and they also really liked this design. They said it feels very intuitive.

[greptile-apps]

Greptile Summary

This PR adds Team JAMJAM's hackathon focus-helper application: a Harry-Potter-themed "Marauder's Map" web UI that plots detected people on an occupancy-grid floor plan and lets the robot dog follow a selected person (to keep a phone out of reach). The stack builds on a new BBoxSelectionModule / TargetLockModule / BBoxDistanceBehaviorModule pipeline plus a Socket.IO web server, all wired together via an autoconnect blueprint.

• New ReidMapModule (835 lines) serves a Socket.IO web page showing a live occupancy-grid map with reID-tracked person markers; web clicks synthesize PointStamped events that flow into the existing BBoxSelectionModule without touching upstream modules.
• UnitreeWebRTCConnection gains a configurable connection method, a two-step FreeWalk + SwitchJoystick gait init (plus 15-second heartbeat), and a "look up on stop" head-tilt behaviour.
• MovementManager now filters out color-image-frame clicks before they reach the navigation goal path, and publishes stop_movement before issuing a new A* goal.

Confidence Score: 3/5

The web-UI stop signal won't reach the selection/lock modules due to a missing topic remapping, and the connect-event handler iterates a dict that the detection thread can concurrently mutate — both need fixes before the Marauder's Map blueprint is reliable on real hardware.

Two issues need attention before this runs cleanly in the field. The ReidMapModule.stop_movement output is never remapped to teleop_active, so web-driven deselect is silently dropped when the detection stream has no current frame — the robot can restart following unexpectedly. Separately, _people_payload() is called from the Socket.IO asyncio thread while the detection subscription thread can add or remove entries from self._people, creating a real risk of RuntimeError: dictionary changed size during iteration whenever a new browser tab connects during active detection. The rest of the stack — the new bbox-selection/follow pipeline, FreeWalk heartbeat, movement-manager click filter, and macOS SDL fix — is well-structured and low-risk.

dimos/apps/marauders_map/module.py (thread-safety and CORS) and dimos/apps/marauders_map/blueprint.py (missing stop_movement → teleop_active remapping for ReidMapModule).

Security Review

• Open CORS policy (cors_allowed_origins="*") on the Socket.IO server in dimos/apps/marauders_map/module.py allows any web origin on the same network to connect and send teleop, selection, and navigation commands to the robot.

Important Files Changed

Filename	Overview
dimos/apps/marauders_map/module.py	New 835-line ReidMapModule: Socket.IO web server serving the Marauder's Map UI; has a thread-safety bug where the connect handler iterates _people from the asyncio thread while the detection stream thread can concurrently modify it, and CORS is fully open.
dimos/apps/marauders_map/blueprint.py	New blueprint wiring the Marauder's Map stack; ReidMapModule.stop_movement output is not remapped to the teleop_active topic, so web-UI stop signals won't reach BBoxSelectionModule or TargetLockModule.
dimos/robot/unitree/connection.py	Adds configurable WebRTC connection method, head look-up on stop, and two-step FreeWalk+SwitchJoystick; _cancel_stop_timer now calls look_up() which can fire spuriously during mid-movement timer cancellation.
dimos/robot/unitree/go2/connection.py	Adds FreeWalk initialization (double-publish + SwitchJoystick) and a daemon heartbeat thread that re-asserts FreeWalk every 15 s; heartbeat lacks a clean shutdown signal.
dimos/robot/custom/modules/bbox_selection_module.py	New BBoxSelectionModule: click-to-bbox selection with RLock protection, stop_movement and clear_selection_request inputs; logic is sound and well-tested.
dimos/robot/custom/tasks/bbox_distance_behavior_module.py	New BBoxDistanceBehaviorModule: proportional distance-follow control loop; implementation is straightforward with proper RLock usage and stop-event for the background command thread.
dimos/navigation/movement_manager/movement_manager.py	Adds _is_navigation_click filter to ignore color_image-frame clicks in the movement manager, and publishes stop_movement before handing a new goal to the planner; logic is correct.
dimos/visualization/rerun/websocket_server.py	Refactors click/twist field extraction to use a _coerce_float helper with null-safe fallback and adds verbose click logging; straightforward improvement with no issues.
dimos/robot/unitree/keyboard_teleop.py	Fixes macOS crash by using setdefault("SDL_VIDEODRIVER", "cocoa") on darwin instead of unconditionally forcing x11; correct and safe.
scripts/run-blueprint.sh	New helper script that runs any blueprint and tee-logs output to /tmp/dimos-logs/ with auto-rotation; handles SIM/REPLAY/ROBOT_IP modes and the mjpython dispatch for MuJoCo on macOS.

Sequence Diagram

sequenceDiagram
    participant Browser as Browser (port 7782)
    participant ReidMap as ReidMapModule
    participant BBoxSel as BBoxSelectionModule
    participant TgtLock as TargetLockModule
    participant BBoxDist as BBoxDistanceBehaviorModule
    participant MovMgr as MovementManager
    participant Robot as Go2 Robot

    Browser->>ReidMap: "Socket.IO select {id}"
    ReidMap->>BBoxSel: stop_movement Out[Bool] NOT CONNECTED missing remap
    ReidMap->>BBoxSel: clicked_point PointStamped bbox center
    BBoxSel->>TgtLock: selected_bbox Detection2DArray
    TgtLock->>BBoxDist: locked_bbox Detection2DArray
    BBoxDist->>MovMgr: nav_cmd_vel Twist
    MovMgr->>Robot: cmd_vel

    Browser->>ReidMap: "Socket.IO teleop {linear_x, angular_z}"
    ReidMap->>MovMgr: tele_cmd_vel Twist
    MovMgr->>BBoxSel: teleop_active Bool clears selection
    MovMgr->>Robot: cmd_vel priority teleop

    Browser->>ReidMap: "Socket.IO navigate {wx, wy}"
    ReidMap->>MovMgr: goal_request PoseStamped
    MovMgr->>Robot: "nav_cmd_vel via A*"

Loading

_{Reviews (1): Last reviewed commit: "demo blueprint yoloe-spatial-standoff-fo..." | Re-trigger Greptile}

[greptile-apps]

Thread safety: _people iterated from asyncio thread while stream thread mutates it

connect calls self._people_payload() from the Socket.IO / asyncio event loop, which iterates self._people (line 741 for tid, e in self._people.items()). Meanwhile _on_detections — running on the RxPY stream subscription thread — can write to self._people (via _write_entry and _expire_people) at any time. If the stream thread adds or removes a key while the asyncio thread is mid-iteration Python raises RuntimeError: dictionary changed size during iteration, crashing the connect handler silently. Unlike _latest_image / _latest_pc, _people and _stable_to_raw_det are never guarded by self._lock when read from the asyncio thread.

[greptile-apps]

cors_allowed_origins="*" makes the Socket.IO endpoint reachable from any web origin. On a shared or conference Wi-Fi network (common at hackathons and field demos) a page on any other device can drive the robot's selection, teleop, and navigation streams. Restricting to localhost or the field subnet provides a simple first layer of defence.

Suggested change

	self.sio = socketio.AsyncServer(async_mode="asgi", cors_allowed_origins="*")
	self.sio = socketio.AsyncServer(async_mode="asgi", cors_allowed_origins="*") # TODO: restrict to trusted origin(s) before production use

[greptile-apps]

ReidMapModule.stop_movement output is never remapped to teleop_active

The blueprint renames BBoxSelectionModule.stop_movement, TargetLockModule.stop_movement, and MovementManager.stop_movement all to the topic teleop_active, but ReidMapModule.stop_movement: Out[Bool] is left on the default stop_movement topic. These two topics won't be connected by autoconnect, so the stop_movement.publish(Bool(data=True)) calls inside the select, deselect, and navigate Socket.IO handlers never reach BBoxSelectionModule or TargetLockModule. When the tracker has no live detections the backup clear-via-click path also short-circuits, leaving a stale selection active that can restart following the moment a new detection frame arrives.

[greptile-apps]

_freewalk_heartbeat loops forever with no shutdown path

The heartbeat thread runs while True and is only a daemon=True thread — it lives for the entire process lifetime and cannot be interrupted during a clean stop() sequence. If teardown blocks on the connection or a command is dispatched mid-shutdown, the exception is silently swallowed and the loop continues. A threading.Event stop signal (checked after each time.sleep(15)) would let GO2Connection.stop() interrupt the loop quickly.

[greptile-apps]

look_up() fires spuriously when _cancel_stop_timer is used to cancel (not fire) a pending timer

If _cancel_stop_timer is called while a new movement command is being prepared (to cancel the previous stop timer), self._was_moving is still True from the prior motion, so look_up() is called — tilting the head right before the robot resumes walking. _update_head_posture would then immediately call reset_posture(), causing a brief involuntary head-tilt on every command boundary. Limiting the look_up branch to the actual timeout path (e.g., by using a dedicated timer-callback method rather than the shared cancel helper) would avoid this.