infinicode 2.8.8 → 2.8.10

package/dist/robopark/setup-livekit.js

@@ -0,0 +1,233 @@
+/**
+ * RoboPark — `robopark setup-livekit`.
+ *
+ * Dispatches an opencode agent over the mesh to install and start a LiveKit
+ * server on the fleet hub via Docker. After the agent reports success, the
+ * scheduler is told about the new LiveKit server.
+ *
+ * Usage:
+ *   robopark setup-livekit --hub-url http://HUB_IP:47913 --token <mesh_token>
+ *
+ * If --hub-url is omitted, the hub is discovered over Tailscale.
+ */
+import { readFileSync, 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 loadMeshToken() {
+    const paths = [
+        join(homedir(), '.robopark', 'mesh.token'),
+        join(homedir(), '.config', 'infinicode-nodejs', 'config.json'),
+        join(homedir(), '.infinicode-nodejs', 'config.json'),
+        join(homedir(), 'AppData', 'Roaming', 'infinicode-nodejs', 'Config', 'config.json'),
+    ];
+    for (const p of paths) {
+        if (!existsSync(p))
+            continue;
+        try {
+            if (p.endsWith('mesh.token'))
+                return readFileSync(p, 'utf8').trim();
+            const cfg = JSON.parse(readFileSync(p, 'utf8'));
+            if (cfg.federation?.token)
+                return cfg.federation.token;
+        }
+        catch { /* ignore */ }
+    }
+    return process.env.ROBOPARK_MESH_TOKEN;
+}
+function randId() {
+    return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function envelope(kind, from, data, opts = {}) {
+    return { v: 1, id: randId(), kind, from, to: opts.to, ts: Date.now(), auth: opts.auth, data };
+}
+async function meshRpc(targetUrl, token, env) {
+    const url = `${targetUrl.replace(/\/$/, '')}/fed/rpc?token=${encodeURIComponent(token)}`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(env),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`mesh RPC ${res.status}: ${text}`);
+    }
+    return (await res.json());
+}
+async function getHubNodeId(hubUrl, token) {
+    try {
+        const url = `${hubUrl.replace(/\/$/, '')}/fed/manifest?token=${encodeURIComponent(token)}`;
+        const res = await fetch(url, { headers: { accept: 'application/json' } });
+        if (!res.ok)
+            return null;
+        const manifest = (await res.json());
+        return manifest.nodeId || manifest.id || null;
+    }
+    catch {
+        return null;
+    }
+}
+const LIVEKIT_SETUP_PROMPT = `You are the RoboPark infrastructure agent running on the fleet hub.
+
+GOAL: Install and start a LiveKit server in Docker on this machine so the RoboPark scheduler can mint tokens and the robot preview agent can publish camera/audio.
+
+DO NOT ask the user for confirmation. Execute the steps directly. If a step is already done, skip it and report it.
+
+Steps:
+1. Check if Docker is installed and running. If not, install Docker (apt-get install docker.io on Debian/Ubuntu, or dnf install docker on Fedora, or use the official convenience script if needed) and start it with systemctl.
+2. Pull the official LiveKit server image: docker pull livekit/livekit-server:latest
+3. Create a directory /opt/livekit if it does not exist.
+4. Generate API credentials: run the LiveKit CLI container to create a key/secret and save them to /opt/livekit/keys.yaml:
+   docker run --rm livekit/livekit-server:latest generate-keys
+   Parse the output and write it as a YAML file with fields api_key and api_secret.
+5. Start the LiveKit server container with host networking on port 7880:
+   docker run -d --name livekit-server --restart unless-stopped --network host \
+     -v /opt/livekit/keys.yaml:/etc/livekit/keys.yaml:ro \
+     livekit/livekit-server:latest \
+     --config /etc/livekit/keys.yaml --bind 0.0.0.0 --port 7880
+6. Wait up to 30 seconds and verify it is healthy: curl -sf http://127.0.0.1:7880
+7. Report back the WebSocket URL (ws://THIS_MACHINE_TAILSCALE_IP:7880 or ws://127.0.0.1:7880), the api_key, the api_secret, and whether the container is running.
+
+IMPORTANT: this is a headless fleet node. Do not open a browser. Only run shell commands and report the final LiveKit URL + credentials in a JSON code block like:
+\`\`\`json
+{
+  "url": "ws://127.0.0.1:7880",
+  "api_key": "...",
+  "api_secret": "...",
+  "running": true
+}
+\`\`\`
+`;
+function extractJson(text) {
+    const m = text.match(/\`\`\`json\s*([\s\S]*?)\s*\`\`\`/);
+    if (!m)
+        return null;
+    try {
+        return JSON.parse(m[1]);
+    }
+    catch {
+        return null;
+    }
+}
+async function registerLiveKitServer(schedulerUrl, info) {
+    const url = `${schedulerUrl.replace(/\/$/, '')}/api/servers`;
+    const body = {
+        id: 'livekit-hub-docker',
+        name: 'LiveKit Hub Docker',
+        url: info.url,
+        webhook_url: info.url.replace(/^wss?/, 'http'),
+        api_key: info.api_key,
+        api_secret: info.api_secret,
+        gpu_name: 'none',
+        gpu_vram_mb: 0,
+        max_sessions: 8,
+        status: 'online',
+    };
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`register server failed ${res.status}: ${text}`);
+    }
+}
+export async function roboparkSetupLivekit(opts) {
+    const ctx = await discoverContext();
+    const hubUrl = opts.hubUrl ?? (ctx.hub ? `http://${ctx.hub.ip}:${ctx.meshPort ?? 47913}` : undefined);
+    const token = opts.token ?? ctx.meshToken ?? loadMeshToken();
+    const schedulerUrl = opts.schedulerUrl ?? (hubUrl ? hubUrl.replace(/:\d+$/, ':8080') : undefined);
+    const timeoutMs = (opts.timeout ? parseInt(opts.timeout, 10) : 180) * 1000;
+    if (!hubUrl) {
+        console.log(chalk.red('  ✗ no hub discovered. Pass --hub-url http://HUB_IP:47913'));
+        process.exit(1);
+    }
+    if (!token) {
+        console.log(chalk.red('  ✗ no mesh token. Pass --token or run robopark setup first.'));
+        process.exit(1);
+    }
+    console.log(chalk.bold('\n  robopark setup-livekit'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  hub:       ${chalk.cyan(hubUrl)}`);
+    console.log(`  scheduler: ${chalk.cyan(schedulerUrl ?? 'not provided')}`);
+    console.log();
+    if (opts.dryRun) {
+        console.log(chalk.yellow('  dry run — prompt that would be sent:'));
+        console.log(chalk.dim(LIVEKIT_SETUP_PROMPT.split('\n').map(l => '  ' + l).join('\n')));
+        return;
+    }
+    const from = hostname().split('.')[0];
+    const nodeId = await getHubNodeId(hubUrl, token);
+    if (!nodeId) {
+        console.log(chalk.red('  ✗ hub manifest not reachable. Is infinicode serve running on the hub?'));
+        process.exit(1);
+    }
+    console.log(chalk.dim(`  hub node id: ${nodeId}`));
+    const dispatchEnv = envelope('task.dispatch', from, {
+        description: 'Install LiveKit server on hub via Docker',
+        capabilities: ['shell', 'docker', 'reasoning'],
+        prompt: LIVEKIT_SETUP_PROMPT,
+        agent: 'opencode',
+        context: { role: 'hub', site: 'fleet-hub' },
+    }, { to: nodeId, auth: token });
+    console.log(chalk.dim('  dispatching opencode agent to hub…'));
+    const accepted = await meshRpc(hubUrl, token, dispatchEnv);
+    if (!accepted || accepted.kind !== 'task.accepted') {
+        const err = accepted?.data && typeof accepted.data === 'object' ? JSON.stringify(accepted.data) : 'unknown';
+        console.log(chalk.red(`  ✗ dispatch failed: ${err}`));
+        process.exit(1);
+    }
+    const { runId } = accepted.data;
+    console.log(chalk.dim(`  run id: ${runId}`));
+    const start = Date.now();
+    let lastStatus = null;
+    let result = null;
+    while (Date.now() - start < timeoutMs) {
+        await new Promise(r => setTimeout(r, 3000));
+        const statusEnv = envelope('task.status', from, { runId }, { to: nodeId, auth: token });
+        result = await meshRpc(hubUrl, token, statusEnv);
+        const rec = (result?.data ?? {});
+        if (rec.status !== lastStatus) {
+            lastStatus = rec.status ?? null;
+            console.log(`  status: ${chalk.cyan(rec.status ?? 'unknown')}${rec.error ? chalk.red(` — ${rec.error}`) : ''}`);
+        }
+        if (rec.status === 'completed' || rec.status === 'failed')
+            break;
+    }
+    if (!result) {
+        console.log(chalk.red('  ✗ no response from hub'));
+        process.exit(1);
+    }
+    const rec = result.data;
+    if (rec.status !== 'completed') {
+        console.log(chalk.red(`  ✗ LiveKit setup failed: ${rec.error || 'unknown'}`));
+        if (rec.outputs)
+            console.log(chalk.dim(JSON.stringify(rec.outputs, null, 2)));
+        process.exit(1);
+    }
+    const content = rec.outputs?.map(o => o.content).filter(Boolean).join('\n') || '';
+    const parsed = extractJson(content);
+    if (!parsed || !parsed.url || !parsed.api_key || !parsed.api_secret) {
+        console.log(chalk.yellow('  ⚠ agent finished but did not return LiveKit credentials in a JSON block'));
+        console.log(chalk.dim(content));
+        process.exit(1);
+    }
+    console.log(chalk.green('  ✓ LiveKit server reported running'));
+    console.log(`    url:  ${chalk.cyan(String(parsed.url))}`);
+    console.log(`    key:  ${chalk.cyan(String(parsed.api_key))}`);
+    if (schedulerUrl) {
+        try {
+            await registerLiveKitServer(schedulerUrl, {
+                url: String(parsed.url),
+                api_key: String(parsed.api_key),
+                api_secret: String(parsed.api_secret),
+            });
+            console.log(chalk.green(`  ✓ registered LiveKit server with scheduler`));
+        }
+        catch (e) {
+            console.log(chalk.yellow(`  ⚠ could not register with scheduler: ${e.message}`));
+        }
+    }
+}

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.8');
+    .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.8",
+  "version": "2.8.10",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",

package/packages/robopark/scheduler/Dockerfile

@@ -3,7 +3,12 @@ FROM python:3.11-slim
 
 WORKDIR /app
 
-# Install dependencies
+# Install build dependencies for pyaudio / opencv wheels, then Python packages.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc g++ libportaudio2 portaudio19-dev \
+    libgl1 libglib2.0-0 libsm6 libxext6 libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt