infinicode 2.8.13 → 2.8.15

package/dist/kernel/federation/dashboard-html.js

@@ -825,6 +825,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
     var nodes=[], byId={}, orbs=[], pulses=[], t0=0, raf=null, running=false, es=null, animSeq=-1;
     var drawerId=null, camRAF=null, meterRAF=null, camAbort=null, drawerTimer=null;
     var previewOn=false, previewTimer=null;   // on-demand operator camera preview
+    var visionOn=false;   // RoboVisionAI_PI overlay feed (direct MJPEG, not LiveKit)
     var lkRoom=null, micAnalyser=null, audioCtx=null;
     var imgs={}; // preloaded robot concept avatars
     var TW=44, TH=22, PARK_W=15, PARK_D=8;
@@ -1189,6 +1190,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
       // tell the scheduler to end any live preview so the robot stops its cam
       if(previewOn && drawerId){ var pn=byId[drawerId]; if(pn){ try{ fetch('/robopark/api/robots/'+encodeURIComponent(schedId(pn))+'/preview/stop'+QS,{method:'POST',keepalive:true}); }catch(e){} } }
       previewOn=false; if(previewTimer){ clearInterval(previewTimer); previewTimer=null; }
+      stopVision();
       $('pk-drawer').classList.remove('open'); drawerId=null;
       if(camRAF)cancelAnimationFrame(camRAF); camRAF=null;
       if(meterRAF)cancelAnimationFrame(meterRAF); meterRAF=null;
@@ -1225,10 +1227,34 @@ button.act:disabled{opacity:0.5;cursor:default;}
       var note=$('pk-golivenote'); if(note) note.textContent='';
       idleCam('idle');
     }
+    // RoboVisionAI_PI serves its own MJPEG stream directly (not via LiveKit),
+    // so the browser hits the robot's LAN IP straight on, no scheduler proxy.
+    // The scheduler learns that IP from the device's own heartbeats.
+    function toggleVision(n){
+      var img=$('pk-vision-img'), note=$('pk-vision-note'), btn=$('pk-vision-toggle');
+      if(visionOn){
+        visionOn=false; if(img){ img.src=''; img.style.display='none'; }
+        if(btn) btn.textContent='🔍 Show overlay';
+        if(note) note.textContent="object/motion detection overlay from the robot's vision server (RoboVisionAI_PI)";
+        return;
+      }
+      var row=schedRow(n);
+      var ip=row&&row.lan_ip;
+      if(!ip){ if(note) note.textContent='no known IP for this robot yet — waiting for a heartbeat with lan_ip'; return; }
+      var port=(row&&row.vision_port)||5000;
+      visionOn=true;
+      if(btn) btn.textContent='■ Hide overlay';
+      if(note) note.textContent='streaming from http://'+ip+':'+port+'/video_feed';
+      if(img){ img.src='http://'+ip+':'+port+'/video_feed'; img.style.display='block'; }
+    }
+    function stopVision(){
+      visionOn=false;
+      var img=$('pk-vision-img'); if(img){ img.src=''; img.style.display='none'; }
+    }
     function pollRoboparkQuiet(){
       fetch('/robopark/api/telemetry'+QS,{cache:'no-store'}).then(function(r){return r.json();}).then(function(d){
         var list=(Array.isArray(d)?d:(d&&d.robots)||[]); roboparkByName={};
-        list.forEach(function(x){ roboparkByName[x.robot_id||x.id||x.name||'robot']=x; });
+        list.forEach(function(x){ roboparkByName[x.robot_id||x.id||x.name||'robot']=x; if(x.name) roboparkByName[x.name]=x; });
         refreshDrawer();
       }).catch(function(){});
     }
@@ -1247,6 +1273,10 @@ button.act:disabled{opacity:0.5;cursor:default;}
             +'<div class="hud"><div class="rec"><i></i>REC · '+esc(n.name)+'</div><div class="tr" id="pk-camres">— · —</div><div class="br" id="pk-camts">--:--:--</div></div></div>'
             +'<div class="pk-note" id="pk-camnote">seeking LiveKit track…</div>'
             +'<div class="pk-ctl" style="margin-top:0.5rem"><button class="rp-btn" id="pk-golive" data-robot="'+esc(n.name)+'">▶ Go live</button><span class="pk-note" id="pk-golivenote" style="margin:0"></span></div>')
+        + sect('🔍 vision overlay',
+            '<div class="pk-cam" id="pk-vision-wrap"><img id="pk-vision-img" style="width:100%;display:none;border-radius:inherit" alt="vision feed"/></div>'
+            +'<div class="pk-note" id="pk-vision-note">object/motion detection overlay from the robot\'s vision server (RoboVisionAI_PI)</div>'
+            +'<div class="pk-ctl" style="margin-top:0.5rem"><button class="rp-btn" id="pk-vision-toggle">🔍 Show overlay</button></div>')
         + sect('🎙 microphone','<div class="pk-meter"><span class="lab">input</span><div class="pk-bars" id="pk-micbars"></div><span class="pk-val" id="pk-micval">—</span></div><div class="pk-note" id="pk-micstate">awaiting robot audio plugin</div>')
         + sect('🔊 speaker','<canvas class="pk-wave" id="pk-spkwave" width="360" height="32"></canvas><div class="pk-meter"><span class="lab">output</span><div class="pk-bars" id="pk-spkbars"></div><span class="pk-val" id="pk-spkval">—</span></div><div class="pk-note" id="pk-spkstate">awaiting robot audio plugin</div>')
         + sect('📊 hardware','<div class="pk-hwgrid"><div><div class="l">load</div><div class="track"><div class="fill" id="pk-hw-load"></div></div></div><div><div class="l">status</div><div class="track"><div class="fill" id="pk-hw-conn" style="background:'+(n.connected?'var(--ok)':'var(--muted)')+'"></div></div></div></div><div class="pk-note">remote node — full CPU/mem telemetry shows on the node itself</div>')
@@ -1254,6 +1284,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
         + sect('⚙ controls','<div class="pk-ctl"><button class="rp-btn danger" id="pk-end" data-robot="'+esc(n.name)+'">End session</button><button class="rp-btn" id="pk-follow">Follow run</button></div><div class="pk-note">end-session is live via the scheduler; cam/mic/speaker fill in as the robot plugin publishes them</div>');
         startCam(n); startMeters(n);
         var gl=$('pk-golive'); if(gl) gl.addEventListener('click', function(){ if(rpReadOnly){ showOut('read-only node'); return; } goLive(n); });
+        var vt=$('pk-vision-toggle'); if(vt) vt.addEventListener('click', function(){ toggleVision(n); });
         var eb=$('pk-end'); if(eb) eb.addEventListener('click', function(){ if(rpReadOnly){ showOut('read-only node'); return; } endSession(schedId(n)); });
         var fb=$('pk-follow'); if(fb) fb.addEventListener('click', function(){ selectTab('fleet'); $('cmdInput').value='/follow'; selectNode(n.id,n.name); showOut('type a runId after /follow, or run /status on '+n.name); });
       } else {

package/dist/robopark/preview-agent-launcher.d.ts

@@ -8,6 +8,9 @@ export interface PreviewAgentOptions {
     width: string;
     height: string;
     fps: string;
+    visionWebhookPort?: string;
+    visionTriggerCooldown?: string;
+    visionSessionSeconds?: string;
     saveConfig?: boolean;
     foreground?: boolean;
 }

package/dist/robopark/preview-agent-launcher.js

@@ -41,6 +41,12 @@ export async function roboparkPreviewAgent(opts) {
         args.push('--device-token', opts.deviceToken);
     if (opts.enrollmentToken)
         args.push('--enrollment-token', opts.enrollmentToken);
+    if (opts.visionWebhookPort)
+        args.push('--vision-webhook-port', opts.visionWebhookPort);
+    if (opts.visionTriggerCooldown)
+        args.push('--vision-trigger-cooldown', opts.visionTriggerCooldown);
+    if (opts.visionSessionSeconds)
+        args.push('--vision-session-seconds', opts.visionSessionSeconds);
     if (opts.saveConfig)
         args.push('--save-config');
     console.log(chalk.bold('\n  robopark preview-agent'));
@@ -49,6 +55,8 @@ export async function roboparkPreviewAgent(opts) {
     console.log(`  scheduler: ${chalk.cyan(schedulerUrl)}`);
     console.log(`  video:     ${chalk.cyan(opts.videoDevice)}`);
     console.log(`  audio:     ${chalk.cyan(opts.audioDevice)}`);
+    if (opts.visionWebhookPort)
+        console.log(`  vision webhook: ${chalk.cyan(':' + opts.visionWebhookPort)} (point RoboVisionAI_PI's motion webhook here)`);
     console.log();
     if (opts.foreground) {
         const proc = spawn(python, args, { stdio: 'inherit' });

package/dist/robopark-cli.js

@@ -99,6 +99,9 @@ program
     .option('--width <px>', 'video width', '640')
     .option('--height <px>', 'video height', '480')
     .option('--fps <n>', 'video fps', '15')
+    .option('--vision-webhook-port <port>', 'local port for RoboVisionAI_PI\'s motion webhook (0 disables)', '5057')
+    .option('--vision-trigger-cooldown <sec>', 'min seconds between motion-triggered sessions', '20')
+    .option('--vision-session-seconds <sec>', 'how long a motion-triggered session holds the publisher', '90')
     .option('--save-config', 'write settings to ~/.robopark/preview_agent.json')
     .option('--foreground', 'stay in foreground; do not detach')
     .action(async (opts) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.13",
+  "version": "2.8.15",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",
@@ -27,6 +27,8 @@
     "bin/robopark.js",
     "dist",
     "packages/robopark/scheduler",
+    "packages/robopark/pi-client",
+    "packages/robopark/vision",
     ".opencode/plugins",
     ".opencode/themes",
     ".opencode/tui.json",

package/packages/robopark/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/packages/robopark/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/packages/robopark/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/packages/robopark/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/packages/robopark/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