infinicode 2.7.1 → 2.8.1

package/dist/robopark/auto-start.js

@@ -0,0 +1,142 @@
+/**
+ * RoboPark — auto-start registration for production machines.
+ *
+ * Registers the RoboPark service to start on boot:
+ *   - Windows → Task Scheduler
+ *   - Linux   → systemd
+ *   - macOS   → launchd
+ *
+ * This is used by `robopark setup --auto-start`.
+ */
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { spawn } from 'node:child_process';
+function shellQuote(s) {
+    if (!/[^a-zA-Z0-9_./:=,-]/.test(s))
+        return s;
+    return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+export async function registerAutoStart(service) {
+    const platform = process.platform;
+    if (platform === 'win32')
+        return registerWindows(service);
+    if (platform === 'linux')
+        return registerSystemd(service);
+    if (platform === 'darwin')
+        return registerLaunchd(service);
+    return { ok: false, message: `auto-start not supported on ${platform}` };
+}
+async function registerWindows(service) {
+    const taskName = `RoboPark-${service.role}-${service.name}`;
+    const logDir = join(homedir(), 'AppData', 'Roaming', 'robopark', 'logs');
+    mkdirSync(logDir, { recursive: true });
+    const outLog = join(logDir, `${taskName}.log`);
+    const errLog = join(logDir, `${taskName}.err.log`);
+    const script = [service.command, ...service.args].map(shellQuote).join(' ');
+    const cmd = ['powershell.exe', '-WindowStyle', 'Hidden', '-ExecutionPolicy', 'Bypass', '-Command', script];
+    const xmlPath = join(homedir(), 'AppData', 'Roaming', 'robopark', `${taskName}.xml`);
+    mkdirSync(dirname(xmlPath), { recursive: true });
+    const xml = `<?xml version="1.0" encoding="UTF-16"?>\n<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">\n  <RegistrationInfo>\n    <Description>RoboPark ${service.role} for ${service.name}</Description>\n  </RegistrationInfo>\n  <Triggers>\n    <BootTrigger>\n      <Enabled>true</Enabled>\n    </BootTrigger>\n    <LogonTrigger>\n      <Enabled>true</Enabled>\n    </LogonTrigger>\n  </Triggers>\n  <Principals>\n    <Principal id="Author">\n      <LogonType>S4U</LogonType>\n      <RunLevel>HighestAvailable</RunLevel>\n    </Principal>\n  </Principals>\n  <Settings>\n    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>\n    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>\n    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>\n    <StartWhenAvailable>true</StartWhenAvailable>\n    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>\n    <IdleSettings>\n      <StopOnIdleEnd>false</StopOnIdleEnd>\n      <RestartOnIdle>false</RestartOnIdle>\n    </IdleSettings>\n    <AllowStartOnDemand>true</AllowStartOnDemand>\n    <Enabled>true</Enabled>\n    <Hidden>false</Hidden>\n    <RunOnlyIfIdle>false</RunOnlyIfIdle>\n    <DisallowStartOnRemoteAppSession>false</DisallowStartOnRemoteAppSession>\n    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>\n    <WakeToRun>false</WakeToRun>\n    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>\n  </Settings>\n  <Actions Context="Author">\n    <Exec>\n      <Command>${cmd[0]}</Command>\n      <Arguments>${cmd.slice(1).map(a => a.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;')).join(' ')}</Arguments>\n      <WorkingDirectory>${service.workingDir ?? homedir()}</WorkingDirectory>\n    </Exec>\n  </Actions>\n</Task>`;
+    // schtasks /XML requires UTF-16 LE *with* BOM when the XML declares UTF-16.
+    const bom = Buffer.from([0xff, 0xfe]);
+    const body = Buffer.from(xml, 'utf16le');
+    writeFileSync(xmlPath, Buffer.concat([bom, body]));
+    return new Promise((resolve) => {
+        const schtasks = spawn('schtasks', ['/Create', '/TN', taskName, '/XML', xmlPath, '/F'], { stdio: 'pipe' });
+        let out = '';
+        let err = '';
+        schtasks.stdout.on('data', d => (out += d.toString()));
+        schtasks.stderr.on('data', d => (err += d.toString()));
+        schtasks.on('close', code => {
+            if (code === 0) {
+                resolve({ ok: true, message: `registered Windows Task Scheduler task "${taskName}"` });
+            }
+            else {
+                resolve({ ok: false, message: `schtasks failed (${code}): ${err || out}` });
+            }
+        });
+        schtasks.on('error', e => resolve({ ok: false, message: `could not run schtasks: ${e.message}` }));
+    });
+}
+async function registerSystemd(service) {
+    const unitName = `robopark-${service.role}-${service.name.toLowerCase().replace(/[^a-z0-9]+/g, '-')}.service`;
+    const unitPath = `/etc/systemd/system/${unitName}`;
+    const envLines = Object.entries(service.env ?? {})
+        .map(([k, v]) => `Environment="${k}=${v.replace(/"/g, '\\"')}"`)
+        .join('\n');
+    const unit = `[Unit]
+Description=RoboPark ${service.role} for ${service.name}
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${service.command} ${service.args.map(shellQuote).join(' ')}
+WorkingDirectory=${service.workingDir ?? '/opt/robopark'}
+Restart=always
+RestartSec=5
+${envLines}
+
+[Install]
+WantedBy=multi-user.target
+`;
+    try {
+        writeFileSync(unitPath, unit, 'utf8');
+        return { ok: true, message: `wrote systemd unit ${unitPath}. Run: systemctl enable --now ${unitName}` };
+    }
+    catch (e) {
+        return { ok: false, message: `could not write ${unitPath}: ${e instanceof Error ? e.message : String(e)}` };
+    }
+}
+async function registerLaunchd(service) {
+    const label = `ai.robopark.${service.role}.${service.name}`;
+    const plistPath = join(homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
+    mkdirSync(join(homedir(), 'Library', 'LaunchAgents'), { recursive: true });
+    const env = service.env ?? {};
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${service.command}</string>
+    ${service.args.map(a => `<string>${a.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;')}</string>`).join('\n    ')}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${service.workingDir ?? homedir()}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join(homedir(), 'Library', 'Logs', `${label}.log`)}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(homedir(), 'Library', 'Logs', `${label}.err.log`)}</string>
+  ${Object.entries(env).map(([k, v]) => `<key>EnvironmentVariables</key>\n  <dict>\n    <key>${k}</key>\n    <string>${v}</string>\n  </dict>`).join('\n  ')}
+</dict>
+</plist>`;
+    try {
+        writeFileSync(plistPath, plist, 'utf8');
+        return { ok: true, message: `wrote launchd plist ${plistPath}. Run: launchctl load ${plistPath}` };
+    }
+    catch (e) {
+        return { ok: false, message: `could not write ${plistPath}: ${e instanceof Error ? e.message : String(e)}` };
+    }
+}
+export function unregisterAutoStart(role, name) {
+    const platform = process.platform;
+    const taskName = `RoboPark-${role}-${name}`;
+    if (platform === 'win32') {
+        try {
+            spawn('schtasks', ['/Delete', '/TN', taskName, '/F'], { stdio: 'ignore' }).unref();
+            return { ok: true, message: `deleted Windows task "${taskName}"` };
+        }
+        catch (e) {
+            return { ok: false, message: `failed: ${e instanceof Error ? e.message : String(e)}` };
+        }
+    }
+    return { ok: false, message: `unregister not implemented for ${platform}` };
+}

package/dist/robopark/discovery.d.ts

@@ -0,0 +1,62 @@
+export interface DiscoveredPeer {
+    name: string;
+    ip: string;
+    tags?: string[];
+    online: boolean;
+    source: 'tailscale' | 'lan';
+}
+export interface DiscoveredContext {
+    /** Best hub candidate (the on-site box). */
+    hub?: DiscoveredPeer;
+    /** InfiniBot gateway if found on the tailnet. */
+    gateway?: {
+        host: string;
+        port: number;
+        token?: string;
+    };
+    /** Robots discovered on LAN or Tailscale. */
+    robots: DiscoveredPeer[];
+    /** Tailscale auth key if one is cached locally. */
+    tailscaleAuthKey?: string;
+    /** Existing infinicode mesh token if already configured. */
+    meshToken?: string;
+    /** Existing infinicode mesh port. */
+    meshPort?: number;
+    /** This machine's hostname. */
+    localName: string;
+}
+interface TailscalePeer {
+    HostName?: string;
+    DNSName?: string;
+    TailscaleIPs?: string[];
+    Online?: boolean;
+    Tags?: string[];
+}
+interface TailscaleStatus {
+    Self?: TailscalePeer;
+    Peer?: Record<string, TailscalePeer>;
+}
+/** Run `tailscale status --json` and parse. */
+export declare function tailscaleStatus(): Promise<TailscaleStatus | null>;
+/** Discover peers from Tailscale. */
+export declare function discoverTailscale(): Promise<DiscoveredPeer[]>;
+/** Scan LAN UDP beacons on the default mesh discovery port. */
+export declare function discoverLan(port?: number, timeoutMs?: number): Promise<DiscoveredPeer[]>;
+/** Read a Tailscale auth key from common locations. */
+export declare function findTailscaleAuthKey(): string | undefined;
+/** Read InfiniBot gateway config from common locations. */
+export declare function findInfinibotGateway(): {
+    host: string;
+    port: number;
+    token?: string;
+} | undefined;
+/** Read existing infinicode mesh token/port from config. */
+export declare function readInfinicodeFederation(): {
+    token?: string;
+    port?: number;
+};
+/** Build the full discovered context for this environment. */
+export declare function discoverContext(): Promise<DiscoveredContext>;
+/** Generate a random token for mesh auth or scheduler enrollment. */
+export declare function generateToken(length?: number): string;
+export {};

package/dist/robopark/discovery.js

@@ -0,0 +1,144 @@
+/**
+ * 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 { 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 = 3000) {
+    // LAN discovery currently relies on the infinicode beacon protocol.
+    // For auto-setup we reuse Tailscale when available; LAN fallback is a TODO
+    // once the beacon protocol is stable enough to parse here.
+    return [];
+}
+/** 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() {
+    const peers = await discoverTailscale();
+    // 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/scan.d.ts

@@ -0,0 +1,10 @@
+interface ScanOptions {
+    /** Write generated install scripts to this directory. */
+    output?: string;
+    /** Include InfiniBot gateway in hub command if found. */
+    gateway?: boolean;
+    /** Mesh auth token to use on all devices. */
+    token?: string;
+}
+export declare function roboparkScan(opts?: ScanOptions): Promise<void>;
+export {};

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,19 @@
+export interface ServeOptions {
+    port?: string;
+    host?: string;
+    dataDir?: string;
+    gateway?: string;
+    gatewayToken?: string;
+    gatewayPassword?: string;
+    open?: boolean;
+    foreground?: boolean;
+}
+/** Resolve the actual infinicode CLI entry point so `robopark setup --start`
+ *  works even when global bins are not on PATH. */
+export declare function resolveInfinicodeBin(): Promise<{
+    node: string;
+    script: string;
+} | null>;
+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,164 @@
+/**
+ * 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';
+}
+/** Resolve the actual infinicode CLI entry point so `robopark setup --start`
+ *  works even when global bins are not on PATH. */
+export async function resolveInfinicodeBin() {
+    try {
+        // When running from the infinicode package itself, the CLI entry is nearby.
+        const local = join(pkgDir(), 'bin', 'infinicode.js');
+        if (existsSync(local))
+            return { node: process.execPath, script: local };
+    }
+    catch { /* ignore */ }
+    try {
+        // When running from the robopark wrapper, resolve infinicode from npm.
+        const { createRequire } = await import('node:module');
+        const require = createRequire(import.meta.url);
+        const pkgMain = require.resolve('infinicode/package.json');
+        const candidate = join(dirname(pkgMain), 'bin', 'infinicode.js');
+        if (existsSync(candidate))
+            return { node: process.execPath, script: candidate };
+    }
+    catch { /* ignore */ }
+    return null;
+}
+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>;