robopark 2.8.36 → 3.0.0

package/dist/robopark/discovery.js

@@ -0,0 +1,180 @@
+/**
+ * RoboPark — auto-discovery helpers.
+ *
+ * Scans the environment so operators never type IPs, URLs, or tokens:
+ *   - Tailscale status → find the RoboPark hub and InfiniBot gateway
+ *   - LAN beacons → find robots
+ *   - Known config files → read Tailscale auth key, InfiniBot gateway token
+ *   - Running infinicode nodes → reuse mesh identity + token
+ */
+import { execa } from 'execa';
+import dgram from 'node:dgram';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+import { join } from 'node:path';
+const HUB_HINTS = /livekit|hub|scheduler|robopark/i;
+const GATEWAY_HINTS = /infinibot|gateway/i;
+const ROBOT_HINTS = /robo|panda|bear|car|dragon|frog|bmw/i;
+/** Best IPv4-ish address from a Tailscale peer. */
+function ipv4(peer) {
+    return (peer.TailscaleIPs ?? []).find(ip => ip.includes('.'));
+}
+/** Run `tailscale status --json` and parse. */
+export async function tailscaleStatus() {
+    try {
+        const { stdout } = await execa('tailscale', ['status', '--json'], { timeout: 5000 });
+        return JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+}
+/** Discover peers from Tailscale. */
+export async function discoverTailscale() {
+    const status = await tailscaleStatus();
+    if (!status?.Peer)
+        return [];
+    return Object.values(status.Peer)
+        .filter(p => p.Online)
+        .map(p => ({
+        name: p.HostName ?? p.DNSName?.split('.')[0] ?? 'unknown',
+        ip: ipv4(p) ?? 'unknown',
+        tags: p.Tags,
+        online: true,
+        source: 'tailscale',
+    }))
+        .filter(p => p.ip !== 'unknown');
+}
+/** Scan LAN UDP beacons on the default mesh discovery port. */
+export async function discoverLan(port = 47915, timeoutMs = 6000) {
+    return new Promise(resolve => {
+        const peers = new Map();
+        const socket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                socket.close();
+            }
+            catch { /* already closed */ }
+            resolve([...peers.values()]);
+        };
+        socket.on('message', (buffer, remote) => {
+            try {
+                const beacon = JSON.parse(buffer.toString('utf8'));
+                if (beacon.t !== 'ICMESH1' || !beacon.nodeId || !Number.isInteger(beacon.meshPort))
+                    return;
+                peers.set(beacon.nodeId, {
+                    name: beacon.name ?? beacon.nodeId,
+                    ip: remote.address,
+                    tags: beacon.tag ? [beacon.tag] : undefined,
+                    online: true,
+                    source: 'lan',
+                });
+            }
+            catch {
+                // Ignore unrelated UDP traffic on the discovery port.
+            }
+        });
+        socket.once('error', finish);
+        socket.bind({ port, exclusive: false });
+        setTimeout(finish, timeoutMs).unref();
+    });
+}
+/** Read a Tailscale auth key from common locations. */
+export function findTailscaleAuthKey() {
+    const paths = [
+        join(homedir(), '.robopark', 'tailscale.key'),
+        join(homedir(), '.config', 'robopark', 'tailscale.key'),
+        process.env.ROBOPARK_TAILSCALE_KEY ? '__env__' : undefined,
+    ].filter(Boolean);
+    for (const p of paths) {
+        if (p === '__env__')
+            return process.env.ROBOPARK_TAILSCALE_KEY;
+        if (existsSync(p)) {
+            const key = readFileSync(p, 'utf8').trim();
+            if (key.startsWith('tskey-'))
+                return key;
+        }
+    }
+    return undefined;
+}
+/** Read InfiniBot gateway config from common locations. */
+export function findInfinibotGateway() {
+    const candidates = [
+        join(homedir(), '.infinibot', 'config.json'),
+        join(homedir(), '.config', 'infinibot', 'config.json'),
+        join(homedir(), 'AppData', 'Roaming', 'infinibot', 'config.json'),
+    ];
+    for (const p of candidates) {
+        if (!existsSync(p))
+            continue;
+        try {
+            const cfg = JSON.parse(readFileSync(p, 'utf8'));
+            const gateway = cfg.gatewayUrl ?? cfg.gateway ?? cfg.gateway_url;
+            const token = cfg.gatewayToken ?? cfg.gateway_token ?? cfg.token;
+            if (typeof gateway === 'string') {
+                const u = new URL(gateway);
+                return { host: u.hostname, port: parseInt(u.port || '18789', 10), token: typeof token === 'string' ? token : undefined };
+            }
+        }
+        catch {
+            // ignore malformed
+        }
+    }
+    return undefined;
+}
+/** Read existing infinicode mesh token/port from config. */
+export function readInfinicodeFederation() {
+    const paths = [
+        join(homedir(), 'AppData', 'Roaming', 'infinicode-nodejs', 'Config', 'config.json'),
+        join(homedir(), '.config', 'infinicode-nodejs', 'config.json'),
+        join(homedir(), '.infinicode-nodejs', 'config.json'),
+    ];
+    for (const p of paths) {
+        if (!existsSync(p))
+            continue;
+        try {
+            const cfg = JSON.parse(readFileSync(p, 'utf8'));
+            return { token: cfg.federation?.token, port: cfg.federation?.port };
+        }
+        catch {
+            // ignore
+        }
+    }
+    return {};
+}
+/** Build the full discovered context for this environment. */
+export async function discoverContext(options = {}) {
+    const [tailnetPeers, lanPeers] = await Promise.all([
+        discoverTailscale(),
+        options.lan ? discoverLan() : Promise.resolve([]),
+    ]);
+    const peers = [...lanPeers, ...tailnetPeers];
+    // Exclude this machine from the fleet tables.
+    const selfName = hostname();
+    const others = peers.filter(p => p.name !== selfName && p.online);
+    const hub = others.find(p => HUB_HINTS.test(p.name));
+    const robots = others.filter(p => ROBOT_HINTS.test(p.name) || p.tags?.some(t => /robopark/i.test(t)));
+    const gateway = findInfinibotGateway();
+    const fed = readInfinicodeFederation();
+    return {
+        hub,
+        gateway,
+        robots,
+        tailscaleAuthKey: findTailscaleAuthKey(),
+        meshToken: fed.token,
+        meshPort: fed.port,
+        localName: hostname(),
+    };
+}
+/** Generate a random token for mesh auth or scheduler enrollment. */
+export function generateToken(length = 32) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let out = '';
+    for (let i = 0; i < length; i++)
+        out += chars[Math.floor(Math.random() * chars.length)];
+    return out;
+}

package/dist/robopark/doctor.js

@@ -0,0 +1,175 @@
+/**
+ * RoboPark — `robopark doctor`.
+ *
+ * A fast, all-in-one health check that replaces the manual curl-by-curl
+ * triage session: hub federation status, scheduler reachability, LiveKit
+ * server registration, device heartbeat freshness, and production mode.
+ *
+ * Usage:
+ *   robopark doctor
+ *   robopark doctor --hub-url http://100.64.1.2:47913 --scheduler-url http://100.64.1.2:8080
+ */
+import chalk from 'chalk';
+import { discoverContext } from './discovery.js';
+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();
+}
+const STALE_HEARTBEAT_MS = 60_000;
+function parseTimestamp(value) {
+    if (typeof value !== 'string' || !value)
+        return undefined;
+    // Scheduler stores naive UTC timestamps (no trailing 'Z'); normalize so
+    // Date.parse treats them as UTC instead of local time.
+    const iso = /[zZ]|[+-]\d\d:\d\d$/.test(value) ? value : `${value}Z`;
+    const ms = Date.parse(iso);
+    return Number.isNaN(ms) ? undefined : ms;
+}
+export async function roboparkDoctor(opts) {
+    const ctx = await discoverContext();
+    const hubUrl = (opts.hubUrl ?? (ctx.hub ? `http://${ctx.hub.ip}:47913` : 'http://localhost:47913')).replace(/\/$/, '');
+    const schedulerUrl = (opts.schedulerUrl ?? (ctx.hub ? `http://${ctx.hub.ip}:8080` : 'http://localhost:8080')).replace(/\/$/, '');
+    const authHeaders = opts.token ? { Authorization: `Bearer ${opts.token}` } : {};
+    console.log(chalk.bold('\n  robopark doctor'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  hub:       ${chalk.cyan(hubUrl)}`);
+    console.log(`  scheduler: ${chalk.cyan(schedulerUrl)}`);
+    console.log();
+    const checks = [];
+    // 1. Hub /fed/status reachable + connected nodes.
+    try {
+        const status = (await fetchJson(`${hubUrl}/fed/status`, { headers: authHeaders }));
+        const nodes = status.nodes ?? [];
+        const connected = nodes.filter(n => n.connected);
+        checks.push({
+            name: 'hub reachable',
+            status: 'pass',
+            message: `self=${status.self?.displayName ?? '?'} (${status.self?.role ?? '?'})`,
+        });
+        if (nodes.length === 0) {
+            checks.push({ name: 'mesh peers', status: 'warn', message: 'no peers known to this hub', detail: 'Nothing has joined the mesh yet, or this node has not discovered peers.' });
+        }
+        else if (connected.length === 0) {
+            checks.push({ name: 'mesh peers', status: 'fail', message: `${nodes.length} known peer(s), 0 connected`, detail: 'Check Tailscale connectivity and that peer processes are running.' });
+        }
+        else {
+            const list = connected.map(n => `${n.displayName ?? n.nodeId}(${n.role ?? '?'})`).join(', ');
+            checks.push({ name: 'mesh peers', status: 'pass', message: `${connected.length}/${nodes.length} connected — ${list}` });
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'hub reachable', status: 'fail', message: `could not reach ${hubUrl}/fed/status: ${e.message}`, detail: 'Is the hub node running? Is it on the same tailnet? Try --hub-url.' });
+    }
+    // 2. Scheduler /api/robots + /api/devices reachable.
+    let robots = [];
+    let devices = [];
+    try {
+        robots = (await fetchJson(`${schedulerUrl}/api/robots`));
+        checks.push({ name: 'scheduler /api/robots', status: 'pass', message: `${robots.length} robot(s)` });
+    }
+    catch (e) {
+        checks.push({ name: 'scheduler /api/robots', status: 'fail', message: `error: ${e.message}`, detail: 'Is robopark serve running? Check --scheduler-url.' });
+    }
+    try {
+        devices = (await fetchJson(`${schedulerUrl}/api/devices`));
+        checks.push({ name: 'scheduler /api/devices', status: 'pass', message: `${devices.length} device(s)` });
+    }
+    catch (e) {
+        checks.push({ name: 'scheduler /api/devices', status: 'fail', message: `error: ${e.message}` });
+    }
+    // 3. LiveKit servers registered + online.
+    try {
+        const servers = (await fetchJson(`${schedulerUrl}/api/servers`));
+        if (servers.length === 0) {
+            checks.push({ name: 'livekit servers', status: 'fail', message: 'no servers in scheduler', detail: 'Add one via the dashboard or robopark setup-livekit.' });
+        }
+        else {
+            for (const s of servers) {
+                const label = s.name ?? s.id;
+                if (!s.url) {
+                    checks.push({ name: `server ${label}`, status: 'fail', message: 'no url configured' });
+                }
+                else if (s.status === 'online') {
+                    checks.push({ name: `server ${label}`, status: 'pass', message: `online @ ${s.url}` });
+                }
+                else if (s.status === 'offline') {
+                    checks.push({ name: `server ${label}`, status: 'fail', message: `offline @ ${s.url}`, detail: 'Check that the LiveKit container/process is running and reachable.' });
+                }
+                else {
+                    checks.push({ name: `server ${label}`, status: 'warn', message: `status=${s.status ?? 'unknown'} @ ${s.url}` });
+                }
+            }
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'livekit servers', status: 'fail', message: `error: ${e.message}` });
+    }
+    // 4. Stale device heartbeats.
+    const now = Date.now();
+    const staleDevices = devices.filter(d => {
+        const hb = parseTimestamp(d.last_heartbeat);
+        return hb !== undefined && now - hb > STALE_HEARTBEAT_MS;
+    });
+    const noHeartbeatDevices = devices.filter(d => parseTimestamp(d.last_heartbeat) === undefined);
+    if (devices.length === 0) {
+        // covered by the /api/devices check above
+    }
+    else if (staleDevices.length === 0 && noHeartbeatDevices.length === 0) {
+        checks.push({ name: 'device heartbeats', status: 'pass', message: `all ${devices.length} device(s) heartbeating within ${STALE_HEARTBEAT_MS / 1000}s` });
+    }
+    else {
+        const parts = [];
+        if (staleDevices.length)
+            parts.push(`${staleDevices.length} stale: ${staleDevices.map(d => d.name ?? d.id).join(', ')}`);
+        if (noHeartbeatDevices.length)
+            parts.push(`${noHeartbeatDevices.length} never heartbeat: ${noHeartbeatDevices.map(d => d.name ?? d.id).join(', ')}`);
+        checks.push({ name: 'device heartbeats', status: 'warn', message: parts.join('; '), detail: 'Is robopark preview-agent (or the device process) running on those machines?' });
+    }
+    // 5. Production mode.
+    try {
+        const settings = (await fetchJson(`${schedulerUrl}/api/settings`));
+        if (settings.production_mode) {
+            checks.push({ name: 'production mode', status: 'pass', message: 'ON' });
+        }
+        else {
+            checks.push({ name: 'production mode', status: 'warn', message: 'OFF', detail: 'New device enrollment and preview sessions are blocked until production mode is ON (toggle in the dashboard or PUT /api/settings).' });
+        }
+        if (settings.default_enrollment_token_set === false) {
+            checks.push({ name: 'enrollment token', status: 'warn', message: 'no default enrollment token set', detail: 'Rotate one via POST /api/settings/enrollment-token/rotate before enrolling new devices.' });
+        }
+    }
+    catch (e) {
+        checks.push({ name: 'production mode', status: 'fail', message: `error: ${e.message}` });
+    }
+    // Print report.
+    let pass = 0;
+    let warn = 0;
+    let fail = 0;
+    for (const c of checks) {
+        const icon = c.status === 'pass' ? chalk.green('✓') : c.status === 'warn' ? chalk.yellow('⚠') : chalk.red('✗');
+        const color = c.status === 'pass' ? chalk.green : c.status === 'warn' ? chalk.yellow : chalk.red;
+        console.log(`  ${icon} ${color(c.name)} — ${c.message}`);
+        if (c.detail)
+            console.log(chalk.dim(`    → ${c.detail}`));
+        if (c.status === 'pass')
+            pass++;
+        else if (c.status === 'warn')
+            warn++;
+        else
+            fail++;
+    }
+    console.log();
+    const total = checks.length;
+    if (fail === 0 && warn === 0) {
+        console.log(chalk.bold.green(`  ${pass}/${total} checks passed — fleet is healthy.`));
+    }
+    else if (fail === 0) {
+        console.log(chalk.bold.yellow(`  ${pass}/${total} passed, ${warn} warning(s) — review the items above.`));
+    }
+    else {
+        console.log(chalk.bold.red(`  ${pass}/${total} passed, ${warn} warning(s), ${fail} failed — fix the items above.`));
+        process.exitCode = 1;
+    }
+}

package/dist/robopark/enroll.js

@@ -0,0 +1,68 @@
+/**
+ * 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';
+import { findPython, findSchedulerPath, prepareRobotPython } from './python-env.js';
+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 });
+}
+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 = prepareRobotPython(findPython(), script);
+    if (!python)
+        process.exit(1);
+    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/llm-set.js

@@ -0,0 +1,87 @@
+/**
+ * RoboPark — `robopark llm set`.
+ *
+ * Upserts LLM provider config into a ROBOVOICE .env file. ROBOVOICE lives in
+ * a separate repo, so the target .env path is always explicit (--env-path) —
+ * this command never guesses or writes infinicode's own config.
+ *
+ * Known keys (from ROBOVOICE's .env.example and src/caal/settings.py /
+ * src/caal/webhooks.py, which read OLLAMA_HOST and OLLAMA_MODEL):
+ *   LLM_PROVIDER   — "ollama" | "groq" (and whatever else ROBOVOICE adds)
+ *   OLLAMA_HOST    — Ollama server URL (only meaningful for ollama providers)
+ *   OLLAMA_MODEL   — Ollama model name (only meaningful for ollama providers)
+ *   OLLAMA_API_KEY — NOT currently read by ROBOVOICE. src/caal/llm/providers/
+ *                    ollama_provider.py constructs `ollama.Client(host=base_url)`
+ *                    with no api_key/auth support, and no OLLAMA_API_KEY lookup
+ *                    exists anywhere in src/caal. We still write the key (for
+ *                    forward-compat with Ollama Cloud, which needs an API key)
+ *                    but it is a no-op until ROBOVOICE's ollama_provider.py is
+ *                    updated to read it — see the gap noted in the CLI output.
+ */
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+/** true for any provider name that talks to an Ollama-compatible server. */
+function isOllamaProvider(provider) {
+    return provider === 'ollama' || provider === 'ollama-cloud';
+}
+/** Mask a secret so only the first/last 4 chars are visible, e.g. `abcd…wxyz`. */
+function maskSecret(value) {
+    if (value.length <= 8)
+        return '*'.repeat(value.length);
+    return `${value.slice(0, 4)}…${value.slice(-4)}`;
+}
+/** Replace an existing `KEY=...` line, or append a new one if absent. */
+function upsertEnvVar(lines, key, value) {
+    const pattern = new RegExp(`^${key}=`);
+    const idx = lines.findIndex(line => pattern.test(line));
+    const entry = `${key}=${value}`;
+    if (idx >= 0) {
+        lines[idx] = entry;
+        return lines;
+    }
+    return [...lines, entry];
+}
+export async function roboparkLlmSet(opts) {
+    if (!opts.envPath) {
+        console.log(chalk.red('  ✗ --env-path is required (points at the target ROBOVOICE .env file)'));
+        process.exit(1);
+    }
+    if (!existsSync(opts.envPath)) {
+        console.log(chalk.red(`  ✗ .env file not found: ${opts.envPath}`));
+        process.exit(1);
+    }
+    if (!opts.provider) {
+        console.log(chalk.red('  ✗ --provider is required (e.g. ollama, ollama-cloud, groq)'));
+        process.exit(1);
+    }
+    const raw = readFileSync(opts.envPath, 'utf8');
+    const hadTrailingNewline = raw.endsWith('\n');
+    let lines = raw.split('\n');
+    // Drop a single trailing empty entry produced by the final newline so we
+    // don't accumulate blank lines across repeated `llm set` runs.
+    if (hadTrailingNewline && lines[lines.length - 1] === '')
+        lines = lines.slice(0, -1);
+    lines = upsertEnvVar(lines, 'LLM_PROVIDER', opts.provider);
+    const ollama = isOllamaProvider(opts.provider);
+    if (ollama && opts.host)
+        lines = upsertEnvVar(lines, 'OLLAMA_HOST', opts.host);
+    if (ollama && opts.model)
+        lines = upsertEnvVar(lines, 'OLLAMA_MODEL', opts.model);
+    if (ollama && opts.apiKey)
+        lines = upsertEnvVar(lines, 'OLLAMA_API_KEY', opts.apiKey);
+    writeFileSync(opts.envPath, lines.join('\n') + (hadTrailingNewline ? '\n' : ''), 'utf8');
+    console.log(chalk.bold('\n  robopark llm set'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  file:     ${chalk.cyan(opts.envPath)}`);
+    console.log(`  provider: ${chalk.yellow(opts.provider)}`);
+    if (ollama && opts.host)
+        console.log(`  host:     ${chalk.cyan(opts.host)}`);
+    if (ollama && opts.model)
+        console.log(`  model:    ${chalk.cyan(opts.model)}`);
+    if (ollama && opts.apiKey) {
+        console.log(`  api key:  ${chalk.cyan(maskSecret(opts.apiKey))} ${chalk.dim('(masked)')}`);
+        console.log(chalk.yellow('  ⚠ note: ROBOVOICE\'s ollama_provider.py does not read OLLAMA_API_KEY yet —'));
+        console.log(chalk.yellow('    this value is written for forward-compat but is currently unused.'));
+    }
+    console.log(chalk.green('\n  ✓ .env updated\n'));
+}