infinicode 2.8.15 → 2.8.16

package/dist/robopark/auto-start.d.ts

@@ -1,5 +1,5 @@
 export interface ServiceArgs {
-    role: 'hub' | 'robot' | 'control' | 'hub-scheduler' | 'robot-preview-agent';
+    role: 'hub' | 'robot' | 'control' | 'hub-scheduler' | 'robot-preview-agent' | 'robot-vision-agent';
     name: string;
     command: string;
     args: string[];

package/dist/robopark/python-env.d.ts

@@ -1,9 +1,15 @@
+/** Modules app_pi_clean.py imports — kept in sync with requirements_pi_unified.txt. */
+export declare const VISION_REQUIRED_MODULES: string[];
 export declare function findSchedulerPath(): Promise<string | null>;
+export declare function findVisionPath(): Promise<string | null>;
 export declare function findPython(): string;
 /**
- * Ensure preview_agent.py's Python deps are importable, installing them from
- * requirements-robot.txt (next to the script) if not. Returns false — with a
- * message already printed — if deps are still missing after the install
+ * Ensure a robot-side script's Python deps are importable, installing them
+ * from a requirements file (next to the script) if not. Returns false — with
+ * a message already printed — if deps are still missing after the install
  * attempt, so callers can bail out before hitting a raw traceback.
+ *
+ * Defaults match preview_agent.py; pass `modules`/`reqFile` for other scripts
+ * (e.g. app_pi_clean.py + requirements_pi_unified.txt).
  */
-export declare function ensurePythonDeps(python: string, scriptPath: string): boolean;
+export declare function ensurePythonDeps(python: string, scriptPath: string, modules?: string[], reqFile?: string): boolean;

package/dist/robopark/python-env.js

@@ -1,6 +1,6 @@
 /**
- * RoboPark — shared Python environment helpers for `enroll` and
- * `preview-agent`, which both spawn `preview_agent.py`.
+ * RoboPark — shared Python environment helpers for `enroll`, `preview-agent`,
+ * and `vision-agent`, which spawn preview_agent.py / app_pi_clean.py.
  */
 import { execSync, spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
@@ -8,10 +8,13 @@ import { join } from 'node:path';
 import chalk from 'chalk';
 /** Modules preview_agent.py imports — kept in sync with requirements-robot.txt. */
 const REQUIRED_MODULES = ['httpx', 'cv2', 'pyaudio', 'livekit'];
-export async function findSchedulerPath() {
+/** Modules app_pi_clean.py imports — kept in sync with requirements_pi_unified.txt. */
+export const VISION_REQUIRED_MODULES = ['flask', 'flask_cors', 'cv2', 'numpy', 'requests'];
+async function findPackageScript(relativePath) {
+    const parts = relativePath.split('/');
     const candidates = [
-        join(process.cwd(), 'packages', 'robopark', 'scheduler', 'preview_agent.py'),
-        join(process.cwd(), 'scheduler', 'preview_agent.py'),
+        join(process.cwd(), 'packages', 'robopark', ...parts),
+        join(process.cwd(), ...parts),
     ];
     for (const p of candidates) {
         if (existsSync(p))
@@ -21,13 +24,19 @@ export async function findSchedulerPath() {
         const { createRequire } = await import('node:module');
         const require = createRequire(import.meta.url);
         const pkgMain = require.resolve('infinicode/package.json');
-        const p = join(pkgMain, '..', 'packages', 'robopark', 'scheduler', 'preview_agent.py');
+        const p = join(pkgMain, '..', 'packages', 'robopark', ...relativePath.split('/'));
         if (existsSync(p))
             return p;
     }
     catch { /* ignore */ }
     return null;
 }
+export async function findSchedulerPath() {
+    return findPackageScript('scheduler/preview_agent.py');
+}
+export async function findVisionPath() {
+    return findPackageScript('vision/app_pi_clean.py');
+}
 export function findPython() {
     const names = process.platform === 'win32'
         ? ['python', 'python3', 'py']
@@ -43,25 +52,28 @@ export function findPython() {
     }
     return process.platform === 'win32' ? 'python' : 'python3';
 }
-function missingModules(python) {
-    return REQUIRED_MODULES.filter(mod => {
+function missingModules(python, modules) {
+    return modules.filter(mod => {
         const res = spawnSync(python, ['-c', `import ${mod}`], { stdio: 'ignore' });
         return res.status !== 0;
     });
 }
 /**
- * Ensure preview_agent.py's Python deps are importable, installing them from
- * requirements-robot.txt (next to the script) if not. Returns false — with a
- * message already printed — if deps are still missing after the install
+ * Ensure a robot-side script's Python deps are importable, installing them
+ * from a requirements file (next to the script) if not. Returns false — with
+ * a message already printed — if deps are still missing after the install
  * attempt, so callers can bail out before hitting a raw traceback.
+ *
+ * Defaults match preview_agent.py; pass `modules`/`reqFile` for other scripts
+ * (e.g. app_pi_clean.py + requirements_pi_unified.txt).
  */
-export function ensurePythonDeps(python, scriptPath) {
-    const missing = missingModules(python);
+export function ensurePythonDeps(python, scriptPath, modules = REQUIRED_MODULES, reqFile = 'requirements-robot.txt') {
+    const missing = missingModules(python, modules);
     if (missing.length === 0)
         return true;
-    const reqPath = join(scriptPath, '..', 'requirements-robot.txt');
+    const reqPath = join(scriptPath, '..', reqFile);
     if (!existsSync(reqPath)) {
-        console.log(chalk.red(`  ✗ missing Python modules: ${missing.join(', ')} (and requirements-robot.txt not found next to ${scriptPath})`));
+        console.log(chalk.red(`  ✗ missing Python modules: ${missing.join(', ')} (and ${reqFile} not found next to ${scriptPath})`));
         return false;
     }
     console.log(chalk.dim(`  installing Python deps (${missing.join(', ')})…`));
@@ -70,7 +82,7 @@ export function ensurePythonDeps(python, scriptPath) {
         console.log(chalk.red(`  ✗ pip install failed — install manually: ${python} -m pip install -r "${reqPath}"`));
         return false;
     }
-    const stillMissing = missingModules(python);
+    const stillMissing = missingModules(python, modules);
     if (stillMissing.length > 0) {
         console.log(chalk.red(`  ✗ still missing after install: ${stillMissing.join(', ')} — install manually: ${python} -m pip install -r "${reqPath}"`));
         return false;

package/dist/robopark/setup.d.ts

@@ -16,6 +16,7 @@ export interface SetupOptions {
     enrollmentToken?: string;
     videoDevice?: string;
     audioDevice?: string;
+    vision?: boolean;
     start?: boolean;
     autoStart?: boolean;
     yes?: boolean;

package/dist/robopark/setup.js

@@ -171,9 +171,16 @@ async function setupRobot(config, opts, ctx, internal) {
     ];
     if (opts.enrollmentToken)
         previewAgentArgs.push('--enrollment-token', opts.enrollmentToken);
+    // Vision (camera/motion detection -> presence-triggered session) is the
+    // production trigger — on by default. --no-vision opts out (e.g. no camera
+    // on this box, or RoboVisionAI_PI isn't installed).
+    const visionEnabled = opts.vision !== false;
+    const visionAgentArgs = ['vision-agent'];
     console.log(chalk.dim('  robot command:'));
     console.log('  ' + chalk.cyan(`infinicode ${args.join(' ')}`));
     console.log('  ' + chalk.cyan(`robopark ${previewAgentArgs.join(' ')}`));
+    if (visionEnabled)
+        console.log('  ' + chalk.cyan(`robopark ${visionAgentArgs.join(' ')}`));
     console.log();
     if (opts.start) {
         const robotArgv = await infinicodeArgv(args);
@@ -191,6 +198,11 @@ async function setupRobot(config, opts, ctx, internal) {
         console.log(chalk.dim('  starting preview agent…'));
         const previewArgv = [process.execPath, process.argv[1], ...previewAgentArgs];
         runDetached(previewArgv[0], previewArgv.slice(1));
+        if (visionEnabled) {
+            console.log(chalk.dim('  starting vision agent…'));
+            const visionArgv = [process.execPath, process.argv[1], ...visionAgentArgs];
+            runDetached(visionArgv[0], visionArgv.slice(1));
+        }
     }
     if (opts.autoStart) {
         const robotArgv = await infinicodeArgv(args);
@@ -209,6 +221,16 @@ async function setupRobot(config, opts, ctx, internal) {
             args: previewArgv.slice(1),
         });
         console.log(reg2.ok ? chalk.green(`  ✓ ${reg2.message}`) : chalk.yellow(`  ⚠ ${reg2.message}`));
+        if (visionEnabled) {
+            const visionArgv = [process.execPath, process.argv[1], ...visionAgentArgs, '--foreground'];
+            const reg3 = await registerAutoStart({
+                role: 'robot-vision-agent',
+                name: internal.name,
+                command: visionArgv[0],
+                args: visionArgv.slice(1),
+            });
+            console.log(reg3.ok ? chalk.green(`  ✓ ${reg3.message}`) : chalk.yellow(`  ⚠ ${reg3.message}`));
+        }
     }
 }
 async function setupControl(config, opts, ctx, internal) {

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

@@ -0,0 +1,7 @@
+export interface VisionAgentOptions {
+    port?: string;
+    motionWebhookUrl?: string;
+    motionActive?: boolean;
+    foreground?: boolean;
+}
+export declare function roboparkVisionAgent(opts: VisionAgentOptions): Promise<void>;

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

@@ -0,0 +1,55 @@
+/**
+ * RoboPark — `robopark vision-agent` launcher.
+ *
+ * Starts app_pi_clean.py (RoboVisionAI_PI's camera/motion detector) with the
+ * right Python interpreter, self-armed and pointed at the local
+ * preview-agent's motion-webhook listener by default — no manual curl calls.
+ */
+import { spawn } from 'node:child_process';
+import chalk from 'chalk';
+import { findPython, findVisionPath, ensurePythonDeps, VISION_REQUIRED_MODULES } from './python-env.js';
+const DEFAULT_VISION_PORT = 5000;
+const DEFAULT_MOTION_WEBHOOK_PORT = 5057; // must match preview-agent's --vision-webhook-port default
+function isPiArm() {
+    return process.platform === 'linux' && (process.arch === 'arm' || process.arch === 'arm64');
+}
+export async function roboparkVisionAgent(opts) {
+    const script = await findVisionPath();
+    if (!script) {
+        console.log(chalk.red('  ✗ could not find app_pi_clean.py'));
+        process.exit(1);
+    }
+    const python = findPython();
+    // Real Pi: opencv comes from `apt install python3-opencv`, not pip (see
+    // requirements_pi_unified.txt) — pip-installing it here would fight the
+    // ARM-optimized system build. Everywhere else: plain pip install works.
+    const reqFile = isPiArm() ? 'requirements_pi_unified.txt' : 'requirements-demo.txt';
+    if (!ensurePythonDeps(python, script, VISION_REQUIRED_MODULES, reqFile))
+        process.exit(1);
+    const port = opts.port ?? String(DEFAULT_VISION_PORT);
+    const webhookUrl = opts.motionWebhookUrl ?? `http://127.0.0.1:${DEFAULT_MOTION_WEBHOOK_PORT}/`;
+    const motionActive = opts.motionActive ?? true; // armed by default — "vision trigger as production system"
+    const args = [script, '--port', port, '--motion-webhook-url', webhookUrl];
+    if (motionActive)
+        args.push('--motion-active');
+    console.log(chalk.bold('\n  robopark vision-agent'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  port:    ${chalk.cyan(port)}`);
+    console.log(`  webhook: ${chalk.cyan(webhookUrl)}`);
+    console.log(`  motion:  ${motionActive ? chalk.green('armed') : chalk.dim('off')}`);
+    console.log();
+    if (opts.foreground) {
+        const proc = spawn(python, args, { stdio: 'inherit' });
+        await new Promise((resolve) => {
+            proc.on('close', () => resolve());
+        });
+        return;
+    }
+    const proc = spawn(python, args, {
+        stdio: 'ignore',
+        detached: true,
+        env: { ...process.env, ROBOPARK_VISION_AGENT: '1' },
+    });
+    proc.unref();
+    console.log(chalk.green('  ✓ vision agent started in background'));
+}

package/dist/robopark-cli.js

@@ -108,6 +108,17 @@ program
     const { roboparkPreviewAgent } = await import('./robopark/preview-agent-launcher.js');
     await roboparkPreviewAgent(opts);
 });
+program
+    .command('vision-agent')
+    .description('Start the robot-side camera/motion detector (RoboVisionAI_PI) — self-arms and wires to preview-agent\'s vision webhook')
+    .option('--port <port>', 'vision server port', '5000')
+    .option('--motion-webhook-url <url>', 'where to POST on motion (defaults to the local preview-agent\'s vision webhook, http://127.0.0.1:5057/)')
+    .option('--no-motion-active', 'do not arm motion detection on startup (armed by default)')
+    .option('--foreground', 'stay in foreground; do not detach')
+    .action(async (opts) => {
+    const { roboparkVisionAgent } = await import('./robopark/vision-agent-launcher.js');
+    await roboparkVisionAgent(opts);
+});
 program
     .command('setup')
     .description('Set up this device in one pass')
@@ -128,6 +139,7 @@ program
     .option('--enrollment-token <token>', 'one-time scheduler enrollment token for robots')
     .option('--video-device <dev>', 'default camera for robot preview agent', 'auto')
     .option('--audio-device <dev>', 'default microphone for robot preview agent', 'default')
+    .option('--no-vision', 'do not start the vision (camera/motion trigger) agent for a robot — armed by default')
     .option('--start', 'launch the node now')
     .option('--auto-start', 'register to start on boot')
     .option('--yes', 'non-interactive mode')
@@ -152,6 +164,7 @@ program
         enrollmentToken: opts.enrollmentToken,
         videoDevice: opts.videoDevice,
         audioDevice: opts.audioDevice,
+        vision: opts.vision,
         start: opts.start,
         autoStart: opts.autoStart,
         yes: opts.yes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.15",
+  "version": "2.8.16",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",

package/packages/robopark/vision/README.md

@@ -21,11 +21,14 @@ presence-triggered session (`POST /api/devices/{id}/request-session`),
 publishing camera + mic into the resulting LiveKit room. Point RoboVision at
 it:
 
+Both of these calls go to RoboVision's own server (port 5000 by default —
+NOT the scheduler on 8080):
+
 ```
-curl -X POST http://localhost:8080/api/motion/webhook \
+curl -X POST http://localhost:5000/api/motion/webhook \
   -H "Content-Type: application/json" \
   -d '{"url": "http://localhost:5057/"}'
-curl -X POST http://localhost:8080/api/motion/toggle \
+curl -X POST http://localhost:5000/api/motion/toggle \
   -H "Content-Type: application/json" -d '{"active": true}'
 ```
 

package/packages/robopark/vision/app_pi_clean.py

@@ -1,6 +1,8 @@
 from flask import Flask, Response, jsonify, request
 from flask_cors import CORS
+import argparse
 import cv2
+import os
 import time
 import numpy as np
 import threading
@@ -299,9 +301,26 @@ def motion_webhook():
         })
 
 if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="RoboVision — camera/motion detection server")
+    parser.add_argument("--port", type=int, default=int(os.getenv("VISION_PORT", "5000")))
+    parser.add_argument("--motion-webhook-url", default=os.getenv("MOTION_WEBHOOK_URL", ""),
+                         help="where to POST a snapshot when motion is detected, e.g. http://localhost:5057/")
+    parser.add_argument("--motion-active", action="store_true",
+                         default=os.getenv("MOTION_ACTIVE", "").lower() in ("1", "true", "yes"),
+                         help="arm motion detection immediately on startup (no manual /api/motion/toggle call needed)")
+    args = parser.parse_args()
+
+    if args.motion_webhook_url:
+        webhook_url = args.motion_webhook_url
+    if args.motion_active:
+        motion_detection_active = True
+
     print("=" * 60)
     print("RoboVision - Raspberry Pi Vision Server (Minimal)")
     print("=" * 60)
-    print("Starting Flask server on http://0.0.0.0:5000")
+    print(f"Starting Flask server on http://0.0.0.0:{args.port}")
+    if webhook_url:
+        print(f"Motion webhook: {webhook_url}")
+    print(f"Motion detection: {'ARMED' if motion_detection_active else 'off (POST /api/motion/toggle to arm)'}")
     print("=" * 60)
-    app.run(host='0.0.0.0', port=5000, debug=False, threaded=True)
+    app.run(host='0.0.0.0', port=args.port, debug=False, threaded=True)

package/packages/robopark/vision/requirements-demo.txt

@@ -0,0 +1,12 @@
+# Non-Pi (Windows/macOS/Linux dev laptop) requirements for app_pi_clean.py.
+#
+# requirements_pi_unified.txt deliberately excludes opencv-python (Pi installs
+# it via `apt install python3-opencv` for the ARM-optimized system build) —
+# that's wrong off a real Pi, where plain `pip install opencv-python` is the
+# normal path. Use this file for a demo/dev machine; use
+# requirements_pi_unified.txt (+ apt) on an actual Raspberry Pi.
+flask==3.0.0
+flask-cors==4.0.0
+opencv-python>=4.8
+numpy>=1.24,<2
+requests>=2.31