reachy-mini 1.2.5rc1__py3-none-any.whl → 1.2.11__py3-none-any.whl

reachy_mini/apps/app.py

@@ -10,13 +10,11 @@ It uses Jinja2 templates to generate the necessary files for the app project.
 import argparse
 import importlib
 import logging
-import platform
-import subprocess
 import threading
 import traceback
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 from urllib.parse import urlparse
 
 from fastapi import FastAPI
@@ -39,14 +37,16 @@ class ReachyMiniApp(ABC):
         self.error: str = ""
         self.logger = logging.getLogger("reachy_mini.app")
 
-        # If we're running with wireless, we assume systemd service is used
-        running_on_wireless = self._check_systemd_service_exists()
-        self.logger.info(f"Running on wireless: {running_on_wireless}")
+        # Detect if daemon is available on localhost
+        # If yes, use localhost connection. If no, use multicast scouting for remote daemon.
+        self.daemon_on_localhost = self._check_daemon_on_localhost()
+        self.logger.info(f"Daemon on localhost: {self.daemon_on_localhost}")
 
+        # Media backend is now auto-detected by ReachyMini, just use "default"
         self.media_backend = (
             self.request_media_backend
             if self.request_media_backend is not None
-            else ("gstreamer" if running_on_wireless else "default")
+            else "default"
         )
 
         self.settings_app: FastAPI | None = None
@@ -68,28 +68,23 @@ class ReachyMiniApp(ABC):
                         return FileResponse(index_file)
 
     @staticmethod
-    def _check_systemd_service_exists(service_name: str = "reachy-mini-daemon") -> bool:
-        """Check if a systemd service exists (Linux only).
+    def _check_daemon_on_localhost(port: int = 8000, timeout: float = 0.5) -> bool:
+        """Check if daemon is reachable on localhost.
 
         Args:
-            service_name: Name of the systemd service to check
+            port: Port to check (default: 8000)
+            timeout: Connection timeout in seconds
 
         Returns:
-            True if the service exists, False otherwise
+            True if daemon responds on localhost, False otherwise
 
         """
-        if platform.system() != "Linux":
-            return False
+        import socket
 
         try:
-            result = subprocess.run(
-                ["systemctl", "status", service_name],
-                capture_output=True,
-                timeout=2,
-            )
-            # Return code 0 = running, 3 = stopped but exists, 4 = doesn't exist
-            return result.returncode != 4
-        except (subprocess.TimeoutExpired, FileNotFoundError):
+            with socket.create_connection(("127.0.0.1", port), timeout=timeout):
+                return True
+        except (socket.timeout, ConnectionRefusedError, OSError):
             return False
 
     def wrapped_run(self, *args: Any, **kwargs: Any) -> None:
@@ -123,8 +118,16 @@ class ReachyMiniApp(ABC):
         try:
             self.logger.info("Starting Reachy Mini app...")
             self.logger.info(f"Using media backend: {self.media_backend}")
+            self.logger.info(f"Daemon on localhost: {self.daemon_on_localhost}")
+
+            # Force the connection mode based on daemon location detection
+            connection_mode: Literal["localhost_only", "network"] = (
+                "localhost_only" if self.daemon_on_localhost else "network"
+            )
+
             with ReachyMini(
                 media_backend=self.media_backend,
+                connection_mode=connection_mode,
                 *args,
                 **kwargs,  # type: ignore
             ) as reachy_mini:

reachy_mini/apps/manager.py

@@ -12,6 +12,8 @@ import numpy as np
 import psutil
 from pydantic import BaseModel
 
+from reachy_mini.daemon.backend.robot import RobotBackend
+
 from . import AppInfo, SourceKind
 from .sources import hf_space, local_common_venv
 
@@ -139,7 +141,7 @@ class AppManager:
                 async for line in process.stdout:
                     self.logger.getChild("runner").info(line.decode().rstrip())
 
-            # Stream stderr (many libraries write INFO/WARNING to stderr)
+            # Stream stderr - log as warning since it often contains errors/exceptions
             stderr_lines: list[str] = []
 
             async def log_stderr() -> None:
@@ -147,7 +149,15 @@ class AppManager:
                 async for line in process.stderr:
                     decoded = line.decode().rstrip()
                     stderr_lines.append(decoded)
-                    self.logger.getChild("runner").info(decoded)
+                    # Check if line looks like an error or exception
+                    if any(
+                        keyword in decoded
+                        for keyword in ["Error:", "Exception:", "Traceback", "ERROR"]
+                    ):
+                        self.logger.getChild("runner").error(decoded)
+                    else:
+                        # Many libraries write INFO/WARNING to stderr
+                        self.logger.getChild("runner").warning(decoded)
 
             # Run both streams concurrently
             await asyncio.gather(log_stdout(), log_stderr())
@@ -167,7 +177,8 @@ class AppManager:
                         f"Process exited with code {returncode}\n{error_msg}"
                     )
                     self.logger.getChild("runner").error(
-                        f"App {app_name} exited with code {returncode}"
+                        f"App {app_name} exited with code {returncode}. "
+                        f"Last stderr output:\n{error_msg}"
                     )
 
         monitor_task = asyncio.create_task(monitor_process())
@@ -229,6 +240,9 @@ class AppManager:
 
         # Return robot to zero position after app stops
         if self.daemon is not None and self.daemon.backend is not None:
+            if isinstance(self.daemon.backend, RobotBackend):
+                self.daemon.backend.enable_motors()
+
             try:
                 from reachy_mini.reachy_mini import INIT_HEAD_POSE
 

reachy_mini/apps/sources/hf_auth.py

@@ -0,0 +1,92 @@
+"""HuggingFace authentication management for private spaces."""
+
+from typing import Any, Optional
+
+from huggingface_hub import HfApi, get_token, login, logout, whoami
+from huggingface_hub.utils import HfHubHTTPError  # type: ignore
+
+
+def save_hf_token(token: str) -> dict[str, Any]:
+    """Save a HuggingFace access token securely.
+
+    Validates the token against the Hugging Face API and, if valid,
+    stores it using the standard Hugging Face authentication mechanism
+    for reuse across sessions.
+
+    Args:
+        token: The HuggingFace access token to save.
+
+    Returns:
+        A dict containing:
+        - "status": "success" or "error"
+        - "username": the associated Hugging Face username if successful
+        - "message": an error description if unsuccessful
+
+    """
+    try:
+        # Validate token first by making an API call
+        api = HfApi(token=token)
+        user_info = api.whoami()
+
+        # Persist token for future runs (no prompt since token is provided)
+        # add_to_git_credential=False keeps it from touching git credentials.
+        login(token=token, add_to_git_credential=False)
+
+        return {
+            "status": "success",
+            "username": user_info.get("name", ""),
+        }
+    except (HfHubHTTPError, ValueError):
+        # ValueError can be raised by `login()` on invalid token (v1.x behavior)
+        return {
+            "status": "error",
+            "message": "Invalid token or network error",
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e),
+        }
+
+
+def get_hf_token() -> Optional[str]:
+    """Get stored HuggingFace token.
+
+    Returns:
+        The stored token, or None if no token is stored.
+
+    """
+    return get_token()
+
+
+def delete_hf_token() -> bool:
+    """Delete stored HuggingFace token(s).
+
+    Note: logout() without arguments logs out from all saved access tokens.
+    """
+    try:
+        logout()
+        return True
+    except Exception:
+        return False
+
+
+def check_token_status() -> dict[str, Any]:
+    """Check if a token is stored and valid.
+
+    Returns:
+        Status dict with is_logged_in and username.
+
+    """
+    token = get_hf_token()
+    if not token:
+        return {"is_logged_in": False, "username": None}
+
+    try:
+        user_info = whoami(token=token)
+        return {
+            "is_logged_in": True,
+            "username": user_info.get("name", ""),
+        }
+    except Exception:
+        return {"is_logged_in": False, "username": None}

reachy_mini/apps/sources/hf_space.py

@@ -12,7 +12,7 @@ from .. import AppInfo, SourceKind
 AUTHORIZED_APP_LIST_URL = "https://huggingface.co/datasets/pollen-robotics/reachy-mini-official-app-store/raw/main/app-list.json"
 HF_SPACES_API_URL = "https://huggingface.co/api/spaces"
 # TODO look for js apps too (reachy_mini_js_app)
-HF_SPACES_FILTER_URL = "https://huggingface.co/api/spaces?filter=reachy_mini_python_app&sort=likes&direction=-1&limit=50&full=true"
+HF_SPACES_FILTER_URL = "https://huggingface.co/api/spaces?filter=reachy_mini_python_app&sort=likes&direction=-1&limit=500&full=true"
 REQUEST_TIMEOUT = aiohttp.ClientTimeout(total=30)
 
 

reachy_mini/apps/sources/local_common_venv.py

@@ -240,14 +240,20 @@ async def _list_apps_from_separate_venvs(
                 custom_app_url = _get_custom_app_url_from_file(
                     app_name, wireless_version, desktop_app_daemon
                 )
+                # Load saved metadata (e.g., private flag)
+                metadata = _load_app_metadata(app_name)
+                # Merge with current extra data
+                extra_data = {
+                    "custom_app_url": custom_app_url,
+                    "venv_path": str(apps_venv),
+                }
+                extra_data.update(metadata)
+
                 apps.append(
                     AppInfo(
                         name=app_name,
                         source_kind=SourceKind.INSTALLED,
-                        extra={
-                            "custom_app_url": custom_app_url,
-                            "venv_path": str(apps_venv),
-                        },
+                        extra=extra_data,
                     )
                 )
             return apps
@@ -273,14 +279,20 @@ async def _list_apps_from_separate_venvs(
                 app_name, wireless_version, desktop_app_daemon
             )
 
+            # Load saved metadata (e.g., private flag)
+            metadata = _load_app_metadata(app_name)
+            # Merge with current extra data
+            extra_data = {
+                "custom_app_url": custom_app_url,
+                "venv_path": str(venv_path),
+            }
+            extra_data.update(metadata)
+
             apps.append(
                 AppInfo(
                     name=app_name,
                     source_kind=SourceKind.INSTALLED,
-                    extra={
-                        "custom_app_url": custom_app_url,
-                        "venv_path": str(venv_path),
-                    },
+                    extra=extra_data,
                 )
             )
 
@@ -301,11 +313,18 @@ async def _list_apps_from_entry_points() -> list[AppInfo]:
             logging.getLogger("reachy_mini.apps").warning(
                 f"Could not load app '{ep.name}' from entry point: {e}"
             )
+
+        # Load saved metadata (e.g., private flag)
+        metadata = _load_app_metadata(ep.name)
+        # Merge with current extra data
+        extra_data = {"custom_app_url": custom_app_url}
+        extra_data.update(metadata)
+
         apps.append(
             AppInfo(
                 name=ep.name,
                 source_kind=SourceKind.INSTALLED,
-                extra={"custom_app_url": custom_app_url},
+                extra=extra_data,
             )
         )
 
@@ -324,6 +343,44 @@ async def list_available_apps(
         return await _list_apps_from_entry_points()
 
 
+def _get_app_metadata_path(app_name: str) -> Path:
+    """Get the path to the metadata file for an app."""
+    parent_dir = _get_venv_parent_dir()
+    metadata_dir = parent_dir / ".app_metadata"
+    metadata_dir.mkdir(exist_ok=True)
+    return metadata_dir / f"{app_name}.json"
+
+
+def _save_app_metadata(app_name: str, metadata: dict) -> None:  # type: ignore
+    """Save metadata for an app."""
+    import json
+
+    metadata_path = _get_app_metadata_path(app_name)
+    with open(metadata_path, "w") as f:
+        json.dump(metadata, f)
+
+
+def _load_app_metadata(app_name: str) -> dict:  # type: ignore
+    """Load metadata for an app."""
+    import json
+
+    metadata_path = _get_app_metadata_path(app_name)
+    if not metadata_path.exists():
+        return {}
+    try:
+        with open(metadata_path, "r") as f:
+            return json.load(f)  # type: ignore
+    except Exception:
+        return {}
+
+
+def _delete_app_metadata(app_name: str) -> None:
+    """Delete metadata for an app."""
+    metadata_path = _get_app_metadata_path(app_name)
+    if metadata_path.exists():
+        metadata_path.unlink()
+
+
 async def install_package(
     app: AppInfo,
     logger: logging.Logger,
@@ -338,7 +395,7 @@ async def install_package(
             "uv is not installed. Falling back to pip. "
             "Install uv for faster installs: pip install uv"
         )
-    
+
     if app.source_kind == SourceKind.HF_SPACE:
         # Use huggingface_hub to download the repo (handles LFS automatically)
         # This avoids requiring git-lfs to be installed on the system
@@ -350,15 +407,107 @@ async def install_package(
             repo_id = app.name
 
         logger.info(f"Downloading HuggingFace Space: {repo_id}")
+
+        # Check if this is a private space installation
+        is_private = app.extra.get("private", False)
+        token = None
+
+        if is_private:
+            # Get token for private spaces
+            from reachy_mini.apps.sources import hf_auth
+
+            token = hf_auth.get_hf_token()
+            if not token:
+                logger.error("Private space requires authentication but no token found")
+                return 1
+            logger.info("Using stored HF token for private space access")
+
         try:
+            # First, verify the space exists and we have access
+            from huggingface_hub import HfApi
+
+            try:
+                api = HfApi(token=token)
+                space_info = api.space_info(repo_id=repo_id)
+                logger.info(
+                    f"Space found: {space_info.id} (private={space_info.private})"
+                )
+
+                # List all files in the space to see what's available
+                try:
+                    files_in_repo = api.list_repo_files(
+                        repo_id=repo_id, repo_type="space", token=token
+                    )
+                    logger.info(f"Files available in space: {', '.join(files_in_repo)}")
+                except Exception as list_error:
+                    logger.warning(f"Could not list files in space: {list_error}")
+            except Exception as verify_error:
+                logger.error(f"Cannot access space {repo_id}: {verify_error}")
+                if "404" in str(verify_error):
+                    logger.error(
+                        f"Space '{repo_id}' not found. Please check the space ID and your permissions."
+                    )
+                elif "401" in str(verify_error) or "403" in str(verify_error):
+                    logger.error(
+                        f"Access denied to space '{repo_id}'. Please check your HuggingFace token permissions."
+                    )
+                return 1
+
+            # Download the space
+            logger.info("Attempting to download all files from space...")
+            # For private spaces, we need to be careful about missing files like .gitattributes
+            # snapshot_download can fail on 404 for optional git metadata files
             target = await asyncio.to_thread(
                 snapshot_download,
                 repo_id=repo_id,
                 repo_type="space",
+                token=token,
+                ignore_patterns=[
+                    ".gitattributes",
+                    ".gitignore",
+                ],  # Skip git metadata that may 404
+                allow_patterns=None,  # Download all other files
             )
             logger.info(f"Downloaded to: {target}")
+
+            # Check what files were downloaded to help with debugging
+            import os
+
+            downloaded_files = []
+            for root, dirs, files in os.walk(target):
+                for file in files:
+                    rel_path = os.path.relpath(os.path.join(root, file), target)
+                    downloaded_files.append(rel_path)
+            logger.info(f"Downloaded files: {', '.join(downloaded_files)}")
+
+            # Check if this looks like a Python package
+            has_pyproject = os.path.exists(os.path.join(target, "pyproject.toml"))
+            has_setup = os.path.exists(os.path.join(target, "setup.py"))
+
+            if not has_pyproject and not has_setup:
+                logger.warning(
+                    f"Space does not appear to have pyproject.toml or setup.py in the root directory. "
+                    f"For a Reachy Mini app, you need a proper Python package structure. "
+                    f"Downloaded files: {', '.join(downloaded_files)}"
+                )
+                logger.info(
+                    "If your package files are in a subdirectory, make sure they're in the root of the space. "
+                    "Check that pyproject.toml or setup.py is committed to your HuggingFace Space."
+                )
         except Exception as e:
-            logger.error(f"Failed to download from HuggingFace: {e}")
+            error_msg = str(e)
+            if "401" in error_msg or "403" in error_msg:
+                logger.error(
+                    f"Authentication failed: {e}\n"
+                    "Please check that your HuggingFace token has access to this space."
+                )
+            elif "404" in error_msg:
+                logger.error(
+                    f"Space not found: {e}\n"
+                    f"Please verify that '{repo_id}' exists and you have access."
+                )
+            else:
+                logger.error(f"Failed to download from HuggingFace: {e}")
             return 1
     elif app.source_kind == SourceKind.LOCAL:
         target = app.extra.get("path", app.name)
@@ -397,7 +546,7 @@ async def install_package(
                     python_path = _get_app_python(
                         app_name, wireless_version, desktop_app_daemon
                     )
-                    
+
                     if use_uv:
                         install_cmd = [
                             "uv",
@@ -415,7 +564,7 @@ async def install_package(
                             "install",
                             "reachy-mini[gstreamer]",
                         ]
-                    
+
                     ret = await running_command(install_cmd, logger=logger)
                     if ret != 0:
                         logger.warning(
@@ -428,12 +577,19 @@ async def install_package(
             python_path = _get_app_python(
                 app_name, wireless_version, desktop_app_daemon
             )
-            
+
             if use_uv:
-                install_cmd = ["uv", "pip", "install", "--python", str(python_path), target]
+                install_cmd = [
+                    "uv",
+                    "pip",
+                    "install",
+                    "--python",
+                    str(python_path),
+                    target,
+                ]
             else:
                 install_cmd = [str(python_path), "-m", "pip", "install", target]
-            
+
             ret = await running_command(install_cmd, logger=logger)
 
             if ret != 0:
@@ -441,6 +597,12 @@ async def install_package(
 
             logger.info(f"Successfully installed '{app_name}' in {venv_path}")
             success = True
+
+            # Save app metadata (e.g., private flag)
+            if app.extra:
+                _save_app_metadata(app_name, app.extra)
+                logger.info(f"Saved metadata for '{app_name}': {app.extra}")
+
             return 0
         finally:
             # Clean up broken venv on any failure (but not shared wireless venv)
@@ -457,7 +619,7 @@ async def install_package(
             install_cmd = ["uv", "pip", "install", "--python", sys.executable, target]
         else:
             install_cmd = [sys.executable, "-m", "pip", "install", target]
-        
+
         return await running_command(install_cmd, logger=logger)
 
 
@@ -513,10 +675,10 @@ async def uninstall_package(
             python_path = _get_app_python(
                 app_name, wireless_version, desktop_app_daemon
             )
-            
+
             # Check if uv is available
             use_uv = _check_uv_available()
-            
+
             if use_uv:
                 uninstall_cmd = [
                     "uv",
@@ -535,16 +697,20 @@ async def uninstall_package(
                     "-y",
                     app_name,
                 ]
-            
+
             ret = await running_command(uninstall_cmd, logger=logger)
             if ret == 0:
                 logger.info(f"Successfully uninstalled '{app_name}'")
+                # Delete app metadata
+                _delete_app_metadata(app_name)
             return ret
         else:
             # Desktop: remove the entire per-app venv directory
             logger.info(f"Removing venv for '{app_name}' at {venv_path}")
             shutil.rmtree(venv_path)
             logger.info(f"Successfully uninstalled '{app_name}'")
+            # Delete app metadata
+            _delete_app_metadata(app_name)
             return 0
     else:
         existing_apps = await list_available_apps()
@@ -553,15 +719,24 @@ async def uninstall_package(
 
         # Check if uv is available
         use_uv = _check_uv_available()
-        
+
         logger.info(f"Removing package {app_name}")
-        
+
         if use_uv:
-            uninstall_cmd = ["uv", "pip", "uninstall", "--python", sys.executable, app_name]
+            uninstall_cmd = [
+                "uv",
+                "pip",
+                "uninstall",
+                "--python",
+                sys.executable,
+                app_name,
+            ]
         else:
             uninstall_cmd = [sys.executable, "-m", "pip", "uninstall", "-y", app_name]
-        
+
         ret = await running_command(uninstall_cmd, logger=logger)
         if ret == 0:
             logger.info(f"Successfully uninstalled '{app_name}'")
+            # Delete app metadata
+            _delete_app_metadata(app_name)
         return ret

reachy_mini/apps/templates/main.py.j2

@@ -10,7 +10,8 @@ class {{ class_name }}(ReachyMiniApp):
     # Optional: URL to a custom configuration page for the app
     # eg. "http://localhost:8042"
     custom_app_url: str | None = "http://0.0.0.0:8042"
-    # Optional: specify a media backend ("gstreamer", "default", etc.)
+    # Optional: specify a media backend ("gstreamer", "gstreamer_no_video", "default", etc.)
+    # On the wireless, use gstreamer_no_video to optimise CPU usage if the app does not use video streaming
     request_media_backend: str | None = None
 
     def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
@@ -34,7 +35,7 @@ class {{ class_name }}(ReachyMiniApp):
         def request_sound_play():
             nonlocal sound_play_requested
             sound_play_requested = True
-            
+
         # === ^^^ ===
 
         # Main control loop
@@ -71,4 +72,4 @@ if __name__ == "__main__":
     try:
         app.wrapped_run()
     except KeyboardInterrupt:
-        app.stop()
+        app.stop()

reachy_mini/daemon/app/dashboard/static/js/apps.js

@@ -114,7 +114,15 @@ const installedApps = {
         const title = document.createElement('div');
         const titleSpan = document.createElement('span');
         titleSpan.className = 'installed-app-title top-1/2 ';
-        titleSpan.innerHTML = app.name;
+
+        // Add [private] tag if this is a private space
+        const isPrivate = app.extra && app.extra.private === true;
+        if (isPrivate) {
+            titleSpan.innerHTML = app.name + ' <span style="color: #dc2626; font-size: 0.75rem; font-weight: 600; margin-left: 0.25rem;">[private]</span>';
+        } else {
+            titleSpan.innerHTML = app.name;
+        }
+
         title.appendChild(titleSpan);
         if (app.extra && app.extra.custom_app_url) {
             const settingsLink = document.createElement('a');