robopark 2.8.13 → 2.8.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robopark",
-  "version": "2.8.13",
+  "version": "2.8.15",
   "description": "RoboPark fleet control CLI — set up, watch, and drive a fleet of talking robots. The operator front-end over the infinicode mesh.",
   "type": "module",
   "bin": {
@@ -9,6 +9,8 @@
   "files": [
     "bin/robopark.js",
     "scheduler",
+    "pi-client",
+    "vision",
     "README.md"
   ],
   "engines": {

package/pi-client/README.md

@@ -0,0 +1,17 @@
+# robopark-pi-client — full robot client (reference)
+
+The full on-robot client: enrollment, heartbeat, motor control, and a
+LiveKit publish loop (`livekit_bridge.py`) that joins a standing per-device
+room whenever `production_mode` is on. `pi_ui.py` serves a touchscreen UI
+with a manual "Join Conversation" button — the human-in-the-loop trigger.
+
+This is a reference implementation shipped for Pi deployment; it is not
+currently wired into `robopark setup --robot` (which uses `../scheduler/
+preview_agent.py` for the on-demand preview + vision-trigger flow — see
+`../vision/README.md`). `client.py`'s standing-room model and the scheduler's
+`request-session`-per-trigger model are two different session strategies;
+reconciling them into one is follow-up work, not done here.
+
+Install: `pip install -r requirements.txt` (`livekit`/`livekit-api` are
+commented out — Pi-only, install separately with the `livekit` SDK).
+`install.sh`/`*.service` are Linux/Pi systemd wrappers.

package/pi-client/_install_steps.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+set -e
+echo "=== reset perms (cleanup from previous attempt) ==="
+sudo rm -rf /opt/robopark-pi-client/.venv 2>/dev/null || true
+sudo chown -R robopark:robopark /opt/robopark-pi-client
+
+echo "=== apt deps (no signing strict) ==="
+sudo apt-get -o Acquire::AllowInsecureRepositories=true update 2>&1 | tail -3
+sudo apt-get install -y --no-install-recommends python3-venv python3-pip libatlas3-base libasound2t64 portaudio19-dev libjpeg-dev libpng-dev ffmpeg 2>&1 | tail -3
+echo "apt-done"
+
+echo "=== create venv as robopark ==="
+sudo -u robopark python3 -m venv /opt/robopark-pi-client/.venv
+sudo -u robopark /opt/robopark-pi-client/.venv/bin/pip install --quiet --upgrade pip
+sudo -u robopark /opt/robopark-pi-client/.venv/bin/pip install --quiet httpx
+echo "httpx-done"
+
+echo "=== media stack (optional, may take a while) ==="
+sudo -u robopark /opt/robopark-pi-client/.venv/bin/pip install --quiet livekit livekit-api numpy 2>&1 | tail -3
+echo "lk-done"
+sudo -u robopark /opt/robopark-pi-client/.venv/bin/pip install --quiet opencv-python-headless 2>&1 | tail -3
+echo "cv-done"
+sudo -u robopark /opt/robopark-pi-client/.venv/bin/pip install --quiet sounddevice 2>&1 | tail -3
+echo "sd-done"
+
+echo "=== final state ==="
+ls -la /opt/robopark-pi-client
+ls /opt/robopark-pi-client/.venv/bin | head -5
+echo "all-done"

package/pi-client/client.py

@@ -0,0 +1,305 @@
+# RoboPark Pi Client
+# Run on the Raspberry Pi (or any device) to:
+#   1. Enroll with the scheduler (first boot) using --enrollment-token
+#   2. Persist device_id + device_token to --state-file (default ./device.json)
+#   3. Heartbeat every --heartbeat-interval seconds
+#   4. Join a LiveKit room (if `livekit` SDK is installed) to publish mic + camera
+#      and subscribe to the agent's data channel for motor commands
+#   5. Forward motor commands to the local RoboVisionAI_PI motor server
+#
+# Quick start:
+#   python client.py \
+#     --scheduler-url http://100.64.1.5:8080 \
+#     --enrollment-token <TOKEN-FROM-SCHEDULER-LOGS> \
+#     --name pipi \
+#     --tailscale-ip 100.64.1.10 \
+#     --lan-ip 192.168.1.159 \
+#     --motor-server-url http://192.168.1.159:8001 \
+#     --livekit-url ws://100.64.1.5:7880
+#
+# Subsequent runs (token is in device.json):
+#   python client.py --scheduler-url http://100.64.1.5:8080
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import signal
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+from motor_bridge import MotorBridge
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+log = logging.getLogger("robopark-pi")
+
+
+class PiClient:
+    def __init__(self, args: argparse.Namespace):
+        self.scheduler_url = args.scheduler_url.rstrip("/")
+        self.state_file = Path(args.state_file)
+        self.enrollment_token = args.enrollment_token
+        self.name = args.name
+        self.tailscale_ip = args.tailscale_ip
+        self.lan_ip = args.lan_ip
+        self.motor_server_url = args.motor_server_url
+        self.livekit_url = args.livekit_url
+        self.character_id = args.character_id
+        self.heartbeat_interval = args.heartbeat_interval
+        self.config_poll_interval = args.config_poll_interval
+        self.join_room = args.join_room
+        self.room_name = args.room_name
+
+        self.device_id: Optional[str] = None
+        self.device_token: Optional[str] = None
+        self.production_mode: bool = False
+        self.motor_bridge = MotorBridge(self.motor_server_url, dry_run=args.dry_run_motors)
+
+        self._stop = asyncio.Event()
+        self._lk_task: Optional[asyncio.Task] = None
+
+    # ---- credential persistence ----------------------------------------
+
+    def _load_state(self) -> bool:
+        if not self.state_file.exists():
+            return False
+        try:
+            data = json.loads(self.state_file.read_text())
+            self.device_id = data.get("device_id")
+            self.device_token = data.get("device_token")
+            # allow CLI overrides to backfill missing fields from a stale state file
+            if not self.tailscale_ip: self.tailscale_ip = data.get("tailscale_ip")
+            if not self.lan_ip: self.lan_ip = data.get("lan_ip")
+            if not self.motor_server_url: self.motor_server_url = data.get("motor_server_url")
+            if not self.livekit_url: self.livekit_url = data.get("livekit_url")
+            if not self.character_id: self.character_id = data.get("character_id")
+            if not self.name: self.name = data.get("name")
+            return bool(self.device_id and self.device_token)
+        except Exception as e:
+            log.warning(f"Could not load state file {self.state_file}: {e}")
+            return False
+
+    def _save_state(self):
+        data = {
+            "device_id": self.device_id,
+            "device_token": self.device_token,
+            "name": self.name,
+            "tailscale_ip": self.tailscale_ip,
+            "lan_ip": self.lan_ip,
+            "motor_server_url": self.motor_server_url,
+            "livekit_url": self.livekit_url,
+            "character_id": self.character_id,
+            "saved_at": time.time(),
+        }
+        self.state_file.parent.mkdir(parents=True, exist_ok=True)
+        self.state_file.write_text(json.dumps(data, indent=2))
+        try:
+            os.chmod(self.state_file, 0o600)
+        except Exception:
+            pass
+        log.info(f"Saved credentials to {self.state_file}")
+
+    # ---- scheduler API --------------------------------------------------
+
+    async def enroll(self):
+        body = {
+            "enrollment_token": self.enrollment_token,
+            "name": self.name,
+            "tailscale_ip": self.tailscale_ip,
+            "lan_ip": self.lan_ip,
+            "motor_server_url": self.motor_server_url,
+            "livekit_url": self.livekit_url,
+            "character_id": self.character_id,
+        }
+        async with httpx.AsyncClient(timeout=15.0) as c:
+            r = await c.post(f"{self.scheduler_url}/api/devices/enroll", json=body)
+            if r.status_code != 200:
+                raise RuntimeError(f"Enroll failed ({r.status_code}): {r.text}")
+            data = r.json()
+        self.device_id = data["device_id"]
+        self.device_token = data["device_token"]
+        log.info(f"Enrolled as device_id={self.device_id}")
+        self._save_state()
+
+    async def heartbeat(self):
+        body = {"status": "online", "ip": self.tailscale_ip or self.lan_ip}
+        async with httpx.AsyncClient(timeout=10.0) as c:
+            r = await c.post(
+                f"{self.scheduler_url}/api/devices/{self.device_id}/heartbeat",
+                headers={"Authorization": f"Bearer {self.device_token}"},
+                json=body,
+            )
+            if r.status_code == 401:
+                log.error("Device token rejected; re-enrollment required")
+                # wipe creds so next loop tries to enroll again
+                self.device_token = None
+                if self.state_file.exists():
+                    self.state_file.unlink()
+                return None
+            r.raise_for_status()
+            return r.json()
+
+    async def fetch_config(self) -> dict:
+        async with httpx.AsyncClient(timeout=10.0) as c:
+            r = await c.get(
+                f"{self.scheduler_url}/api/devices/{self.device_id}/config",
+                headers={"Authorization": f"Bearer {self.device_token}"},
+            )
+            r.raise_for_status()
+            return r.json()
+
+    # ---- LiveKit (optional) ---------------------------------------------
+
+    async def livekit_loop(self):
+        """Join a LiveKit room, publish mic + cam, subscribe to data channel.
+        Skips silently if the `livekit` SDK is not installed."""
+        try:
+            from livekit_bridge import run_livekit  # local module
+        except ImportError:
+            log.warning(
+                "livekit_bridge module not available (livekit SDK missing). "
+                "Heartbeat + motor bridge will still work; install the `livekit` "
+                "and `livekit-api` packages on the Pi to enable rooms."
+            )
+            return
+
+        # Default room: robopark-<device_id>. Allow override via --room-name.
+        room = (self.room_name if self.room_name and not self.room_name.startswith("robopark-pi-standby")
+                else f"robopark-{self.device_id}")
+        # LiveKit URL: prefer the one the scheduler told us about, fall back to CLI.
+        lk_url = self.livekit_url or None
+
+        await run_livekit(
+            livekit_url=lk_url,
+            room_name=room,
+            identity=f"pi:{self.device_id}",
+            on_motor_command=self.motor_bridge.handle_command,
+            stop_event=self._stop,
+            production_mode_provider=lambda: self.production_mode,
+            scheduler_url=self.scheduler_url,
+            device_id=self.device_id,
+            device_token=self.device_token,
+        )
+
+    # ---- main loop ------------------------------------------------------
+
+    async def run(self):
+        # 1. credentials
+        if not self._load_state():
+            if not self.enrollment_token:
+                log.error(
+                    "No saved credentials and no --enrollment-token. "
+                    "First boot requires --enrollment-token from the scheduler."
+                )
+                return
+            await self.enroll()
+
+        log.info(f"Device {self.device_id} starting main loop")
+        # 2. start LiveKit worker in background (no-op if SDK missing)
+        if self.join_room:
+            self._lk_task = asyncio.create_task(self.livekit_loop())
+        hb_failures = 0
+        try:
+            while not self._stop.is_set():
+                try:
+                    hb = await self.heartbeat()
+                    hb_failures = 0
+                    if hb:
+                        self.production_mode = bool(hb.get("production_mode", False))
+                        if self.production_mode and self._lk_task is None and self.join_room:
+                            log.info("Production mode ON -> joining LiveKit room")
+                            self._lk_task = asyncio.create_task(self.livekit_loop())
+                        elif not self.production_mode and self._lk_task is not None:
+                            log.info("Production mode OFF -> leaving LiveKit room")
+                            self._lk_task.cancel()
+                            try:
+                                await self._lk_task
+                            except (asyncio.CancelledError, Exception):
+                                pass
+                            self._lk_task = None
+                except Exception as e:
+                    hb_failures += 1
+                    log.warning(f"Heartbeat error ({hb_failures}): {e}")
+
+                # periodic config poll (covers cases where production_mode flips but hb is slow)
+                try:
+                    if int(time.time()) % int(self.config_poll_interval) < int(self.heartbeat_interval):
+                        cfg = await self.fetch_config()
+                        self.production_mode = bool(cfg.get("production_mode", False))
+                        if cfg.get("character_id"):
+                            self.character_id = cfg["character_id"]
+                except Exception as e:
+                    log.debug(f"Config poll error: {e}")
+
+                try:
+                    await asyncio.wait_for(self._stop.wait(), timeout=self.heartbeat_interval)
+                except asyncio.TimeoutError:
+                    pass
+        finally:
+            self._stop.set()
+            if self._lk_task:
+                self._lk_task.cancel()
+                try:
+                    await self._lk_task
+                except Exception:
+                    pass
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="RoboPark Pi Client")
+    p.add_argument("--scheduler-url", required=True, help="e.g. http://100.64.1.5:8080")
+    p.add_argument("--enrollment-token", default=None,
+                   help="One-time enrollment token (first boot only)")
+    p.add_argument("--state-file", default="./device.json",
+                   help="Where to persist device_id + device_token")
+    p.add_argument("--name", default=None, help="Device display name")
+    p.add_argument("--tailscale-ip", default=None)
+    p.add_argument("--lan-ip", default=None)
+    p.add_argument("--motor-server-url", default=None,
+                   help="Base URL of the local RoboVisionAI_PI motor server")
+    p.add_argument("--livekit-url", default=None, help="e.g. ws://100.64.1.5:7880")
+    p.add_argument("--character-id", default=None, help="Override character assignment")
+    p.add_argument("--room-name", default="robopark-pi-standby",
+                   help="LiveKit room to join")
+    p.add_argument("--heartbeat-interval", type=float, default=10.0)
+    p.add_argument("--config-poll-interval", type=float, default=30.0)
+    p.add_argument("--join-room", action="store_true",
+                   help="Attempt to join the LiveKit room (requires livekit SDK)")
+    p.add_argument("--dry-run-motors", action="store_true",
+                   help="Log motor commands without calling the motor server")
+    return p.parse_args()
+
+
+async def _amain():
+    args = parse_args()
+    client = PiClient(args)
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, client._stop.set)
+        except NotImplementedError:
+            pass  # Windows
+
+    try:
+        await client.run()
+    except KeyboardInterrupt:
+        pass
+
+
+def main():
+    try:
+        asyncio.run(_amain())
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

package/pi-client/install.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Install RoboPark Pi Client on a Raspberry Pi
+# Usage:
+#   sudo ./install.sh --scheduler-url http://100.64.1.5:8080 \
+#                     --enrollment-token <TOKEN>
+set -euo pipefail
+
+SCHEDULER_URL=""
+ENROLLMENT_TOKEN=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --scheduler-url) SCHEDULER_URL="$2"; shift 2 ;;
+    --enrollment-token) ENROLLMENT_TOKEN="$2"; shift 2 ;;
+    *) echo "Unknown arg: $1"; exit 1 ;;
+  esac
+done
+
+if [[ -z "$SCHEDULER_URL" || -z "$ENROLLMENT_TOKEN" ]]; then
+  echo "Usage: $0 --scheduler-url URL --enrollment-token TOKEN"
+  exit 1
+fi
+
+id "robopark" 2>/dev/null || useradd -r -s /bin/false robopark
+install -d -m 755 -o robopark -g robopark /opt/robopark-pi-client
+install -d -m 700 -o robopark -g robopark /etc/robopark
+cp -r ./* /opt/robopark-pi-client/
+chown -R robopark:robopark /opt/robopark-pi-client
+
+sudo -u robopark python3 -m venv /opt/robopark-pi-client/.venv
+/opt/robopark-pi-client/.venv/bin/pip install --upgrade pip
+/opt/robopark-pi-client/.venv/bin/pip install -r /opt/robopark-pi-client/requirements.txt
+# On Pi you typically want the full media stack:
+/opt/robopark-pi-client/.venv/bin/pip install livekit livekit-api sounddevice numpy opencv-python av
+
+cp /opt/robopark-pi-client/robopark-pi-client.service /etc/systemd/system/
+systemctl daemon-reload
+systemctl enable --now robopark-pi-client.service
+
+echo "First-boot enrollment will run as part of the service start."
+echo "Tail logs with: journalctl -u robopark-pi-client -f"

package/pi-client/join_convo.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Join a LiveKit conversation from the Pi.
+#
+# Calls the local Pi UI's /api/join endpoint, which itself asks the scheduler
+# for a short-lived LiveKit access token. The script prints the meet URL
+# AND (if --open) opens it in the default browser on the Pi.
+#
+# Usage:
+#   ./join_convo.sh
+#   ./join_convo.sh --room robopark-pi-test --identity alice --open
+#   PI_UI=http://192.168.1.159:8081 ./join_convo.sh --open
+
+set -euo pipefail
+
+PI_UI="${PI_UI:-http://127.0.0.1:8081}"
+ROOM="${ROOM:-robopark-pi-test}"
+IDENTITY="${IDENTITY:-}"
+OPEN=0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --room) ROOM="$2"; shift 2 ;;
+    --identity) IDENTITY="$2"; shift 2 ;;
+    --open) OPEN=1; shift ;;
+    --pi-ui) PI_UI="$2"; shift 2 ;;
+    -h|--help)
+      sed -n '2,12p' "$0"; exit 0 ;;
+    *) echo "unknown arg: $1" >&2; exit 1 ;;
+  esac
+done
+
+BODY=$(jq -nc --arg room "$ROOM" --arg identity "$IDENTITY" \
+  '{room:$room, identity:$identity}')
+
+echo "Requesting token from $PI_UI (room=$ROOM identity=$IDENTITY)..."
+RESP=$(curl -fsS -X POST "$PI_UI/api/join" \
+  -H 'Content-Type: application/json' -d "$BODY")
+
+URL=$(echo "$RESP" | jq -r '
+  "https://meet.livekit.io/custom?livekitUrl=" + (.url | @uri) +
+  "&token=" + (.token | @uri)
+')
+
+EXPIRES=$(echo "$RESP" | jq -r '.expires_at')
+echo "Token expires: $EXPIRES"
+echo "Meet URL:"
+echo "  $URL"
+
+if [[ $OPEN -eq 1 ]]; then
+  if command -v xdg-open >/dev/null 2>&1; then xdg-open "$URL" >/dev/null 2>&1 || true
+  elif command -v sensible-browser >/dev/null 2>&1; then sensible-browser "$URL" >/dev/null 2>&1 || true
+  elif command -v open >/dev/null 2>&1; then open "$URL" >/dev/null 2>&1 || true
+  else echo "no browser opener found; copy the URL above" >&2; exit 2; fi
+  echo "(opened in browser)"
+fi