fix cogwheel not showing up

README.md

@@ -20,8 +20,7 @@ models:
 datasets:
   - pollen-robotics/reachy-mini-emotions-library
   - pollen-robotics/reachy-mini-dances-library
-thumbnail: >-
-  https://huggingface.co/spaces/panny247/hello_world/resolve/main/screenshots/thumbnail.png
+thumbnail: https://huggingface.co/spaces/panny247/hello_world/resolve/main/screenshots/thumbnail.png
 ---
 
 <div align="center">

hello_world/main.py

@@ -1,13 +1,233 @@
 """
-Hello World - Main entry point.
+HelloWorld Application Class.
 
-A developer-friendly dashboard app for the Reachy Mini robot.
+The main application class that inherits from ReachyMiniApp.
+Provides a Status dashboard with system telemetry and robot state.
 """
 
-from .app import HelloWorld
-
 __all__ = ['HelloWorld']
 
+import logging
+import os
+import threading
+import time
+import urllib.request
+
+from reachy_mini import ReachyMini, ReachyMiniApp
+
+from .api import register_all_routes
+from .api.oscillation import oscillation_tick
+from .api.timers import timer_tick
+from .api.alarms import alarm_tick
+from .config import config
+from .settings import load_settings
+from .camera_registry import CameraRegistry
+from .vision_inference import VisionInference
+from .stats import (
+    get_cpu_stats, get_memory_stats, get_disk_stats, get_network_stats,
+    get_wifi_stats, get_uptime_stats, get_load_stats, get_fan_stats,
+    get_throttle_stats, get_disk_io_stats, get_top_processes, get_hardware_info,
+    get_thread_stats
+)
+from .websocket import register_websockets
+
+logger = logging.getLogger("reachy_mini.app.hello_world")
+
+
+class HelloWorld(ReachyMiniApp):
+    """A developer dashboard app for Reachy Mini with system telemetry."""
+
+    custom_app_url: str | None = "http://0.0.0.0:8042"
+    request_media_backend: str | None = "no_media" if os.environ.get("DEMO_MODE") else None
+
+    def __init__(self):
+        super().__init__()
+        self._reachy_mini = None
+        self._start_time = time.time()
+        # Tracking dicts for stats that need delta calculations
+        self._last_net = {"rx": 0, "tx": 0, "time": time.time()}
+        self._disk_cache = {"local": None, "remote": None, "swap": None, "time": 0}
+        self._disk_cache_ttl = 60
+        self._last_disk_io = {"read": 0, "write": 0, "time": time.time()}
+        self._process_cache = {"processes": [], "time": 0}
+        self._hardware_cache = {}
+        # Load persistent settings
+        self._settings = load_settings()
+        # Transcript WebSocket clients for conversation broadcast
+        self._transcribe_websockets = set()
+
+        # Oscillation state
+        self._oscillation_active = False
+        self._oscillation_pattern = None
+        self._oscillation_amplitude = 0.5
+        self._oscillation_speed = 1.0
+        self._oscillation_start_time = 0
+
+        # Move playback state
+        self._playing_move = None
+        self._playing_move_task = None
+
+        # Timer/alarm state
+        self._timers = {}
+        self._last_timer_tick = 0
+        self._last_alarm_tick = 0
+
+        # TTS/ambient coordination
+        self._tts_speaking = False
+
+        # Zenoh watchdog state
+        self._zenoh_last_check = 0
+        self._zenoh_last_reconnect = 0
+        self._zenoh_reconnect_backoff = 5   # seconds, grows on failure
+        self._zenoh_reconnect_failures = 0
+        self._zenoh_was_alive = True
+
+        # Camera registry (unified frame source for all consumers)
+        self._cameras = CameraRegistry(self)
+
+        # Vision inference engine
+        self._vision = VisionInference(self)
+
+        # Register WebSocket endpoints + cache control
+        if self.settings_app is not None:
+            register_websockets(self)
+
+            # Force browsers to revalidate HTML pages (prevents stale ?v=N references)
+            @self.settings_app.middleware("http")
+            async def cache_control(request, call_next):
+                response = await call_next(request)
+                ct = response.headers.get("content-type", "")
+                if "text/html" in ct:
+                    response.headers["Cache-Control"] = "no-cache, must-revalidate"
+                return response
+
+    def _get_stats(self):
+        """Get all system stats using focused stat functions."""
+        result = {}
+        result.update(get_cpu_stats())
+        result.update(get_memory_stats())
+        result.update(get_disk_stats(self._disk_cache, self._disk_cache_ttl))
+        result.update(get_network_stats(self._last_net))
+        result.update(get_wifi_stats())
+        result.update(get_uptime_stats())
+        result.update(get_load_stats())
+        result.update(get_fan_stats())
+        result.update(get_throttle_stats())
+        result.update(get_disk_io_stats(self._last_disk_io))
+        result.update(get_top_processes(self._process_cache))
+        result.update(get_hardware_info(self._hardware_cache))
+        result.update(get_thread_stats())
+        return result
+
+    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
+        """Main app loop."""
+        self._reachy_mini = reachy_mini
+
+        # Register all API routes
+        register_all_routes(self)
+
+        # Force OpenAPI schema regeneration after all routes are registered
+        # (uvicorn starts before routes are registered, causing stale cache)
+        if self.settings_app is not None:
+            self.settings_app.openapi_schema = None
+            self.settings_app.openapi()
+
+        # Restore active camera from settings
+        saved_camera = self._settings.get("active_camera", "robot")
+        if saved_camera != "robot":
+            self._cameras.set_active_camera(saved_camera)
+
+        # Apply saved motor mode on startup
+        saved_mode = self._settings.get("motor_mode", "enabled")
+        if saved_mode != "enabled":
+            try:
+                req = urllib.request.Request(
+                    config.get_daemon_endpoint(f"motors/set_mode/{saved_mode}"),
+                    method="POST"
+                )
+                with urllib.request.urlopen(req, timeout=config.TIMEOUTS['daemon_move']) as resp:
+                    logger.info(f"Applied saved motor mode: {saved_mode}")
+            except Exception as e:
+                logger.warning(f"Failed to apply saved motor mode: {e}")
+
+        # Main loop (50Hz — oscillation tick + timer/alarm checks + sleep)
+        while not stop_event.is_set():
+            now = time.time()
+            self._zenoh_watchdog(now)
+            oscillation_tick(self, now)
+            timer_tick(self, now)
+            alarm_tick(self, now)
+            time.sleep(0.02)
+
+    def _zenoh_watchdog(self, now: float):
+        """Monitor Zenoh connection and auto-reconnect if it drops.
+
+        Checks every 5s. On disconnect, attempts to create a fresh
+        ReachyMini (which creates a new ZenohClient + Zenoh session).
+        Uses exponential backoff on repeated failures (5s → 10s → 20s → 60s max).
+        """
+        # Rate limit checks to every 5 seconds
+        if now - self._zenoh_last_check < 5.0:
+            return
+        self._zenoh_last_check = now
+
+        if self._reachy_mini is None:
+            return
+
+        # Read connection state from the client's check_alive thread
+        try:
+            is_alive = self._reachy_mini.client._is_alive
+        except Exception:
+            is_alive = False
+
+        if is_alive:
+            if not self._zenoh_was_alive:
+                logger.info("Zenoh connection restored")
+                self._zenoh_reconnect_failures = 0
+                self._zenoh_reconnect_backoff = 5
+            self._zenoh_was_alive = True
+            return
+
+        # Connection is dead — log on first detection
+        if self._zenoh_was_alive:
+            logger.warning("Zenoh connection lost — watchdog will attempt reconnection")
+            self._zenoh_was_alive = False
+
+        # Respect backoff between reconnect attempts
+        if now - self._zenoh_last_reconnect < self._zenoh_reconnect_backoff:
+            return
+
+        self._zenoh_last_reconnect = now
+        self._zenoh_reconnect_failures += 1
+        logger.info(
+            f"Zenoh reconnect attempt {self._zenoh_reconnect_failures} "
+            f"(backoff {self._zenoh_reconnect_backoff}s)"
+        )
+
+        try:
+            # Disconnect old client (closes session, stops subscribers)
+            old_rm = self._reachy_mini
+            try:
+                old_rm.client.disconnect()
+            except Exception:
+                pass
+
+            # Create fresh ReachyMini with new Zenoh session
+            new_rm = ReachyMini(localhost_only=True, timeout=3.0)
+            self._reachy_mini = new_rm
+            self._zenoh_was_alive = True
+            self._zenoh_reconnect_failures = 0
+            self._zenoh_reconnect_backoff = 5
+            logger.info("Zenoh reconnected successfully — new session active")
+
+        except Exception as e:
+            # Backoff: 5 → 10 → 20 → 40 → 60 (cap)
+            self._zenoh_reconnect_backoff = min(60, self._zenoh_reconnect_backoff * 2)
+            logger.warning(
+                f"Zenoh reconnect failed: {e} — "
+                f"next attempt in {self._zenoh_reconnect_backoff}s"
+            )
+
 if __name__ == "__main__":
     app = HelloWorld()
     try:

pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "hello-world"
+name = "hello_world"
 version = "0.1.0"
 description = "A community hello world app for Reachy Mini with system telemetry dashboard"
 requires-python = ">=3.10"