infinicode 2.7.0 → 2.8.0

package/dist/robopark/scan.js

@@ -0,0 +1,97 @@
+/**
+ * RoboPark — `robopark scan`.
+ *
+ * Scans Tailscale + LAN + local config and emits ready-to-run setup commands
+ * for every machine in the fleet. No manual IP/token typing.
+ */
+import chalk from 'chalk';
+import { discoverContext, generateToken } from './discovery.js';
+function hubCommand(ctx, opts) {
+    const name = ctx.hub?.name ?? 'livekit-1';
+    const site = 'Tel Aviv'; // TODO: discover from role context or prompt
+    const token = opts.token ?? ctx.meshToken ?? generateToken();
+    const gw = opts.gateway !== false ? ctx.gateway : undefined;
+    const parts = [
+        'robopark setup --hub',
+        `--name ${name}`,
+        `--site "${site}"`,
+        `--token ${token}`,
+        '--start',
+        '--auto-start',
+    ];
+    if (ctx.tailscaleAuthKey)
+        parts.push(`--tailscale-auth ${ctx.tailscaleAuthKey}`);
+    if (gw)
+        parts.push(`--gateway ws://${gw.host}:${gw.port}`, `--gateway-token ${gw.token ?? 'SET_TOKEN'}`);
+    return parts.join(' ');
+}
+function robotCommand(robot, ctx, opts) {
+    const token = opts.token ?? ctx.meshToken ?? generateToken();
+    const hubUrl = ctx.hub ? `http://${ctx.hub.ip}:47913` : 'http://HUB_IP:47913';
+    const parts = [
+        'robopark setup --robot',
+        `--name ${robot.name}`,
+        `--hub-url ${hubUrl}`,
+        `--token ${token}`,
+        '--start',
+        '--auto-start',
+    ];
+    if (ctx.tailscaleAuthKey)
+        parts.push(`--tailscale-auth ${ctx.tailscaleAuthKey}`);
+    return parts.join(' ');
+}
+function controlCommand(ctx, opts) {
+    const token = opts.token ?? ctx.meshToken ?? generateToken();
+    const hubUrl = ctx.hub ? `http://${ctx.hub.ip}:47913` : 'http://HUB_IP:47913';
+    const parts = [
+        'robopark setup --control',
+        `--hub-url ${hubUrl}`,
+        `--token ${token}`,
+        '--start',
+        '--auto-start',
+    ];
+    return parts.join(' ');
+}
+export async function roboparkScan(opts = {}) {
+    console.log(chalk.bold('\n  robopark scan — auto-discovering your fleet\n'));
+    const ctx = await discoverContext();
+    if (!ctx.hub) {
+        console.log(chalk.yellow('  ⚠ no hub found on Tailscale. Look for a machine named like livekit-* / hub / scheduler.'));
+        console.log(chalk.dim('    make sure the hub box is online and tagged, or run `robopark setup --hub` on it first.'));
+    }
+    else {
+        console.log(`  ${chalk.green('✓')} hub found: ${chalk.cyan(ctx.hub.name)} @ ${chalk.cyan(ctx.hub.ip)}`);
+    }
+    if (!ctx.gateway) {
+        console.log(chalk.dim('  · no InfiniBot gateway discovered (set one with --gateway or INFINIBOT_GATEWAY env)'));
+    }
+    else {
+        console.log(`  ${chalk.green('✓')} gateway found: ${chalk.cyan(`${ctx.gateway.host}:${ctx.gateway.port}`)}`);
+    }
+    if (!ctx.robots.length) {
+        console.log(chalk.dim('  · no robots discovered yet. They will LAN-join after the hub is running.'));
+    }
+    else {
+        console.log(`  ${chalk.green('✓')} ${ctx.robots.length} robot(s) found:`);
+        for (const r of ctx.robots)
+            console.log(`    · ${chalk.cyan(r.name)} @ ${chalk.cyan(r.ip)}`);
+    }
+    const token = opts.token ?? ctx.meshToken ?? generateToken();
+    console.log(`\n  ${chalk.green('✓')} using mesh token: ${chalk.cyan(token)}`);
+    console.log(chalk.dim('    save it with: echo "${TOKEN}" > ~/.robopark/mesh.token'));
+    console.log(chalk.bold('\n  Generated setup commands:\n'));
+    console.log(chalk.dim('  # on the hub box'));
+    console.log('  ' + chalk.cyan(hubCommand(ctx, opts)));
+    console.log();
+    console.log(chalk.dim('  # on each robot'));
+    for (const r of ctx.robots) {
+        console.log('  ' + chalk.cyan(robotCommand(r, ctx, opts)));
+    }
+    if (!ctx.robots.length) {
+        console.log('  ' + chalk.cyan(robotCommand({ name: 'robobmw', ip: 'HUB_IP', online: true, source: 'tailscale' }, ctx, opts).replace('robobmw', '<ROBOT_NAME>')));
+    }
+    console.log();
+    console.log(chalk.dim('  # on this dev laptop'));
+    console.log('  ' + chalk.cyan(controlCommand(ctx, opts)));
+    console.log();
+}

package/dist/robopark/serve.d.ts

@@ -0,0 +1,13 @@
+export interface ServeOptions {
+    port?: string;
+    host?: string;
+    dataDir?: string;
+    gateway?: string;
+    gatewayToken?: string;
+    gatewayPassword?: string;
+    open?: boolean;
+    foreground?: boolean;
+}
+export declare function roboparkServe(opts: ServeOptions): Promise<void>;
+/** Quick health check: is the scheduler responding? */
+export declare function schedulerHealthy(url: string, timeoutMs?: number): Promise<boolean>;

package/dist/robopark/serve.js

@@ -0,0 +1,142 @@
+/**
+ * RoboPark — `robopark serve`.
+ *
+ * Starts the RoboPark scheduler (Python FastAPI) and the web UI in one pass.
+ * The scheduler lives next to this package in `scheduler/main.py`.
+ *
+ *   robopark serve --port 8080
+ *   robopark serve --gateway ws://infinibot:18789 --gateway-token <token>
+ */
+import chalk from 'chalk';
+import { spawn, execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+function pkgDir() {
+    try {
+        // dist/robopark/serve.js -> project root
+        return dirname(dirname(fileURLToPath(import.meta.url)));
+    }
+    catch {
+        return process.cwd();
+    }
+}
+function findScheduler() {
+    const candidates = [
+        join(pkgDir(), 'packages', 'robopark', 'scheduler', 'main.py'),
+        join(pkgDir(), 'scheduler', 'main.py'),
+        join(process.cwd(), 'packages', 'robopark', 'scheduler', 'main.py'),
+        join(process.cwd(), 'scheduler', 'main.py'),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+function findPython() {
+    for (const name of ['python3.12', 'python3.11', 'python3.10', 'python3', 'python']) {
+        try {
+            execSync(`${name} --version`, { stdio: 'ignore' });
+            return name;
+        }
+        catch {
+            continue;
+        }
+    }
+    return 'python3';
+}
+export async function roboparkServe(opts) {
+    const schedulerPath = findScheduler();
+    if (!schedulerPath) {
+        console.log(chalk.red('  ✗ could not find scheduler/main.py'));
+        console.log(chalk.dim('    make sure robopark is installed from npm, not a partial checkout.'));
+        process.exit(1);
+    }
+    const port = opts.port ? parseInt(opts.port, 10) : 8080;
+    const host = opts.host ?? '0.0.0.0';
+    const python = findPython();
+    const env = {
+        ...process.env,
+        SCHEDULER_HOST: host,
+        SCHEDULER_PORT: String(port),
+        SCHEDULER_DATA_DIR: opts.dataDir ?? join(pkgDir(), '..', 'data'),
+    };
+    if (opts.gateway)
+        env.INFINIBOT_GATEWAY_URL = opts.gateway;
+    if (opts.gatewayToken)
+        env.INFINIBOT_GATEWAY_TOKEN = opts.gatewayToken;
+    if (opts.gatewayPassword)
+        env.INFINIBOT_GATEWAY_PASSWORD = opts.gatewayPassword;
+    console.log(chalk.bold('\n  robopark serve'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  scheduler: ${chalk.cyan(schedulerPath)}`);
+    console.log(`  python:    ${chalk.cyan(python)}`);
+    console.log(`  listen:    ${chalk.cyan(`${host}:${port}`)}`);
+    if (opts.gateway)
+        console.log(`  gateway:   ${chalk.cyan(opts.gateway)}`);
+    console.log();
+    const proc = spawn(python, ['main.py'], {
+        cwd: dirname(schedulerPath),
+        env,
+        stdio: 'pipe',
+        detached: !opts.foreground,
+    });
+    let ready = false;
+    proc.stdout?.on('data', (d) => {
+        const line = d.toString().trim();
+        if (line)
+            console.log(chalk.dim('  [scheduler] ' + line));
+        if (/Uvicorn running|Application startup complete/i.test(line)) {
+            ready = true;
+            printUrl(port);
+        }
+    });
+    proc.stderr?.on('data', (d) => {
+        const line = d.toString().trim();
+        if (line)
+            console.log(chalk.yellow('  [scheduler] ' + line));
+    });
+    proc.on('error', (err) => {
+        console.log(chalk.red(`  ✗ scheduler failed to start: ${err.message}`));
+        process.exit(1);
+    });
+    proc.on('exit', (code) => {
+        if (!ready && code !== 0) {
+            console.log(chalk.red(`  ✗ scheduler exited ${code ?? ''}`));
+            process.exit(code ?? 1);
+        }
+    });
+    if (opts.foreground) {
+        process.on('SIGINT', () => {
+            console.log(chalk.dim('\n  stopping scheduler…'));
+            try {
+                proc.kill('SIGINT');
+            }
+            catch { /* ignore */ }
+        });
+        proc.on('exit', () => process.exit(0));
+    }
+    else {
+        // Detached mode: let the user walk away. The process keeps running.
+        proc.unref();
+        printUrl(port);
+        console.log(chalk.dim('  running in background. Use Task Manager / systemctl / launchctl to stop.'));
+        // give the scheduler a moment to bind before printing URL
+        setTimeout(() => process.exit(0), 1200);
+    }
+}
+function printUrl(port) {
+    const url = `http://localhost:${port}`;
+    console.log(chalk.bold(`  dashboard: ${chalk.cyan(url)}`));
+}
+/** Quick health check: is the scheduler responding? */
+export async function schedulerHealthy(url, timeoutMs = 3000) {
+    try {
+        const res = await fetch(`${url.replace(/\/$/, '')}/api/settings`, { signal: AbortSignal.timeout(timeoutMs) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/robopark/setup.d.ts

@@ -0,0 +1,21 @@
+import type Conf from 'conf';
+import type { InfinicodeConfig } from '../kernel/config-schema.js';
+export interface SetupOptions {
+    role?: 'hub' | 'robot' | 'control';
+    name?: string;
+    site?: string;
+    token?: string;
+    hub?: string;
+    port?: string;
+    gateway?: string;
+    gatewayToken?: string;
+    gatewayPassword?: string;
+    tailscaleAuth?: string;
+    tag?: string;
+    schedulerPort?: string;
+    start?: boolean;
+    autoStart?: boolean;
+    yes?: boolean;
+    foreground?: boolean;
+}
+export declare function roboparkSetup(config: Conf<InfinicodeConfig>, opts: SetupOptions): Promise<void>;

package/dist/robopark/setup.js

@@ -0,0 +1,174 @@
+/**
+ * RoboPark — `robopark setup`.
+ *
+ * One-liner setup per production machine. Each role turns on the right defaults
+ * and hides the mesh vocabulary.
+ *
+ *   robopark setup --hub --name livekit-1 --site "Tel Aviv" --start --auto-start
+ *   robopark setup --robot --name robobmw --start --auto-start
+ *   robopark setup --control --start
+ */
+import chalk from 'chalk';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { discoverContext, generateToken } from './discovery.js';
+import { registerAutoStart } from './auto-start.js';
+const DEFAULT_MESH_PORT = 47913;
+const DEFAULT_SCHEDULER_PORT = 8080;
+function saveToken(token) {
+    const dir = join(homedir(), '.robopark');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'mesh.token'), token, 'utf8');
+}
+/** Run an external command and detach unless foreground is requested. */
+function runDetached(cmd, args, env) {
+    const proc = spawn(cmd, args, {
+        stdio: 'ignore',
+        detached: true,
+        env: { ...process.env, ...env },
+    });
+    proc.unref();
+}
+export async function roboparkSetup(config, opts) {
+    const ctx = await discoverContext();
+    const role = opts.role ?? 'control';
+    const token = opts.token ?? ctx.meshToken ?? generateToken();
+    const port = opts.port ? parseInt(opts.port, 10) : DEFAULT_MESH_PORT;
+    const name = opts.name ?? ctx.localName;
+    const gatewayHost = opts.gateway ?? (ctx.gateway ? `ws://${ctx.gateway.host}:${ctx.gateway.port ?? 18789}` : undefined);
+    const gatewayToken = opts.gatewayToken ?? ctx.gateway?.token;
+    saveToken(token);
+    console.log(chalk.bold('\n  robopark setup'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  role:   ${chalk.yellow(role)}`);
+    console.log(`  name:   ${chalk.cyan(name)}${opts.site ? chalk.dim('  @ ' + opts.site) : ''}`);
+    console.log(`  mesh:   ${chalk.cyan('0.0.0.0:' + port)}`);
+    console.log(`  token:  ${chalk.green(token)}`);
+    if (gatewayHost)
+        console.log(`  gateway:${chalk.cyan(gatewayHost)}`);
+    console.log();
+    if (role === 'hub') {
+        await setupHub(config, opts, { name, token, port, gatewayHost, gatewayToken });
+    }
+    else if (role === 'robot') {
+        await setupRobot(config, opts, ctx, { name, token, port });
+    }
+    else {
+        await setupControl(config, opts, ctx, { name, token, port });
+    }
+}
+async function setupHub(config, opts, internal) {
+    const fed = {
+        ...(config.get('federation') ?? {}),
+        enabled: true,
+        role: 'hub',
+        port: internal.port,
+        displayName: internal.name,
+        token: internal.token,
+        lan: true,
+    };
+    config.set('federation', fed);
+    const infinicodeArgs = [
+        'serve', '--hub',
+        '--name', internal.name,
+        '--port', String(internal.port),
+        '--token', internal.token,
+        '--lan',
+        '--auto-update',
+        '--supervised',
+    ];
+    if (internal.gatewayHost)
+        infinicodeArgs.push('--gateway', internal.gatewayHost);
+    if (internal.gatewayToken)
+        infinicodeArgs.push('--gateway-token', internal.gatewayToken);
+    const schedulerPort = opts.schedulerPort ? parseInt(opts.schedulerPort, 10) : DEFAULT_SCHEDULER_PORT;
+    console.log(chalk.dim('  hub commands:'));
+    console.log('  ' + chalk.cyan(`infinicode ${infinicodeArgs.join(' ')}`));
+    console.log('  ' + chalk.cyan(`robopark serve --port ${schedulerPort}`));
+    console.log();
+    if (opts.start) {
+        console.log(chalk.dim('  starting infinicode hub…'));
+        runDetached('infinicode', infinicodeArgs);
+        console.log(chalk.dim('  starting robopark scheduler…'));
+        runDetached('robopark', ['serve', '--port', String(schedulerPort)]);
+    }
+    if (opts.autoStart) {
+        const reg = await registerAutoStart({
+            role: 'hub',
+            name: internal.name,
+            command: 'infinicode',
+            args: infinicodeArgs,
+        });
+        console.log(reg.ok ? chalk.green(`  ✓ ${reg.message}`) : chalk.yellow(`  ⚠ ${reg.message}`));
+        const reg2 = await registerAutoStart({
+            role: 'hub-scheduler',
+            name: internal.name,
+            command: 'robopark',
+            args: ['serve', '--port', String(schedulerPort), '--foreground'],
+        });
+        console.log(reg2.ok ? chalk.green(`  ✓ ${reg2.message}`) : chalk.yellow(`  ⚠ ${reg2.message}`));
+    }
+}
+async function setupRobot(config, opts, ctx, internal) {
+    const hubUrl = opts.hub ?? (ctx.hub ? `http://${ctx.hub.ip}:${internal.port}` : undefined);
+    if (!hubUrl) {
+        console.log(chalk.red('  ✗ no hub discovered. Pass --hub http://HUB_IP:47913'));
+        return;
+    }
+    const fed = {
+        ...(config.get('federation') ?? {}),
+        enabled: true,
+        role: 'satellite',
+        port: internal.port,
+        displayName: internal.name,
+        token: internal.token,
+        seeds: [hubUrl],
+        lan: true,
+    };
+    config.set('federation', fed);
+    const args = [
+        'serve', '--role', 'satellite',
+        '--name', internal.name,
+        '--port', String(internal.port),
+        '--token', internal.token,
+        '--seed', hubUrl,
+        '--lan',
+        '--auto-update',
+        '--supervised',
+    ];
+    console.log(chalk.dim('  robot command:'));
+    console.log('  ' + chalk.cyan(`infinicode ${args.join(' ')}`));
+    console.log();
+    if (opts.start) {
+        console.log(chalk.dim('  starting robot satellite node…'));
+        runDetached('infinicode', args);
+    }
+    if (opts.autoStart) {
+        const reg = await registerAutoStart({
+            role: 'robot',
+            name: internal.name,
+            command: 'infinicode',
+            args,
+        });
+        console.log(reg.ok ? chalk.green(`  ✓ ${reg.message}`) : chalk.yellow(`  ⚠ ${reg.message}`));
+    }
+}
+async function setupControl(config, opts, ctx, internal) {
+    const hubUrl = opts.hub ?? (ctx.hub ? `http://${ctx.hub.ip}:${internal.port}` : undefined);
+    const args = [
+        'mesh', 'install',
+        '--token', internal.token,
+        '--name', internal.name,
+        hubUrl ? '--seed' : '', hubUrl ?? '',
+    ].filter(Boolean);
+    console.log(chalk.dim('  control command:'));
+    console.log('  ' + chalk.cyan(`infinicode ${args.join(' ')}`));
+    console.log();
+    if (opts.start) {
+        console.log(chalk.dim('  registering infinicode MCP host…'));
+        const proc = spawn('infinicode', args, { stdio: 'inherit' });
+        await new Promise(resolve => proc.on('close', () => resolve()));
+    }
+}

package/dist/robopark-cli.d.ts

@@ -1,2 +1 @@
-#!/usr/bin/env node
 export {};

package/dist/robopark-cli.js

@@ -1,23 +1,92 @@
-#!/usr/bin/env node
 /**
- * `robopark` — standalone entry for the RoboPark fleet control CLI.
+ * RoboPark CLI entry point (shipped as `infinicode/robopark` and `robopark`).
  *
- * Same verbs as `infinicode robopark …`, exposed as a top-level `robopark`
- * command so operators type `robopark fleet` / `robopark setup` directly.
+ * A thin operator layer over the infinicode mesh. Keeps product concerns
+ * (scheduler, fleet UI, video sessions, InfiniBot map) separate from the
+ * execution kernel.
  */
 import { Command } from 'commander';
+import chalk from 'chalk';
 import Conf from 'conf';
-import { attachRoboparkSubcommands } from './commands/robopark.js';
-import { DEFAULT_CONFIG } from './kernel/config-schema.js';
-const VERSION = '2.5.1';
+import { attachRoboparkSubcommands as attachLegacy } from './commands/robopark.js';
+import { roboparkScan } from './robopark/scan.js';
+import { roboparkServe } from './robopark/serve.js';
+import { roboparkSetup } from './robopark/setup.js';
 const config = new Conf({
-    projectName: 'infinicode', // share infinicode's config store (providers, federation)
-    defaults: DEFAULT_CONFIG,
+    projectName: 'infinicode',
 });
-const program = new Command();
+const program = new Command('robopark')
+    .description('RoboPark fleet control CLI — set up, watch, and drive talking robots')
+    .version('2.8.0');
 program
-    .name('robopark')
-    .description('RoboPark fleet control — setup, fleet status, run, apply, dashboard (rides the infinicode mesh)')
-    .version(VERSION);
-attachRoboparkSubcommands(program, config);
-program.parse();
+    .command('scan')
+    .description('Auto-discover the fleet and print ready-to-run setup commands')
+    .option('--token <token>', 'mesh auth token to use')
+    .option('--output <dir>', 'write install scripts to this directory')
+    .option('--no-gateway', 'skip InfiniBot gateway in generated commands')
+    .action(async (opts) => {
+    await roboparkScan({
+        token: opts.token,
+        output: opts.output,
+        gateway: opts.gateway,
+    });
+});
+program
+    .command('serve')
+    .description('Start the RoboPark scheduler + web UI')
+    .option('--port <port>', 'scheduler HTTP port', '8080')
+    .option('--host <host>', 'scheduler bind host', '0.0.0.0')
+    .option('--data-dir <dir>', 'scheduler data directory')
+    .option('--gateway <url>', 'InfiniBot gateway ws:// URL')
+    .option('--gateway-token <token>', 'InfiniBot gateway token')
+    .option('--gateway-password <pw>', 'InfiniBot gateway password')
+    .option('--foreground', 'stay in foreground; do not detach')
+    .action(async (opts) => {
+    await roboparkServe(opts);
+});
+program
+    .command('setup')
+    .description('Set up this device in one pass')
+    .option('--hub', 'this device is the on-site hub')
+    .option('--robot', 'this device is a robot')
+    .option('--control', 'this device is a control station')
+    .option('--role <role>', 'explicit role: hub | robot | control')
+    .option('--name <name>', 'device name (defaults to hostname)')
+    .option('--site <site>', 'physical location, e.g. "Tel Aviv"')
+    .option('--hub-url <url>', 'hub base URL for robots/control')
+    .option('--token <token>', 'shared mesh token')
+    .option('--port <port>', 'mesh listen port', '47913')
+    .option('--gateway <url>', 'InfiniBot gateway ws:// URL')
+    .option('--gateway-token <token>', 'InfiniBot gateway token')
+    .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('--start', 'launch the node now')
+    .option('--auto-start', 'register to start on boot')
+    .option('--yes', 'non-interactive mode')
+    .action(async (opts) => {
+    const role = opts.role ?? (opts.hub ? 'hub' : opts.robot ? 'robot' : opts.control ? 'control' : undefined);
+    if (!role) {
+        console.log(chalk.red('  pass a role: --hub | --robot | --control'));
+        process.exit(1);
+    }
+    await roboparkSetup(config, {
+        role,
+        name: opts.name,
+        site: opts.site,
+        hub: opts.hubUrl,
+        token: opts.token,
+        port: opts.port,
+        gateway: opts.gateway,
+        gatewayToken: opts.gatewayToken,
+        schedulerPort: opts.schedulerPort,
+        tailscaleAuth: opts.tailscaleAuth,
+        tag: opts.tag,
+        start: opts.start,
+        autoStart: opts.autoStart,
+        yes: opts.yes,
+    });
+});
+// Keep legacy fleet/run/apply/dashboard commands available while migrating.
+attachLegacy(program, config, { skipSetup: true });
+await program.parseAsync(process.argv);

package/package.json

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