infinicode 2.8.7 → 2.8.9

package/dist/robopark/setup.d.ts

@@ -13,6 +13,9 @@ export interface SetupOptions {
     tailscaleAuth?: string;
     tag?: string;
     schedulerPort?: string;
+    enrollmentToken?: string;
+    videoDevice?: string;
+    audioDevice?: string;
     start?: boolean;
     autoStart?: boolean;
     yes?: boolean;

package/dist/robopark/setup.js

@@ -160,13 +160,37 @@ async function setupRobot(config, opts, ctx, internal) {
         '--auto-update',
         '--supervised',
     ];
+    const schedulerUrl = `http://${ctx.hub?.ip ?? '127.0.0.1'}:${opts.schedulerPort ? parseInt(opts.schedulerPort, 10) : DEFAULT_SCHEDULER_PORT}`;
+    const previewAgentArgs = [
+        'preview-agent',
+        '--scheduler-url', schedulerUrl,
+        '--robot-id', internal.name,
+        '--video-device', opts.videoDevice ?? 'auto',
+        '--audio-device', opts.audioDevice ?? 'default',
+        '--save-config',
+    ];
+    if (opts.enrollmentToken)
+        previewAgentArgs.push('--enrollment-token', opts.enrollmentToken);
     console.log(chalk.dim('  robot command:'));
     console.log('  ' + chalk.cyan(`infinicode ${args.join(' ')}`));
+    console.log('  ' + chalk.cyan(`robopark ${previewAgentArgs.join(' ')}`));
     console.log();
     if (opts.start) {
         const robotArgv = await infinicodeArgv(args);
         console.log(chalk.dim('  starting robot satellite node…'));
         runDetached(robotArgv[0], robotArgv.slice(1));
+        if (opts.enrollmentToken) {
+            console.log(chalk.dim('  enrolling robot with scheduler…'));
+            const enrollArgv = [process.execPath, process.argv[1], 'enroll',
+                '--scheduler-url', schedulerUrl,
+                '--robot-id', internal.name,
+                '--enrollment-token', opts.enrollmentToken,
+                '--save-config'];
+            runDetached(enrollArgv[0], enrollArgv.slice(1));
+        }
+        console.log(chalk.dim('  starting preview agent…'));
+        const previewArgv = [process.execPath, process.argv[1], ...previewAgentArgs];
+        runDetached(previewArgv[0], previewArgv.slice(1));
     }
     if (opts.autoStart) {
         const robotArgv = await infinicodeArgv(args);
@@ -177,6 +201,14 @@ async function setupRobot(config, opts, ctx, internal) {
             args: robotArgv.slice(1),
         });
         console.log(reg.ok ? chalk.green(`  ✓ ${reg.message}`) : chalk.yellow(`  ⚠ ${reg.message}`));
+        const previewArgv = [process.execPath, process.argv[1], ...previewAgentArgs, '--foreground'];
+        const reg2 = await registerAutoStart({
+            role: 'robot-preview-agent',
+            name: internal.name,
+            command: previewArgv[0],
+            args: previewArgv.slice(1),
+        });
+        console.log(reg2.ok ? chalk.green(`  ✓ ${reg2.message}`) : chalk.yellow(`  ⚠ ${reg2.message}`));
     }
 }
 async function setupControl(config, opts, ctx, internal) {

package/dist/robopark/verify.d.ts

@@ -0,0 +1,6 @@
+export interface VerifyOptions {
+    schedulerUrl?: string;
+    robotId?: string;
+    token?: string;
+}
+export declare function roboparkVerify(opts: VerifyOptions): Promise<void>;

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-cli.js

@@ -17,7 +17,7 @@ const config = new Conf({
 });
 const program = new Command('robopark')
     .description('RoboPark fleet control CLI — set up, watch, and drive talking robots')
-    .version('2.8.7');
+    .version('2.8.9');
 program
     .command('scan')
     .description('Auto-discover the fleet and print ready-to-run setup commands')
@@ -31,6 +31,38 @@ program
         gateway: opts.gateway,
     });
 });
+program
+    .command('probe')
+    .description('Dispatch opencode agents across the mesh to map infrastructure')
+    .option('--token <token>', 'mesh auth token (optional, for context)')
+    .option('--timeout <sec>', 'seconds per node', '60')
+    .option('--output <file>', 'write JSON results to this file')
+    .option('--local', 'probe only this machine')
+    .action(async (opts) => {
+    const { roboparkProbe } = await import('./robopark/probe.js');
+    await roboparkProbe(opts);
+});
+program
+    .command('setup-livekit')
+    .description('Dispatch an opencode agent on the hub to install LiveKit server via Docker')
+    .option('--hub-url <url>', 'hub federation URL, e.g. http://100.64.1.2:47913')
+    .option('--token <token>', 'mesh auth token')
+    .option('--scheduler-url <url>', 'scheduler URL to register the new server, e.g. http://100.64.1.2:8080')
+    .option('--timeout <sec>', 'max seconds to wait for the agent', '180')
+    .option('--dry-run', 'print the prompt instead of dispatching')
+    .action(async (opts) => {
+    const { roboparkSetupLivekit } = await import('./robopark/setup-livekit.js');
+    await roboparkSetupLivekit(opts);
+});
+program
+    .command('verify')
+    .description('Verify the RoboPark fleet is ready for live preview')
+    .option('--scheduler-url <url>', 'scheduler base URL, e.g. http://livekit-1:8080')
+    .option('--robot-id <id>', 'robot name to verify (defaults to hostname)')
+    .action(async (opts) => {
+    const { roboparkVerify } = await import('./robopark/verify.js');
+    await roboparkVerify(opts);
+});
 program
     .command('serve')
     .description('Start the RoboPark scheduler + web UI')
@@ -44,6 +76,35 @@ program
     .action(async (opts) => {
     await roboparkServe(opts);
 });
+program
+    .command('enroll')
+    .description('Enroll this robot/satellite with the RoboPark scheduler')
+    .option('--scheduler-url <url>', 'scheduler base URL', 'http://localhost:8080')
+    .option('--robot-id <id>', 'robot/device name (defaults to hostname)')
+    .option('--enrollment-token <token>', 'one-time enrollment token (or ENV ENROLLMENT_TOKEN)')
+    .option('--save-config', 'write settings to ~/.robopark/preview_agent.json')
+    .action(async (opts) => {
+    const { roboparkEnroll } = await import('./robopark/enroll.js');
+    await roboparkEnroll(opts);
+});
+program
+    .command('preview-agent')
+    .description('Start the robot-side preview agent (camera + mic to scheduler)')
+    .option('--scheduler-url <url>', 'scheduler base URL', 'http://localhost:8080')
+    .option('--robot-id <id>', 'robot/device name (defaults to hostname)')
+    .option('--device-token <token>', 'long-lived device token')
+    .option('--enrollment-token <token>', 'one-time enrollment token')
+    .option('--video-device <dev>', 'camera: auto, /dev/video0, 0, picamera', 'auto')
+    .option('--audio-device <dev>', 'microphone: default, none, or name/index', 'default')
+    .option('--width <px>', 'video width', '640')
+    .option('--height <px>', 'video height', '480')
+    .option('--fps <n>', 'video fps', '15')
+    .option('--save-config', 'write settings to ~/.robopark/preview_agent.json')
+    .option('--foreground', 'stay in foreground; do not detach')
+    .action(async (opts) => {
+    const { roboparkPreviewAgent } = await import('./robopark/preview-agent-launcher.js');
+    await roboparkPreviewAgent(opts);
+});
 program
     .command('setup')
     .description('Set up this device in one pass')
@@ -61,6 +122,9 @@ program
     .option('--scheduler-port <port>', 'scheduler port on hub', '8080')
     .option('--tailscale-auth <token>', 'Tailscale auth key for the hub')
     .option('--tag <tag>', 'Tailscale tag filter')
+    .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('--start', 'launch the node now')
     .option('--auto-start', 'register to start on boot')
     .option('--yes', 'non-interactive mode')
@@ -82,6 +146,9 @@ program
         schedulerPort: opts.schedulerPort,
         tailscaleAuth: opts.tailscaleAuth,
         tag: opts.tag,
+        enrollmentToken: opts.enrollmentToken,
+        videoDevice: opts.videoDevice,
+        audioDevice: opts.audioDevice,
         start: opts.start,
         autoStart: opts.autoStart,
         yes: opts.yes,

package/package.json

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