infinicode 2.8.36 → 2.8.38

package/packages/robopark/scheduler/scripts/install-robot-supervisor-linux.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# Installs the RoboPark robot supervisor as a systemd service on a real
+# robot (Raspberry Pi or similar). Auto-starts on boot, restarts on crash.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SUPERVISOR_DIR="$(dirname "$SCRIPT_DIR")"
+UNIT_SRC="$SCRIPT_DIR/robopark-supervisor.service"
+UNIT_DST="/etc/systemd/system/robopark-supervisor.service"
+
+if [ ! -f "$SUPERVISOR_DIR/robot_supervisor.py" ]; then
+    echo "robot_supervisor.py not found in $SUPERVISOR_DIR" >&2
+    exit 1
+fi
+
+if [ ! -f "$HOME/.robopark/supervisor.json" ]; then
+    echo "No ~/.robopark/supervisor.json yet — copy supervisor.example.json there and edit it first:" >&2
+    echo "  cp $SUPERVISOR_DIR/supervisor.example.json ~/.robopark/supervisor.json" >&2
+    exit 1
+fi
+
+echo "Installing systemd unit -> $UNIT_DST (requires sudo)"
+sudo sed \
+    -e "s#WorkingDirectory=.*#WorkingDirectory=$SUPERVISOR_DIR#" \
+    -e "s#User=.*#User=$(whoami)#" \
+    "$UNIT_SRC" | sudo tee "$UNIT_DST" > /dev/null
+
+sudo systemctl daemon-reload
+sudo systemctl enable robopark-supervisor.service
+sudo systemctl restart robopark-supervisor.service
+
+echo "Installed and started. Check status: sudo systemctl status robopark-supervisor.service"
+echo "Logs: journalctl -u robopark-supervisor.service -f  (or ~/.robopark/logs/*.log per-service)"

package/packages/robopark/scheduler/scripts/install-robot-supervisor-windows.ps1

@@ -0,0 +1,49 @@
+<#
+.SYNOPSIS
+  Registers the RoboPark robot supervisor to auto-start at Windows logon.
+
+.DESCRIPTION
+  Creates a Scheduled Task that runs robot_supervisor.py whenever this user
+  logs in, restarting it automatically if it ever exits unexpectedly. Runs
+  in the interactive session (not "run whether logged on or not") because
+  Windows restricts microphone/camera access to interactive sessions —
+  preview_agent.py needs both.
+
+  The supervisor itself (robot_supervisor.py) is what keeps the individual
+  robot services (preview_agent, vision app, motor server) alive; this task
+  is the one layer above that keeps the supervisor itself running.
+
+.PARAMETER PythonExe
+  Path to python.exe. Defaults to whatever `python` resolves to on PATH.
+
+.EXAMPLE
+  .\install-robot-supervisor-windows.ps1
+  .\install-robot-supervisor-windows.ps1 -PythonExe "C:\Python312\python.exe"
+#>
+param(
+    [string]$PythonExe = (Get-Command python -ErrorAction Stop).Source
+)
+
+$ErrorActionPreference = 'Stop'
+$scriptDir = Split-Path -Parent $PSScriptRoot
+$supervisorScript = Join-Path $scriptDir 'robot_supervisor.py'
+if (-not (Test-Path $supervisorScript)) {
+    throw "robot_supervisor.py not found at $supervisorScript"
+}
+
+$taskName = 'RoboParkSupervisor'
+$action = New-ScheduledTaskAction -Execute $PythonExe -Argument "`"$supervisorScript`"" -WorkingDirectory $scriptDir
+$trigger = New-ScheduledTaskTrigger -AtLogOn
+$settings = New-ScheduledTaskSettingsSet `
+    -RestartCount 999 `
+    -RestartInterval (New-TimeSpan -Minutes 1) `
+    -ExecutionTimeLimit (New-TimeSpan -Days 0) `
+    -AllowStartIfOnBatteries `
+    -DontStopIfGoingOnBatteries
+
+Register-ScheduledTask -TaskName $taskName -Action $action -Trigger $trigger -Settings $settings -Force | Out-Null
+
+Write-Output "Registered scheduled task '$taskName' — starts at logon, restarts on crash."
+Write-Output "Config: copy supervisor.example.json to `$HOME\.robopark\supervisor.json and edit it first if you haven't."
+Write-Output "Start it now without logging out: Start-ScheduledTask -TaskName '$taskName'"
+Write-Output "Remove it later: Unregister-ScheduledTask -TaskName '$taskName' -Confirm:`$false"

package/packages/robopark/scheduler/scripts/robopark-supervisor.service

@@ -0,0 +1,20 @@
+[Unit]
+Description=RoboPark robot supervisor (preview_agent + vision + motors)
+After=network-online.target sound.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+# Edit these two for your setup:
+User=pi
+WorkingDirectory=/home/pi/infinicode-main/packages/robopark/scheduler
+ExecStart=/usr/bin/python3 robot_supervisor.py
+Restart=always
+RestartSec=5
+# Camera/audio devices, GPIO — adjust group membership instead of running as
+# root: `sudo usermod -aG video,audio,gpio pi`
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=multi-user.target

package/packages/robopark/scheduler/scripts/start-scheduler-local.ps1

@@ -0,0 +1,50 @@
+<#
+.SYNOPSIS
+  Starts the RoboPark scheduler locally with every env var it needs.
+
+.DESCRIPTION
+  main.py's own auth for the voice agent's session-keepalive calls
+  (ROBOPARK_AGENT_TOKEN, checked in POST /api/sessions/{id}/keepalive)
+  silently degrades to "every keepalive gets 401'd" if the scheduler is
+  ever started without it set -- no startup error, no crash, just every
+  motion-triggered session getting cut off by its own silence-timeout
+  within ~15s because last_activity_at never updates. This bit twice in
+  one session from ad-hoc restarts that forgot the env var. Use this
+  script (or set the same vars) for every local restart instead of a bare
+  `python main.py`.
+
+  ROBOPARK_AGENT_TOKEN here MUST match ROBOPARK_AGENT_TOKEN in the voice
+  agent's own .env -- it's the shared secret the agent container presents
+  via the X-RoboPark-Agent-Token header. Never hardcode the actual value
+  in this script (it's committed to git) -- pass it explicitly, set it in
+  your shell first, or point -AgentEnvFile at the agent's .env to read it
+  from there at run time.
+
+.EXAMPLE
+  .\start-scheduler-local.ps1 -AgentToken "the-real-token"
+  .\start-scheduler-local.ps1 -AgentEnvFile "C:\path\to\ROBOVOICE-main\.env"
+  $env:ROBOPARK_AGENT_TOKEN = "the-real-token"; .\start-scheduler-local.ps1
+#>
+param(
+    [string]$DataDir = "C:\Users\yunge\OneDrive\Desktop\data",
+    [string]$AgentToken = $env:ROBOPARK_AGENT_TOKEN,
+    [string]$AgentEnvFile,
+    [string]$PythonExe = (Get-Command python -ErrorAction Stop).Source
+)
+
+$ErrorActionPreference = 'Stop'
+$schedulerDir = Split-Path -Parent $PSScriptRoot
+
+if (-not $AgentToken -and $AgentEnvFile -and (Test-Path $AgentEnvFile)) {
+    $line = Get-Content $AgentEnvFile | Where-Object { $_ -match '^ROBOPARK_AGENT_TOKEN=' } | Select-Object -First 1
+    if ($line) { $AgentToken = ($line -split '=', 2)[1].Trim() }
+}
+if (-not $AgentToken) {
+    throw "ROBOPARK_AGENT_TOKEN not provided. Pass -AgentToken, set `$env:ROBOPARK_AGENT_TOKEN first, or pass -AgentEnvFile pointing at the voice agent's .env."
+}
+
+$env:SCHEDULER_DATA_DIR = $DataDir
+$env:ROBOPARK_AGENT_TOKEN = $AgentToken
+
+Write-Output "Starting scheduler: SCHEDULER_DATA_DIR=$DataDir, ROBOPARK_AGENT_TOKEN set (len=$($AgentToken.Length))"
+& $PythonExe (Join-Path $schedulerDir 'main.py')

package/packages/robopark/scheduler/supervisor.example.json

@@ -0,0 +1,26 @@
+{
+  "log_dir": "~/.robopark/logs",
+  "services": [
+    {
+      "name": "preview_agent",
+      "enabled": true,
+      "comment": "Core service — heartbeat, LiveKit publish, motion webhook listener. Reads its own settings from ~/.robopark/preview_agent.json (device_id, scheduler_url, etc), enrolled once via `robopark add-robot`.",
+      "command": ["python", "preview_agent.py"],
+      "cwd": "/absolute/path/to/infinicode-main/packages/robopark/scheduler"
+    },
+    {
+      "name": "vision_app",
+      "enabled": false,
+      "comment": "Real motion/object detection (e.g. RoboVisionAI_PI's app_pi_clean.py). Must POST to preview_agent's motion webhook (http://localhost:<vision-webhook-port>/, default 5057) on detection. Disabled by default — no safe generic command, fill in your robot's actual vision app path.",
+      "command": ["python", "app_pi_clean.py"],
+      "cwd": "/absolute/path/to/RoboVisionAI_PI"
+    },
+    {
+      "name": "motor_server",
+      "enabled": false,
+      "comment": "Only needed if your robot's motors are NOT wired to preview_agent's LiveKit data-channel path — i.e. voice_agent.py falls back to motor_server_url (set on the character preset / device) instead of the data-channel. Disabled by default.",
+      "command": ["python", "-m", "uvicorn", "motors:app", "--host", "0.0.0.0", "--port", "8001"],
+      "cwd": "/absolute/path/to/motor-server-project"
+    }
+  ]
+}

package/packages/robopark/scheduler/vision_motion_trigger.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""
+Minimal cross-platform motion detector -> preview_agent.py's motion webhook.
+
+RoboVisionAI_PI's real app_pi_clean.py does full object detection + motion
++ MJPEG streaming in one Flask app, but its motion loop only actually runs
+while something is actively pulling /video_feed, and it wants Pi-specific
+caffemodel files for the object-detection half. For a plain "does motion
+actually reach the conversation pipeline" test (or a lightweight always-on
+trigger on a robot that doesn't need the vision overlay), this is a much
+smaller piece: open whatever camera OpenCV can see, do frame-differencing
+motion detection, POST to the webhook on motion, done. No Flask, no model
+files, works the same on Windows/Linux/Pi wherever cv2 can open a camera.
+
+preview_agent.py's webhook handler accepts any POST body (even {}) as a
+trigger signal -- it does not require the RoboVisionAI_PI payload shape --
+so this only needs to hit the URL, not match any particular JSON schema.
+
+Usage:
+    python vision_motion_trigger.py --webhook-url http://localhost:5058/
+    python vision_motion_trigger.py --camera 0 --min-area 800 --cooldown 15
+"""
+from __future__ import annotations
+
+import argparse
+import logging
+import time
+
+logger = logging.getLogger("robopark.vision_motion_trigger")
+
+
+def run(camera_index: int, webhook_url: str, min_area: float, cooldown: float, fps_limit: float) -> None:
+    import cv2
+    import httpx
+
+    cap = cv2.VideoCapture(camera_index)
+    if not cap.isOpened():
+        raise SystemExit(f"could not open camera index {camera_index}")
+    logger.info(f"camera {camera_index} opened, watching for motion (min_area={min_area}px, cooldown={cooldown}s)")
+
+    prev_gray = None
+    last_trigger = 0.0
+    frame_interval = 1.0 / fps_limit if fps_limit > 0 else 0.0
+    client = httpx.Client(timeout=5.0)
+
+    try:
+        while True:
+            loop_start = time.monotonic()
+            ok, frame = cap.read()
+            if not ok:
+                logger.warning("camera read failed, retrying")
+                time.sleep(1.0)
+                continue
+
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            gray = cv2.GaussianBlur(gray, (21, 21), 0)
+
+            if prev_gray is not None:
+                delta = cv2.absdiff(prev_gray, gray)
+                thresh = cv2.threshold(delta, 25, 255, cv2.THRESH_BINARY)[1]
+                thresh = cv2.dilate(thresh, None, iterations=2)
+                contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+                motion = any(cv2.contourArea(c) >= min_area for c in contours)
+
+                if motion:
+                    now = time.time()
+                    if now - last_trigger >= cooldown:
+                        last_trigger = now
+                        logger.info("motion detected, posting to webhook")
+                        try:
+                            client.post(webhook_url, json={"source": "vision_motion_trigger"})
+                        except Exception as e:
+                            logger.warning(f"webhook POST failed: {e}")
+                    else:
+                        logger.debug("motion detected, still in cooldown")
+
+            prev_gray = gray
+
+            if frame_interval:
+                elapsed = time.monotonic() - loop_start
+                if elapsed < frame_interval:
+                    time.sleep(frame_interval - elapsed)
+    finally:
+        cap.release()
+        client.close()
+
+
+def main() -> None:
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--camera", type=int, default=0, help="OpenCV camera index (default 0)")
+    parser.add_argument("--webhook-url", default="http://localhost:5058/", help="preview_agent.py's motion webhook")
+    parser.add_argument("--min-area", type=float, default=500.0, help="minimum changed-pixel contour area to count as motion")
+    parser.add_argument("--cooldown", type=float, default=20.0, help="minimum seconds between triggers")
+    parser.add_argument("--fps-limit", type=float, default=5.0, help="cap capture rate to reduce CPU (0 = uncapped)")
+    args = parser.parse_args()
+    run(args.camera, args.webhook_url, args.min_area, args.cooldown, args.fps_limit)
+
+
+if __name__ == "__main__":
+    main()