infinicode 2.8.8 → 2.8.9

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

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

package/dist/robopark/enroll.d.ts

@@ -0,0 +1,7 @@
+export interface EnrollOptions {
+    schedulerUrl: string;
+    robotId?: string;
+    enrollmentToken?: string;
+    saveConfig?: boolean;
+}
+export declare function roboparkEnroll(opts: EnrollOptions): Promise<void>;

package/dist/robopark/enroll.js

@@ -0,0 +1,101 @@
+/**
+ * RoboPark — `robopark enroll`.
+ *
+ * Enrolls this machine as a scheduler device. Either uses an explicit
+ * enrollment token, or reads it from ~/.robopark/enrollment_token.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+import { join } from 'node:path';
+import chalk from 'chalk';
+const ROBOPARK_DIR = join(homedir(), '.robopark');
+const ENROLLMENT_FILE = join(ROBOPARK_DIR, 'enrollment_token');
+function ensureDir() {
+    mkdirSync(ROBOPARK_DIR, { recursive: true });
+}
+function readEnrollmentToken() {
+    if (existsSync(ENROLLMENT_FILE)) {
+        return readFileSync(ENROLLMENT_FILE, 'utf8').trim();
+    }
+    return undefined;
+}
+function saveEnrollmentToken(token) {
+    ensureDir();
+    writeFileSync(ENROLLMENT_FILE, token, { mode: 0o600 });
+}
+async function findSchedulerPath() {
+    const candidates = [
+        join(process.cwd(), 'packages', 'robopark', 'scheduler', 'preview_agent.py'),
+        join(process.cwd(), 'scheduler', 'preview_agent.py'),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p))
+            return p;
+    }
+    try {
+        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');
+        if (existsSync(p))
+            return p;
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function findPython() {
+    const names = process.platform === 'win32'
+        ? ['python', 'python3', 'py']
+        : ['python3', 'python'];
+    for (const name of names) {
+        try {
+            const { execSync } = require('node:child_process');
+            execSync(`${name} --version`, { stdio: 'ignore' });
+            return name;
+        }
+        catch {
+            continue;
+        }
+    }
+    return process.platform === 'win32' ? 'python' : 'python3';
+}
+export async function roboparkEnroll(opts) {
+    const token = opts.enrollmentToken ?? readEnrollmentToken();
+    if (!token) {
+        console.log(chalk.red('  ✗ pass --enrollment-token <token> or write it to ~/.robopark/enrollment_token'));
+        process.exit(1);
+    }
+    saveEnrollmentToken(token);
+    const robotId = opts.robotId ?? hostname().split('.')[0];
+    const schedulerUrl = opts.schedulerUrl;
+    const script = await findSchedulerPath();
+    if (!script) {
+        console.log(chalk.red('  ✗ could not find preview_agent.py'));
+        process.exit(1);
+    }
+    const python = findPython();
+    const args = [
+        script,
+        '--scheduler-url', schedulerUrl,
+        '--robot-id', robotId,
+        '--enrollment-token', token,
+    ];
+    if (opts.saveConfig)
+        args.push('--save-config');
+    console.log(chalk.bold('\n  robopark enroll'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  robot:     ${chalk.cyan(robotId)}`);
+    console.log(`  scheduler: ${chalk.cyan(schedulerUrl)}`);
+    console.log();
+    const proc = spawn(python, args, { stdio: 'inherit' });
+    await new Promise((resolve, reject) => {
+        proc.on('error', reject);
+        proc.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`enrollment exited ${code ?? ''}`));
+        });
+    });
+}

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

@@ -0,0 +1,14 @@
+export interface PreviewAgentOptions {
+    schedulerUrl: string;
+    robotId?: string;
+    deviceToken?: string;
+    enrollmentToken?: string;
+    videoDevice: string;
+    audioDevice: string;
+    width: string;
+    height: string;
+    fps: string;
+    saveConfig?: boolean;
+    foreground?: boolean;
+}
+export declare function roboparkPreviewAgent(opts: PreviewAgentOptions): Promise<void>;

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

@@ -0,0 +1,102 @@
+/**
+ * RoboPark — `robopark preview-agent` launcher.
+ *
+ * Starts preview_agent.py with the right Python interpreter, auto-discovers
+ * the scheduler URL from mesh/hub, and detaches unless --foreground.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { hostname } from 'node:os';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { discoverContext } from './discovery.js';
+const DEFAULT_SCHEDULER_PORT = 8080;
+async function findSchedulerPath() {
+    const candidates = [
+        join(process.cwd(), 'packages', 'robopark', 'scheduler', 'preview_agent.py'),
+        join(process.cwd(), 'scheduler', 'preview_agent.py'),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p))
+            return p;
+    }
+    try {
+        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');
+        if (existsSync(p))
+            return p;
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function findPython() {
+    const names = process.platform === 'win32'
+        ? ['python', 'python3', 'py']
+        : ['python3', 'python'];
+    for (const name of names) {
+        try {
+            const { execSync } = require('node:child_process');
+            execSync(`${name} --version`, { stdio: 'ignore' });
+            return name;
+        }
+        catch {
+            continue;
+        }
+    }
+    return process.platform === 'win32' ? 'python' : 'python3';
+}
+export async function roboparkPreviewAgent(opts) {
+    const ctx = await discoverContext();
+    const port = DEFAULT_SCHEDULER_PORT;
+    const schedulerUrl = opts.schedulerUrl !== 'http://localhost:8080'
+        ? opts.schedulerUrl
+        : ctx.hub
+            ? `http://${ctx.hub.ip}:${port}`
+            : 'http://localhost:8080';
+    const robotId = opts.robotId ?? hostname().split('.')[0];
+    const script = await findSchedulerPath();
+    if (!script) {
+        console.log(chalk.red('  ✗ could not find preview_agent.py'));
+        process.exit(1);
+    }
+    const python = findPython();
+    const args = [
+        script,
+        '--scheduler-url', schedulerUrl,
+        '--robot-id', robotId,
+        '--video-device', opts.videoDevice,
+        '--audio-device', opts.audioDevice,
+        '--width', opts.width,
+        '--height', opts.height,
+        '--fps', opts.fps,
+    ];
+    if (opts.deviceToken)
+        args.push('--device-token', opts.deviceToken);
+    if (opts.enrollmentToken)
+        args.push('--enrollment-token', opts.enrollmentToken);
+    if (opts.saveConfig)
+        args.push('--save-config');
+    console.log(chalk.bold('\n  robopark preview-agent'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  robot:     ${chalk.cyan(robotId)}`);
+    console.log(`  scheduler: ${chalk.cyan(schedulerUrl)}`);
+    console.log(`  video:     ${chalk.cyan(opts.videoDevice)}`);
+    console.log(`  audio:     ${chalk.cyan(opts.audioDevice)}`);
+    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_PREVIEW_AGENT: '1' },
+    });
+    proc.unref();
+    console.log(chalk.green('  ✓ preview agent started in background'));
+}

package/dist/robopark/probe.d.ts

@@ -0,0 +1,7 @@
+export interface ProbeOptions {
+    token?: string;
+    timeout?: string;
+    output?: string;
+    local?: boolean;
+}
+export declare function roboparkProbe(opts: ProbeOptions): Promise<void>;

package/dist/robopark/probe.js

@@ -0,0 +1,138 @@
+/**
+ * RoboPark — `robopark probe`.
+ *
+ * Spawn opencode agents (locally or over mesh) to build an accurate
+ * infrastructure map. Discovers peers via Tailscale, then runs a structured
+ * prompt through the locally installed `opencode` CLI for each node.
+ *
+ * The agent is asked only to report facts — it does not mutate anything.
+ */
+import { spawn } from 'node:child_process';
+import { hostname, networkInterfaces } from 'node:os';
+import chalk from 'chalk';
+import { discoverContext } from './discovery.js';
+function getLanIps() {
+    const out = [];
+    for (const [name, addrs] of Object.entries(networkInterfaces())) {
+        if (!addrs)
+            continue;
+        for (const a of addrs) {
+            if (a.family === 'IPv4' && !a.internal)
+                out.push(a.address);
+        }
+    }
+    return out;
+}
+function findOpencode() {
+    const names = process.platform === 'win32' ? ['opencode.exe', 'opencode'] : ['opencode'];
+    for (const name of names) {
+        try {
+            const { execSync } = require('node:child_process');
+            execSync(`${name} --version`, { stdio: 'ignore' });
+            return name;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function runOpencodePrompt(prompt, timeoutMs) {
+    const bin = findOpencode();
+    if (!bin)
+        return Promise.resolve('opencode CLI not found; install opencode to run probes');
+    return new Promise((resolve) => {
+        const proc = spawn(bin, ['--no-project', '--non-interactive'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, OPENCODE_QUIET: '1' },
+        });
+        let stdout = '';
+        let stderr = '';
+        let killed = false;
+        const timer = setTimeout(() => {
+            killed = true;
+            proc.kill('SIGTERM');
+        }, timeoutMs);
+        proc.stdin?.write(prompt);
+        proc.stdin?.end();
+        proc.stdout?.on('data', (d) => { stdout += d.toString(); });
+        proc.stderr?.on('data', (d) => { stderr += d.toString(); });
+        proc.on('close', () => {
+            clearTimeout(timer);
+            if (killed)
+                resolve(stdout + '\n[probe timed out]');
+            else
+                resolve(stdout || stderr || '(no output)');
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timer);
+            resolve(`opencode error: ${err.message}`);
+        });
+    });
+}
+function probePrompt(target, token) {
+    const tokenHint = token ? `mesh token is "${token}"` : 'no mesh token provided';
+    return `You are an infrastructure probe for the RoboPark fleet.
+Target node: ${target.name} (${target.ip}) via ${target.source}.
+${tokenHint}.
+
+Do NOT modify anything. Only report facts. Keep your answer under 600 words.
+
+Please report:
+1. Hostname, OS, architecture.
+2. LAN IPs and Tailscale IP if available.
+3. Whether these processes are running: infinicode node, robopark scheduler, robopark preview_agent.
+4. If this node is the hub, whether the scheduler at http://localhost:8080/api/settings responds and what production_mode is.
+5. If this node is a robot/satellite, whether it has enrolled to the scheduler and whether ~/.robopark/device_token exists.
+6. Any recent errors in journalctl/systemctl for infinicode or robopark services (last 10 lines).
+7. Whether a camera (/dev/video0) or microphone is detected.
+
+Answer as concise structured Markdown bullet list.`;
+}
+async function probeTarget(target, opts) {
+    const timeoutMs = opts.timeout ? parseInt(opts.timeout, 10) * 1000 : 60000;
+    try {
+        const summary = await runOpencodePrompt(probePrompt(target, opts.token), timeoutMs);
+        return { target, ok: true, summary, timestamp: new Date().toISOString() };
+    }
+    catch (e) {
+        return { target, ok: false, error: e.message, summary: '', timestamp: new Date().toISOString() };
+    }
+}
+export async function roboparkProbe(opts) {
+    const ctx = await discoverContext();
+    const self = { name: hostname().split('.')[0], ip: getLanIps()[0] || '127.0.0.1', source: 'self' };
+    const rawTargets = opts.local ? [self] : [self, ...(ctx.robots || []), ...(ctx.hub ? [ctx.hub] : [])];
+    const targets = rawTargets.map((t) => ({
+        name: t.name,
+        ip: t.ip,
+        source: t === self ? 'self' : 'tailscale',
+    }));
+    console.log(chalk.bold('\n  robopark probe'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  targets: ${chalk.cyan(targets.length)}`);
+    console.log();
+    const results = [];
+    for (const t of targets) {
+        process.stdout.write(chalk.dim(`  probing ${t.name}… `));
+        const r = await probeTarget(t, opts);
+        results.push(r);
+        console.log(r.ok ? chalk.green('ok') : chalk.red('failed'));
+    }
+    console.log();
+    console.log(chalk.bold('  Probe results'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    for (const r of results) {
+        console.log(`\n  ${chalk.cyan(r.target.name)} (${r.target.ip})`);
+        if (!r.ok) {
+            console.log(chalk.red(`    error: ${r.error}`));
+            continue;
+        }
+        console.log(r.summary.split('\n').map(l => '    ' + l).join('\n'));
+    }
+    if (opts.output) {
+        const { writeFileSync } = await import('node:fs');
+        writeFileSync(opts.output, JSON.stringify(results, null, 2), 'utf8');
+        console.log(`\n  ${chalk.green('✓')} wrote ${opts.output}`);
+    }
+}

package/dist/robopark/serve.js

@@ -108,6 +108,19 @@ export async function roboparkServe(opts) {
     const port = opts.port ? parseInt(opts.port, 10) : 8080;
     const host = opts.host ?? '0.0.0.0';
     const python = findPython();
+    const schedulerDir = dirname(schedulerPath);
+    const requirements = join(schedulerDir, 'requirements.txt');
+    // Ensure scheduler Python dependencies are installed before starting.
+    if (existsSync(requirements)) {
+        console.log(chalk.dim('  ensuring scheduler Python deps…'));
+        try {
+            execSync(`${python} -m pip install -r "${requirements}" --user --quiet`, { stdio: 'pipe' });
+        }
+        catch (err) {
+            console.log(chalk.yellow(`  ⚠ pip install failed: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(chalk.dim('    continuing; scheduler may fail if deps are missing.'));
+        }
+    }
     const env = {
         ...process.env,
         SCHEDULER_HOST: host,

package/dist/robopark/setup-livekit.d.ts

@@ -0,0 +1,8 @@
+export interface SetupLivekitOptions {
+    hubUrl?: string;
+    token?: string;
+    schedulerUrl?: string;
+    timeout?: string;
+    dryRun?: boolean;
+}
+export declare function roboparkSetupLivekit(opts: SetupLivekitOptions): Promise<void>;

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;