infinicode 2.3.6 → 2.5.0

package/dist/commands/robopark.js

@@ -0,0 +1,450 @@
+/**
+ * robopark — the RoboPark fleet control CLI.
+ *
+ * A thin operator layer that rides the infinicode mesh instead of SSH-ing around:
+ *
+ *   robopark setup --role scheduler --hub http://100.x:47913 --start
+ *   robopark fleet                 # live table of every node the hub can see
+ *   robopark run panda-a /status   # run a command on one node
+ *   robopark apply                 # push shared config (providers/policy) to the fleet
+ *   robopark dashboard --open      # open the web control UI
+ *
+ * `setup` writes this device's role + mesh config (the nine manual steps,
+ * automated). The other verbs talk to a running node's HTTP API (default the
+ * local node at 127.0.0.1:<port>), so the CLI never needs its own transport —
+ * it reuses the mesh the node already stood up.
+ */
+import chalk from 'chalk';
+import { spawn } from 'node:child_process';
+import { saveRole } from '../kernel/federation/role-context.js';
+import { serve } from './serve.js';
+const DEFAULT_PORT = 47913;
+function nodeUrl(config, urlOpt) {
+    if (urlOpt)
+        return urlOpt.replace(/\/+$/, '');
+    const fed = (config.get('federation') ?? {});
+    return `http://127.0.0.1:${fed.port ?? DEFAULT_PORT}`;
+}
+function authToken(config, tokenOpt) {
+    const fed = (config.get('federation') ?? {});
+    return tokenOpt ?? fed.token;
+}
+function headers(token) {
+    const h = { 'content-type': 'application/json' };
+    if (token)
+        h['authorization'] = `Bearer ${token}`;
+    return h;
+}
+async function getStatus(url, token) {
+    const res = await fetch(`${url}/fed/status`, { headers: headers(token), signal: AbortSignal.timeout(6000) });
+    if (res.status === 401)
+        throw new Error('unauthorized — this node requires a token (pass --token <secret>)');
+    if (!res.ok)
+        throw new Error(`node returned ${res.status}`);
+    return (await res.json());
+}
+function unreachable(url, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+        chalk.red(`  ✗ no mesh node reachable at ${url}`),
+        chalk.dim(`    ${msg}`),
+        chalk.dim('    start one with  infinicode serve --dashboard   or   robopark setup --start'),
+    ].join('\n');
+}
+// ── loadbar / formatting helpers ───────────────────────────────────────────────
+function bar(pct, width = 10) {
+    const v = Math.max(0, Math.min(100, Math.round(pct)));
+    const filled = Math.round((v / 100) * width);
+    const glyph = '█'.repeat(filled) + '░'.repeat(width - filled);
+    const color = v >= 80 ? chalk.red : v >= 50 ? chalk.yellow : chalk.green;
+    return color(glyph);
+}
+function pad(s, n) {
+    const len = [...s].length;
+    return len >= n ? s : s + ' '.repeat(n - len);
+}
+/** Pad the visible text to `width`, THEN colorize — so ANSI codes never count
+ *  toward column width (the bug you get from padding an already-colored string). */
+function cell(text, width, color) {
+    const p = pad(text, width);
+    return color ? color(p) : p;
+}
+function renderFleet(snap) {
+    const nodes = snap.nodes ?? [];
+    const lines = [];
+    const up = nodes.filter(n => n.connected).length;
+    const runs = (snap.runs ?? []).filter(r => r.status === 'running').length;
+    lines.push('');
+    lines.push(chalk.bold('  RoboPark fleet') + chalk.dim(`   ${up}/${nodes.length} up · ${runs} active run${runs === 1 ? '' : 's'}`));
+    lines.push(chalk.dim('  ' + '─'.repeat(72)));
+    if (!nodes.length) {
+        lines.push(chalk.dim('  no nodes reporting yet — bring peers online with `infinicode serve`.'));
+        return lines.join('\n');
+    }
+    const W = { name: 22, role: 11, state: 8, load: 16, site: 12 };
+    lines.push('  ' +
+        chalk.dim(pad('NODE', W.name) + pad('ROLE', W.role) + pad('STATE', W.state) + pad('LOAD', W.load) + pad('SITE', W.site) + 'VER'));
+    nodes.sort((a, b) => Number(b.connected) - Number(a.connected));
+    for (const n of nodes) {
+        const isSelf = snap.self && snap.self.nodeId === n.nodeId;
+        const name = n.displayName + (isSelf ? ' ‹this›' : '');
+        const state = cell(n.connected ? '● up' : '○ down', W.state, n.connected ? chalk.green : chalk.dim);
+        // LOAD: colored bar (fixed 10 visible glyphs) + percent, hand-padded so the
+        // bar's ANSI codes don't skew the column.
+        let load;
+        if (n.connected) {
+            const pct = `${Math.round(n.load ?? 0)}%`;
+            const visible = 10 + 1 + pct.length; // bar + space + "NN%"
+            load = `${bar(n.load ?? 0)} ${pct}` + ' '.repeat(Math.max(0, W.load - visible));
+        }
+        else {
+            load = cell('—', W.load, chalk.dim);
+        }
+        lines.push('  ' +
+            cell(name, W.name, isSelf ? chalk.bold.cyan : chalk.bold) +
+            cell(n.role, W.role, chalk.yellow) +
+            state +
+            load +
+            cell(n.site ?? '-', W.site, n.site ? undefined : chalk.dim) +
+            chalk.dim('v' + (n.version ?? '?')));
+    }
+    return lines.join('\n');
+}
+const ROLE_PRESETS = {
+    scheduler: { mesh: 'hub', blurb: 'on-site hub (LiveKit Server 1) — bridges tailnet ↔ LAN, serves the dashboard', dashboard: true, lan: true, tailscale: true },
+    robot: { mesh: 'satellite', blurb: 'a robot Pi — accept-only, LAN-discovered, never dials out', dashboard: false, lan: true, tailscale: false },
+    laptop: { mesh: 'peer', blurb: 'your control station — drives the fleet over the mesh', dashboard: false, lan: false, tailscale: true },
+    relay: { mesh: 'relay', blurb: 'a relay hop between two networks', dashboard: false, lan: true, tailscale: true },
+};
+// Power users can pass raw mesh roles too; fold them onto the matching preset.
+const MESH_ALIASES = { hub: 'scheduler', satellite: 'robot', peer: 'laptop' };
+function resolveRole(input) {
+    if (!input)
+        return null;
+    const key = input.toLowerCase();
+    const label = MESH_ALIASES[key] ?? key;
+    const preset = ROLE_PRESETS[label];
+    return preset ? { label, preset } : null;
+}
+/** Interactive fallback — the streamlined "just run `robopark setup`" path. */
+async function setupWizard(opts) {
+    const inquirer = (await import('inquirer')).default;
+    const a = (await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'role',
+            message: 'What is this device?',
+            choices: [
+                { name: 'scheduler  — the on-site hub (LiveKit Server 1)', value: 'scheduler' },
+                { name: 'robot      — a talking-robot Raspberry Pi', value: 'robot' },
+                { name: 'laptop     — your control station (drives the fleet)', value: 'laptop' },
+            ],
+            default: opts.robot ? 'robot' : opts.laptop ? 'laptop' : 'scheduler',
+        },
+        { type: 'input', name: 'name', message: 'Name for this device:', default: opts.name },
+        { type: 'input', name: 'site', message: 'Site / location (optional):', default: opts.site ?? '' },
+        {
+            type: 'input',
+            name: 'hub',
+            message: 'Hub URL to join (blank if this IS the scheduler):',
+            default: opts.hub ?? '',
+            when: (ans) => ans.role !== 'scheduler',
+        },
+        {
+            type: 'input',
+            name: 'gateway',
+            message: 'InfiniBot gateway ws:// URL (optional — surfaces the fleet in InfiniBot):',
+            default: opts.gateway ?? '',
+            when: (ans) => ans.role === 'scheduler',
+        },
+        { type: 'input', name: 'token', message: 'Shared token every device presents (optional but recommended):', default: opts.token ?? '' },
+        { type: 'confirm', name: 'start', message: 'Start the node now?', default: true },
+    ]));
+    return {
+        ...opts,
+        role: a.role,
+        name: a.name || opts.name,
+        site: a.site || undefined,
+        hub: a.hub || opts.hub,
+        gateway: a.gateway || opts.gateway,
+        token: a.token || opts.token,
+        start: a.start,
+    };
+}
+async function roboparkSetup(config, opts) {
+    // Shorthand flags → --role.
+    const roleInput = opts.role ?? (opts.scheduler ? 'scheduler' : opts.robot ? 'robot' : opts.laptop ? 'laptop' : undefined);
+    // No role given? Run the guided wizard in a TTY (unless --yes); otherwise error.
+    if (!roleInput && !opts.yes) {
+        if (process.stdin.isTTY) {
+            opts = await setupWizard(opts);
+        }
+        else {
+            console.log(chalk.red('  robopark setup: pass --scheduler | --robot | --laptop (or --role <role>)'));
+            return;
+        }
+    }
+    const resolved = resolveRole(opts.role ?? roleInput ?? 'laptop');
+    if (!resolved) {
+        console.log(chalk.red(`  unknown role "${opts.role}". Use: scheduler | robot | laptop | relay`));
+        return;
+    }
+    const { label, preset } = resolved;
+    const meshRole = preset.mesh;
+    // Preset defaults, overridable by explicit flags.
+    const dashboard = opts.dashboard ?? preset.dashboard;
+    const lan = opts.lan ?? preset.lan;
+    const tailscale = opts.tailscale ?? (preset.tailscale && !opts.hub); // seed URL replaces discovery
+    const port = opts.port ? parseInt(opts.port, 10) : DEFAULT_PORT;
+    const prev = (config.get('federation') ?? {});
+    const fed = {
+        ...prev,
+        enabled: true,
+        role: meshRole,
+        port,
+        displayName: opts.name ?? prev.displayName,
+        token: opts.token ?? prev.token,
+        seeds: opts.hub ? Array.from(new Set([...(prev.seeds ?? []), opts.hub])) : prev.seeds,
+        lan,
+    };
+    config.set('federation', fed);
+    // Persist the device's role/site brief — injected into every task run here.
+    const roleCtx = saveRole({
+        role: opts.name ?? label,
+        site: opts.site,
+        architecture: opts.architecture,
+    });
+    console.log(chalk.bold('\n  robopark setup'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  device: ${chalk.yellow(label)} ${chalk.dim('→ mesh role ' + meshRole)}`);
+    console.log(chalk.dim(`          ${preset.blurb}`));
+    console.log(`  name:   ${chalk.cyan(opts.name ?? '(hostname)')}${opts.site ? chalk.dim('  @ ' + opts.site) : ''}`);
+    console.log(`  listen: ${chalk.cyan('0.0.0.0:' + port)}`);
+    if (opts.hub)
+        console.log(`  hub:    ${chalk.cyan(opts.hub)}`);
+    if (fed.token)
+        console.log(`  auth:   ${chalk.green('token set')}`);
+    if (lan)
+        console.log(`  lan:    ${chalk.green('auto-discovery on')}`);
+    if (tailscale)
+        console.log(`  tailnet:${chalk.green(' discovery on')}${opts.tag ? chalk.dim(' · tag ' + opts.tag) : ''}`);
+    if (dashboard)
+        console.log(`  ui:     ${chalk.green('dashboard on')}`);
+    console.log();
+    const serveOpts = {
+        role: meshRole,
+        name: opts.name,
+        port: String(port),
+        token: fed.token,
+        seed: opts.hub ? [opts.hub] : undefined,
+        tailscale,
+        lan,
+        tag: opts.tag,
+        dashboard,
+        gateway: opts.gateway,
+        gatewayToken: opts.gatewayToken,
+    };
+    if (opts.start) {
+        console.log(chalk.dim('  starting node…\n'));
+        await serve(config, serveOpts);
+        return;
+    }
+    const startCmd = [
+        'infinicode serve',
+        `--role ${meshRole}`,
+        dashboard ? '--dashboard' : '',
+        lan ? '--lan' : '',
+        tailscale ? '--tailscale' : '',
+        opts.tag ? `--tag ${opts.tag}` : '',
+        opts.hub ? `--seed ${opts.hub}` : '',
+        fed.token ? `--token ${fed.token}` : '',
+        opts.gateway ? `--gateway ${opts.gateway}` : '',
+    ]
+        .filter(Boolean)
+        .join(' ');
+    console.log(chalk.dim('  saved. start it now with:  ') + chalk.cyan('robopark setup --' + label + ' --start'));
+    console.log(chalk.dim('  or run the node directly:   ') + chalk.cyan(startCmd));
+    console.log();
+}
+async function roboparkFleet(config, opts) {
+    const url = nodeUrl(config, opts.url);
+    const token = authToken(config, opts.token);
+    const once = async () => {
+        let snap;
+        try {
+            snap = await getStatus(url, token);
+        }
+        catch (err) {
+            console.log(unreachable(url, err));
+            return false;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(snap, null, 2));
+        }
+        else {
+            if (opts.watch)
+                process.stdout.write('\x1b[2J\x1b[H');
+            console.log(renderFleet(snap));
+            if (opts.watch)
+                console.log(chalk.dim(`\n  updated ${new Date().toLocaleTimeString()} · Ctrl-C to stop`));
+        }
+        return true;
+    };
+    if (!opts.watch) {
+        await once();
+        return;
+    }
+    const ok = await once();
+    if (!ok)
+        return; // don't spin on an unreachable node
+    const timer = setInterval(() => void once(), 2000);
+    await new Promise(resolve => {
+        process.on('SIGINT', () => {
+            clearInterval(timer);
+            resolve();
+        });
+    });
+}
+async function roboparkRun(config, node, command, opts) {
+    const url = nodeUrl(config, opts.url);
+    const token = authToken(config, opts.token);
+    const cmd = command.join(' ').trim();
+    if (!cmd) {
+        console.log(chalk.red('  nothing to run — usage: robopark run <node> <command…>'));
+        return;
+    }
+    // Local node keywords bypass the /node dispatch wrapper.
+    const local = ['.', 'self', 'local', 'here'].includes(node.toLowerCase());
+    const input = local ? (cmd.startsWith('/') ? cmd : `/${cmd}`) : `/node ${node} ${cmd}`;
+    try {
+        const res = await fetch(`${url}/fed/command`, {
+            method: 'POST',
+            headers: headers(token),
+            body: JSON.stringify({ input }),
+            signal: AbortSignal.timeout(120_000),
+        });
+        const body = (await res.json().catch(() => ({ ok: false, text: `HTTP ${res.status}` })));
+        const text = body.text ?? JSON.stringify(body);
+        console.log(body.ok === false ? chalk.yellow(text) : text);
+    }
+    catch (err) {
+        console.log(unreachable(url, err));
+    }
+}
+async function roboparkApply(config, opts) {
+    const url = nodeUrl(config, opts.url);
+    const token = authToken(config, opts.token);
+    try {
+        const res = await fetch(`${url}/fed/apply`, {
+            method: 'POST',
+            headers: headers(token),
+            body: '{}',
+            signal: AbortSignal.timeout(15_000),
+        });
+        const body = (await res.json().catch(() => ({ ok: false, text: `HTTP ${res.status}` })));
+        console.log((body.ok === false ? chalk.yellow : chalk.green)('  ' + (body.text ?? 'applied')));
+    }
+    catch (err) {
+        console.log(unreachable(url, err));
+    }
+}
+function openBrowser(url) {
+    const platform = process.platform;
+    const cmd = platform === 'win32' ? 'cmd' : platform === 'darwin' ? 'open' : 'xdg-open';
+    const args = platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    try {
+        spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+    }
+    catch {
+        /* fall back to just printing */
+    }
+}
+async function roboparkDashboard(config, opts) {
+    const base = nodeUrl(config, opts.url);
+    const token = authToken(config, opts.token);
+    const link = `${base}/${token ? `?token=${encodeURIComponent(token)}` : ''}`;
+    // Confirm the node is actually serving the dashboard before pointing there.
+    try {
+        const res = await fetch(link, { headers: headers(token), signal: AbortSignal.timeout(5000) });
+        if (res.status === 404) {
+            console.log(chalk.yellow(`  ⚠ node at ${base} is up but the dashboard is off.`));
+            console.log(chalk.dim('    restart it with  infinicode serve --dashboard'));
+            return;
+        }
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+    }
+    catch (err) {
+        console.log(unreachable(base, err));
+        return;
+    }
+    console.log(chalk.bold('\n  RoboPark control dashboard'));
+    console.log('  ' + chalk.cyan(link) + '\n');
+    if (opts.open)
+        openBrowser(link);
+}
+// ── wiring ─────────────────────────────────────────────────────────────────────
+/** Attach the robopark verbs to a Commander command (the `robopark` program in
+ *  the standalone bin, or the `infinicode robopark` group). */
+export function attachRoboparkSubcommands(cmd, config) {
+    cmd
+        .command('setup')
+        .description('Set up this device in one pass. Run bare for a guided wizard, or pass a role to skip it.')
+        .option('--scheduler', 'this device is the on-site hub (LiveKit Server 1)')
+        .option('--robot', 'this device is a talking-robot Raspberry Pi')
+        .option('--laptop', 'this device is your control station')
+        .option('--role <role>', 'explicit role: scheduler | robot | laptop | relay (or raw mesh role hub/peer/satellite)')
+        .option('--site <site>', 'physical location for fleet grouping, e.g. "Tel Aviv"')
+        .option('--name <name>', 'friendly device name (defaults to hostname)')
+        .option('--hub <url>', 'hub base URL to join, e.g. http://100.x.y.z:47913 (robots/laptops)')
+        .option('--gateway <url>', 'InfiniBot gateway ws:// URL to surface the fleet in InfiniBot (scheduler)')
+        .option('--gateway-token <token>', 'auth token for the InfiniBot gateway')
+        .option('--token <token>', 'shared bearer token every device must present')
+        .option('--port <port>', 'mesh listen port (default 47913)')
+        .option('--tag <tag>', 'only discover peers carrying this tag (e.g. tag:robopark)')
+        .option('--architecture <text>', "one-line brief of this device's job in the wider system")
+        .option('--lan', 'force zero-config LAN auto-discovery (on by default for scheduler/robot)')
+        .option('--tailscale', 'force Tailscale peer discovery (on by default for scheduler/laptop)')
+        .option('--dashboard', 'force the web control UI (on by default for scheduler)')
+        .option('--start', 'launch the node now instead of just writing config')
+        .option('--yes', 'skip the guided wizard even with no role (non-interactive)')
+        .action(async (opts) => {
+        await roboparkSetup(config, opts);
+    });
+    cmd
+        .command('fleet')
+        .alias('status')
+        .description('Show every node the local (or a given) mesh node can see')
+        .option('--url <url>', 'node HTTP base to query (default the local node)')
+        .option('--token <token>', 'bearer token if the node requires auth')
+        .option('--watch', 'refresh the table every 2s until Ctrl-C')
+        .option('--json', 'print the raw status snapshot as JSON')
+        .action(async (opts) => {
+        await roboparkFleet(config, opts);
+    });
+    cmd
+        .command('run <node> <command...>')
+        .description('Run a slash-command on a node (use "." for the local node), e.g. robopark run panda-a /status')
+        .option('--url <url>', 'node HTTP base to send through (default the local node)')
+        .option('--token <token>', 'bearer token if the node requires auth')
+        .action(async (node, command, opts) => {
+        await roboparkRun(config, node, command, opts);
+    });
+    cmd
+        .command('apply')
+        .description('Publish this hub\'s shared config (providers, keys, policy) to every satellite')
+        .option('--url <url>', 'node HTTP base to apply through (default the local node)')
+        .option('--token <token>', 'bearer token if the node requires auth')
+        .action(async (opts) => {
+        await roboparkApply(config, opts);
+    });
+    cmd
+        .command('dashboard')
+        .description('Print (and optionally open) the web control dashboard URL')
+        .option('--url <url>', 'node HTTP base (default the local node)')
+        .option('--token <token>', 'bearer token if the node requires auth')
+        .option('--open', 'open the dashboard in the default browser')
+        .action(async (opts) => {
+        await roboparkDashboard(config, opts);
+    });
+}

package/dist/commands/serve.d.ts

@@ -17,5 +17,10 @@ export interface ServeOptions {
     gateway?: string;
     gatewayToken?: string;
     gatewayPassword?: string;
+    dashboard?: boolean;
+    schedulerUrl?: string;
+    schedulerToken?: string;
+    tlsCert?: string;
+    tlsKey?: string;
 }
 export declare function serve(config: Conf<InfinicodeConfig>, opts: ServeOptions): Promise<void>;