infinicode 2.7.1 → 2.8.1

package/dist/robopark/setup.js

@@ -0,0 +1,198 @@
+/**
+ * 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';
+import { resolveInfinicodeBin } from './serve.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.on('error', (err) => {
+        console.log(chalk.red(`  ✗ failed to start ${cmd}: ${err.message}`));
+    });
+    proc.unref();
+}
+/** Resolve the infinicode CLI and return the argv to spawn it. */
+async function infinicodeArgv(args) {
+    const bin = await resolveInfinicodeBin();
+    if (bin)
+        return [bin.node, bin.script, ...args];
+    // Fallback: assume `infinicode` is on PATH. Will fail clearly if not.
+    return ['infinicode', ...args];
+}
+/** Build a Windows-task-friendly command string from an argv array. */
+function commandString(argv) {
+    return argv.map(a => /[^a-zA-Z0-9_./:=,-]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a).join(' ');
+}
+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) {
+        const hubArgv = await infinicodeArgv(infinicodeArgs);
+        console.log(chalk.dim('  starting infinicode hub…'));
+        runDetached(hubArgv[0], hubArgv.slice(1));
+        console.log(chalk.dim('  starting robopark scheduler…'));
+        runDetached(process.execPath, [process.argv[1], 'serve', '--port', String(schedulerPort)]);
+    }
+    if (opts.autoStart) {
+        const hubArgv = await infinicodeArgv(infinicodeArgs);
+        const reg = await registerAutoStart({
+            role: 'hub',
+            name: internal.name,
+            command: hubArgv[0],
+            args: hubArgv.slice(1),
+        });
+        console.log(reg.ok ? chalk.green(`  ✓ ${reg.message}`) : chalk.yellow(`  ⚠ ${reg.message}`));
+        const reg2 = await registerAutoStart({
+            role: 'hub-scheduler',
+            name: internal.name,
+            command: process.execPath,
+            args: [process.argv[1], '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) {
+        const robotArgv = await infinicodeArgv(args);
+        console.log(chalk.dim('  starting robot satellite node…'));
+        runDetached(robotArgv[0], robotArgv.slice(1));
+    }
+    if (opts.autoStart) {
+        const robotArgv = await infinicodeArgv(args);
+        const reg = await registerAutoStart({
+            role: 'robot',
+            name: internal.name,
+            command: robotArgv[0],
+            args: robotArgv.slice(1),
+        });
+        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) {
+        const controlArgv = await infinicodeArgv(args);
+        console.log(chalk.dim('  registering infinicode MCP host…'));
+        const proc = spawn(controlArgv[0], controlArgv.slice(1), { stdio: 'inherit' });
+        proc.on('error', (err) => {
+            console.log(chalk.red(`  ✗ failed to start infinicode: ${err.message}`));
+        });
+        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.1');
 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.1",
+  "version": "2.8.1",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",