robopark 2.8.35 → 3.0.0

package/dist/robopark/verify.js

@@ -0,0 +1,192 @@
+/**
+ * RoboPark — `robopark verify`.
+ *
+ * Checks the fleet end-to-end and reports what's working vs. missing:
+ *   - hub / scheduler reachable
+ *   - LiveKit configured and server registered
+ *   - production mode enabled
+ *   - robots/devices enrolled
+ *   - preview agent running on robots
+ *   - preview room can be started
+ *
+ * Usage:
+ *   robopark verify
+ *   robopark verify --scheduler-url http://livekit-1:8080 --robot-id robobmw
+ */
+import { existsSync } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { discoverContext } from './discovery.js';
+function loadDeviceToken(robotId) {
+    const paths = [
+        join(homedir(), '.robopark', 'device_token'),
+    ];
+    for (const p of paths) {
+        if (existsSync(p))
+            return readFile(p);
+    }
+    return undefined;
+}
+function readFile(p) {
+    const { readFileSync } = require('node:fs');
+    return readFileSync(p, 'utf8').trim();
+}
+async function fetchJson(url, init) {
+    const res = await fetch(url, { ...init, signal: AbortSignal.timeout(5000) });
+    if (!res.ok)
+        throw new Error(`${res.status} ${res.statusText}`);
+    return res.json();
+}
+export async function roboparkVerify(opts) {
+    const ctx = await discoverContext();
+    const schedulerUrl = (opts.schedulerUrl ?? (ctx.hub ? `http://${ctx.hub.ip}:8080` : 'http://localhost:8080')).replace(/\/$/, '');
+    const robotId = opts.robotId ?? hostname().split('.')[0];
+    console.log(chalk.bold('\n  robopark verify'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  scheduler: ${chalk.cyan(schedulerUrl)}`);
+    console.log(`  robot:     ${chalk.cyan(robotId)}`);
+    console.log();
+    const checks = [];
+    // 1. Scheduler reachable
+    try {
+        const settings = (await fetchJson(`${schedulerUrl}/api/settings`));
+        checks.push({ name: 'scheduler reachable', ok: true, message: `production_mode=${settings.production_mode ?? false}` });
+        if (!settings.production_mode) {
+            checks.push({ name: 'production mode', ok: false, message: 'Production mode is OFF. Toggle it in the dashboard or PUT /api/settings', detail: 'Pi preview/session enrollment is blocked until production mode is ON.' });
+        }
+        else {
+            checks.push({ name: 'production mode', ok: true, message: 'ON' });
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'scheduler reachable', ok: false, message: `could not reach scheduler: ${e.message}`, detail: 'Is robopark serve running on the hub? Is the scheduler port open?' });
+    }
+    // 2. LiveKit configured
+    try {
+        const lk = (await fetchJson(`${schedulerUrl}/api/livekit/config`));
+        if (lk.url && lk.has_secret) {
+            checks.push({ name: 'livekit configured', ok: true, message: `url=${lk.url}` });
+        }
+        else {
+            checks.push({ name: 'livekit configured', ok: false, message: 'LiveKit URL or API secret missing', detail: 'Set LiveKit config in the dashboard or via robopark setup-livekit.' });
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'livekit configured', ok: false, message: `error: ${e.message}` });
+    }
+    // 3. LiveKit server registered
+    try {
+        const servers = (await fetchJson(`${schedulerUrl}/api/servers`));
+        const online = servers.filter(s => s.status === 'online');
+        if (online.length > 0) {
+            checks.push({ name: 'livekit server registered', ok: true, message: `${online.length} online server(s)` });
+        }
+        else if (servers.length > 0) {
+            checks.push({ name: 'livekit server registered', ok: false, message: `${servers.length} server(s) but none online`, detail: 'Check that the LiveKit container/process is running and reachable from the hub.' });
+        }
+        else {
+            checks.push({ name: 'livekit server registered', ok: false, message: 'no servers in scheduler', detail: 'Add a LiveKit server in the dashboard or run robopark setup-livekit.' });
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'livekit server registered', ok: false, message: `error: ${e.message}` });
+    }
+    // 4. Device enrolled
+    let deviceToken;
+    let deviceId;
+    try {
+        const devices = (await fetchJson(`${schedulerUrl}/api/devices`));
+        const device = devices.find(d => d.name === robotId || d.id === robotId);
+        if (device) {
+            deviceId = device.id;
+            checks.push({ name: 'device enrolled', ok: true, message: `${device.id} (${device.status})` });
+        }
+        else {
+            checks.push({ name: 'device enrolled', ok: false, message: `${robotId} not found in scheduler`, detail: 'Run robopark enroll on the robot with the scheduler enrollment token.' });
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'device enrolled', ok: false, message: `error: ${e.message}` });
+    }
+    // 5. Local device token
+    deviceToken = loadDeviceToken(robotId);
+    if (deviceToken) {
+        checks.push({ name: 'local device token', ok: true, message: `found ~/.robopark/device_token` });
+    }
+    else {
+        checks.push({ name: 'local device token', ok: false, message: 'no ~/.robopark/device_token', detail: 'Run robopark enroll on this machine first.' });
+    }
+    // 6. Robot row exists
+    try {
+        const robots = (await fetchJson(`${schedulerUrl}/api/robots`));
+        const robot = robots.find(r => r.id === (deviceId || robotId) || r.name === robotId);
+        if (robot) {
+            checks.push({ name: 'robot registered', ok: true, message: `${robot.id} (${robot.status})` });
+        }
+        else {
+            checks.push({ name: 'robot registered', ok: false, message: `${robotId} not in robots table`, detail: 'The device should auto-create a robot row on enrollment. Re-run enroll or check scheduler logs.' });
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'robot registered', ok: false, message: `error: ${e.message}` });
+    }
+    // 7. Preview agent polling
+    if (deviceToken) {
+        try {
+            const agentRes = (await fetchJson(`${schedulerUrl}/api/robots/${robotId}/preview/agent`, {
+                headers: { Authorization: `Bearer ${deviceToken}` },
+            }));
+            if (agentRes.active) {
+                checks.push({ name: 'preview agent polling', ok: true, message: 'preview currently active' });
+            }
+            else {
+                checks.push({ name: 'preview agent polling', ok: true, message: `no active preview (reason=${agentRes.reason || 'none'})`, detail: 'This is normal when the dashboard is not watching. Start a preview from the dashboard.' });
+            }
+        }
+        catch (e) {
+            checks.push({ name: 'preview agent polling', ok: false, message: `error: ${e.message}`, detail: 'Is robopark preview-agent running on the robot?' });
+        }
+    }
+    else {
+        checks.push({ name: 'preview agent polling', ok: false, message: 'skipped (no device token)' });
+    }
+    // 8. Try starting a preview from the operator side
+    try {
+        const preview = (await fetchJson(`${schedulerUrl}/api/robots/${robotId}/preview/start`, { method: 'POST' }));
+        if (preview.active) {
+            checks.push({ name: 'operator preview start', ok: true, message: `room assigned at ${preview.url}` });
+            // stop it so we don't leave a stale preview running
+            await fetch(`${schedulerUrl}/api/robots/${robotId}/preview/stop`, { method: 'POST' });
+        }
+        else {
+            checks.push({ name: 'operator preview start', ok: false, message: `could not start: ${preview.reason || 'unknown'}`, detail: 'Enable production mode, add a LiveKit server, and ensure the robot is not in a session.' });
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'operator preview start', ok: false, message: `error: ${e.message}` });
+    }
+    // Print results
+    let pass = 0;
+    let fail = 0;
+    for (const c of checks) {
+        const icon = c.ok ? chalk.green('✓') : chalk.red('✗');
+        const color = c.ok ? chalk.green : chalk.red;
+        console.log(`  ${icon} ${color(c.name)} — ${c.message}`);
+        if (c.detail) {
+            console.log(chalk.dim(`    → ${c.detail}`));
+        }
+        if (c.ok)
+            pass++;
+        else
+            fail++;
+    }
+    console.log();
+    if (fail === 0) {
+        console.log(chalk.bold.green(`  ${pass}/${checks.length} checks passed — fleet is ready for preview.`));
+    }
+    else {
+        console.log(chalk.bold.yellow(`  ${pass}/${checks.length} passed, ${fail} failed — fix the items above.`));
+        process.exitCode = 1;
+    }
+}

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

@@ -0,0 +1,98 @@
+/**
+ * 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, findVisionAudioPath, prepareRobotPython, 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 basePython = 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_vision_agent.txt' : 'requirements-demo.txt';
+    const requiredModules = isPiArm() ? [...VISION_REQUIRED_MODULES, 'fastapi', 'uvicorn', 'sounddevice', 'soundfile', 'groq', 'lgpio'] : VISION_REQUIRED_MODULES;
+    const python = prepareRobotPython(basePython, script, requiredModules, reqFile);
+    if (!python)
+        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');
+    // The original RoboVision audio selector lives in audio_server_pi.py.
+    // Start it beside the camera service on real Pi robots so /devices and
+    // /set-device remain the authoritative source for Park dropdowns.
+    let audioScript = null;
+    if (isPiArm()) {
+        audioScript = await findVisionAudioPath();
+    }
+    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')}`);
+    if (audioScript)
+        console.log(`  audio:   ${chalk.green('RoboVision audio server :8000')}`);
+    console.log(`  motors:  ${chalk.dim('managed independently by robopark motor :8001')}`);
+    console.log();
+    if (opts.foreground) {
+        const audio = audioScript
+            ? spawn(python, [audioScript], { stdio: 'inherit', env: { ...process.env, ROBOPARK_AUDIO_SERVER: '1' } })
+            : null;
+        const camera = spawn(python, args, { stdio: 'inherit' });
+        let stopping = false;
+        const stopChildren = () => {
+            if (stopping)
+                return;
+            stopping = true;
+            camera.kill('SIGTERM');
+            audio?.kill('SIGTERM');
+        };
+        process.once('SIGINT', stopChildren);
+        process.once('SIGTERM', stopChildren);
+        // If either required media service exits, tear down its sibling. The
+        // robot runtime then restarts one coherent pair instead of accumulating
+        // orphan audio servers and duplicate owners of ports/devices.
+        await new Promise((resolve) => {
+            let resolved = false;
+            const finish = () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                stopChildren();
+                resolve();
+            };
+            camera.once('close', finish);
+            audio?.once('close', finish);
+        });
+        return;
+    }
+    if (audioScript) {
+        const audio = spawn(python, [audioScript], {
+            stdio: 'ignore', detached: true, env: { ...process.env, ROBOPARK_AUDIO_SERVER: '1' },
+        });
+        audio.unref();
+    }
+    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/vision-control.js

@@ -0,0 +1,81 @@
+import { spawnSync } from 'node:child_process';
+import chalk from 'chalk';
+import { unregisterAutoStart } from './auto-start.js';
+import { resolveContext } from './profile.js';
+import { roboparkSetup } from './setup.js';
+function runtimeUnit(name) {
+    return `robopark-robot-runtime-${name.toLowerCase().replace(/[^a-z0-9]+/g, '-')}.service`;
+}
+export async function roboparkVisionUp(config, name, opts) {
+    if (opts.lan && opts.tailscale)
+        throw new Error('choose exactly one of --lan or --tailscale');
+    const context = await resolveContext({ hubUrl: opts.hubUrl, token: opts.token });
+    if (!context.hubUrl) {
+        throw new Error('no hub resolved; run `robopark hub-use --hub-url http://HUB_IP:47913 --token TOKEN` once');
+    }
+    if (!context.token) {
+        throw new Error('no mesh token resolved; run `robopark hub-use --hub-url http://HUB_IP:47913 --token TOKEN` once');
+    }
+    console.log(chalk.bold('\n  robopark vision up'));
+    console.log(chalk.dim('  ' + '-'.repeat(52)));
+    console.log(`  robot:  ${chalk.cyan(name)}`);
+    console.log(`  camera: ${chalk.cyan(opts.videoDevice ?? 'auto')}`);
+    console.log(`  relay:  ${chalk.green('always on, independent of voice calls')}`);
+    console.log();
+    await roboparkSetup(config, {
+        role: 'robot',
+        name,
+        site: context.site,
+        hub: context.hubUrl,
+        token: context.token,
+        port: opts.port ?? '47913',
+        character: opts.character,
+        videoDevice: opts.videoDevice ?? 'auto',
+        // A vision-only registration must never reserve the production microphone.
+        audioDevice: 'none',
+        lan: opts.tailscale ? false : true,
+        tailscale: Boolean(opts.tailscale),
+        start: true,
+        autoStart: opts.autoStart !== false,
+        yes: true,
+    });
+    console.log(chalk.dim(`  dashboard relay: /fed/media/robots/${encodeURIComponent(name)}/video_feed`));
+}
+export function roboparkVisionDown(name) {
+    const result = unregisterAutoStart('robot-runtime', name);
+    if (!result.ok)
+        throw new Error(result.message);
+    console.log(chalk.green(`  ${result.message}`));
+}
+export function roboparkVisionRestart(name) {
+    if (process.platform !== 'linux') {
+        throw new Error('vision restart currently requires systemd; rerun `robopark vision up NAME` on this platform');
+    }
+    const unit = runtimeUnit(name);
+    const result = spawnSync('systemctl', ['restart', unit], { encoding: 'utf8' });
+    if (result.status !== 0)
+        throw new Error(String(result.stderr || result.stdout || `could not restart ${unit}`).trim());
+    console.log(chalk.green(`  restarted ${unit}`));
+}
+export async function roboparkVisionStatus(name) {
+    const unit = runtimeUnit(name);
+    const service = process.platform === 'linux'
+        ? spawnSync('systemctl', ['is-active', unit], { encoding: 'utf8' }).stdout.trim()
+        : 'unknown';
+    let camera = 'unreachable';
+    try {
+        const response = await fetch('http://127.0.0.1:5000/api/camera/status', {
+            signal: AbortSignal.timeout(3_000),
+        });
+        camera = response.ok ? 'ready' : `HTTP ${response.status}`;
+    }
+    catch {
+        // Printed as unreachable below.
+    }
+    console.log(chalk.bold(`\n  ${name} vision`));
+    console.log(`  service: ${service === 'active' ? chalk.green(service) : chalk.yellow(service)}`);
+    console.log(`  camera:  ${camera === 'ready' ? chalk.green(camera) : chalk.yellow(camera)}`);
+    console.log(`  local:   http://127.0.0.1:5000/video_feed`);
+    if (service !== 'active' || camera !== 'ready')
+        process.exitCode = 1;
+}