infinicode 2.8.22 → 2.8.25

package/dist/robopark/setup-livekit.js

@@ -55,26 +55,52 @@ async function meshRpc(targetUrl, token, env) {
     }
     return (await res.json());
 }
-async function getHubNodeId(hubUrl, token) {
+async function getHubManifest(hubUrl, token) {
     try {
         const url = `${hubUrl.replace(/\/$/, '')}/fed/manifest?token=${encodeURIComponent(token)}`;
         const res = await fetch(url, { headers: { accept: 'application/json' } });
         if (!res.ok)
-            return null;
+            return { nodeId: null, platform: null };
         const manifest = (await res.json());
-        return manifest.nodeId || manifest.id || null;
+        return { nodeId: manifest.nodeId || manifest.id || null, platform: manifest.platform ?? null };
+    }
+    catch {
+        return { nodeId: null, platform: null };
+    }
+}
+/** Fallback: GET /fed/status returns the hub's own NodeManifest under `self`,
+ *  including `platform`. Used when /fed/manifest doesn't carry it. */
+async function getHubPlatformFromStatus(hubUrl, token) {
+    try {
+        const url = `${hubUrl.replace(/\/$/, '')}/fed/status?token=${encodeURIComponent(token)}`;
+        const res = await fetch(url, { headers: { accept: 'application/json' } });
+        if (!res.ok)
+            return null;
+        const status = (await res.json());
+        return status.self?.platform ?? null;
     }
     catch {
         return null;
     }
 }
-const LIVEKIT_SETUP_PROMPT = `You are the RoboPark infrastructure agent running on the fleet hub.
+const LIVEKIT_SETUP_PROMPT_HEADER = `You are the RoboPark infrastructure agent running on the fleet hub.
 
 GOAL: Install and start a LiveKit server in Docker on this machine so the RoboPark scheduler can mint tokens and the robot preview agent can publish camera/audio.
 
 DO NOT ask the user for confirmation. Execute the steps directly. If a step is already done, skip it and report it.
-
-Steps:
+`;
+const LIVEKIT_SETUP_PROMPT_FOOTER = `
+IMPORTANT: this is a headless fleet node. Do not open a browser. Only run shell commands and report the final LiveKit URL + credentials in a JSON code block like:
+\`\`\`json
+{
+  "url": "ws://127.0.0.1:7880",
+  "api_key": "...",
+  "api_secret": "...",
+  "running": true
+}
+\`\`\`
+`;
+const LIVEKIT_SETUP_STEPS_LINUX = `Steps:
 1. Check if Docker is installed and running. If not, install Docker (apt-get install docker.io on Debian/Ubuntu, or dnf install docker on Fedora, or use the official convenience script if needed) and start it with systemctl.
 2. Pull the official LiveKit server image: docker pull livekit/livekit-server:latest
 3. Create a directory /opt/livekit if it does not exist.
@@ -82,23 +108,58 @@ Steps:
    docker run --rm livekit/livekit-server:latest generate-keys
    Parse the output and write it as a YAML file with fields api_key and api_secret.
 5. Start the LiveKit server container with host networking on port 7880:
-   docker run -d --name livekit-server --restart unless-stopped --network host \
-     -v /opt/livekit/keys.yaml:/etc/livekit/keys.yaml:ro \
-     livekit/livekit-server:latest \
+   docker run -d --name livekit-server --restart unless-stopped --network host \\
+     -v /opt/livekit/keys.yaml:/etc/livekit/keys.yaml:ro \\
+     livekit/livekit-server:latest \\
      --config /etc/livekit/keys.yaml --bind 0.0.0.0 --port 7880
 6. Wait up to 30 seconds and verify it is healthy: curl -sf http://127.0.0.1:7880
 7. Report back the WebSocket URL (ws://THIS_MACHINE_TAILSCALE_IP:7880 or ws://127.0.0.1:7880), the api_key, the api_secret, and whether the container is running.
+`;
+// Windows hosts: Docker Desktop does not support --network host, so ports are
+// mapped explicitly. --dev mode ships with well-known devkey/secret, which
+// sidesteps the `generate-keys` dance (that container command is awkward to
+// run/parse consistently from PowerShell).
+const LIVEKIT_SETUP_STEPS_WINDOWS = `Steps (Windows host — use PowerShell, NOT bash):
+1. Check if Docker Desktop is installed and running: docker info
+   If it is not installed, stop and report that Docker Desktop must be installed manually (winget install Docker.DockerDesktop), since it requires a GUI/WSL2 backend and cannot be silently installed headlessly.
+2. Pull the official LiveKit server image: docker pull livekit/livekit-server:latest
+3. Start the LiveKit server container in --dev mode (uses the well-known devkey/secret credentials, no key generation needed). Docker Desktop on Windows does not support --network host, so map ports explicitly:
+   docker run -d --name livekit-server --restart unless-stopped \`
+     -p 7880:7880 -p 7881:7881 -p 7881:7881/udp -p 50000-50100:50000-50100/udp \`
+     livekit/livekit-server:latest --dev --bind 0.0.0.0
+   (If a container named livekit-server already exists, remove it first with: docker rm -f livekit-server)
+4. Wait up to 30 seconds and verify it is healthy: curl.exe -sf http://127.0.0.1:7880 (or Invoke-WebRequest)
+5. The credentials in --dev mode are fixed: api_key = devkey, api_secret = secret.
+6. Report back the WebSocket URL (ws://THIS_MACHINE_TAILSCALE_IP:7880 or ws://127.0.0.1:7880), api_key "devkey", api_secret "secret", and whether the container is running.
+`;
+// Used when the hub's platform could not be determined before dispatch: ask
+// the agent to detect its own OS first, then follow the matching branch.
+const LIVEKIT_SETUP_STEPS_AUTODETECT = `Steps:
+0. FIRST, detect your own OS before running anything else:
+   - On Windows, $env:OS will be "Windows_NT" (PowerShell) — or the presence of \`Get-Command\` with no \`uname\` binary.
+   - On Linux/macOS, \`uname\` will succeed and print Linux/Darwin.
+   Branch into ONE of the two command sets below based on that detection. Do not run both.
 
-IMPORTANT: this is a headless fleet node. Do not open a browser. Only run shell commands and report the final LiveKit URL + credentials in a JSON code block like:
-\`\`\`json
-{
-  "url": "ws://127.0.0.1:7880",
-  "api_key": "...",
-  "api_secret": "...",
-  "running": true
-}
-\`\`\`
+--- IF WINDOWS (use PowerShell): ---
+${LIVEKIT_SETUP_STEPS_WINDOWS}
+
+--- IF LINUX/macOS (use bash/sh): ---
+${LIVEKIT_SETUP_STEPS_LINUX}
 `;
+function buildLivekitSetupPrompt(platform) {
+    let steps;
+    if (platform === 'win32') {
+        steps = LIVEKIT_SETUP_STEPS_WINDOWS;
+    }
+    else if (platform === 'linux' || platform === 'darwin') {
+        steps = LIVEKIT_SETUP_STEPS_LINUX;
+    }
+    else {
+        // Platform unknown ahead of dispatch — let the agent detect itself.
+        steps = LIVEKIT_SETUP_STEPS_AUTODETECT;
+    }
+    return LIVEKIT_SETUP_PROMPT_HEADER + '\n' + steps + LIVEKIT_SETUP_PROMPT_FOOTER;
+}
 function extractJson(text) {
     const m = text.match(/\`\`\`json\s*([\s\S]*?)\s*\`\`\`/);
     if (!m)
@@ -152,14 +213,20 @@ export async function roboparkSetupLivekit(opts) {
     console.log(chalk.dim('  ' + '─'.repeat(52)));
     console.log(`  hub:       ${chalk.cyan(hubUrl)}`);
     console.log(`  scheduler: ${chalk.cyan(schedulerUrl ?? 'not provided')}`);
+    const from = hostname().split('.')[0];
+    const manifest = await getHubManifest(hubUrl, token);
+    let platform = manifest.platform;
+    if (!platform)
+        platform = await getHubPlatformFromStatus(hubUrl, token);
+    console.log(`  hub platform: ${chalk.cyan(platform ?? 'unknown (agent will self-detect)')}`);
     console.log();
+    const prompt = buildLivekitSetupPrompt(platform);
     if (opts.dryRun) {
         console.log(chalk.yellow('  dry run — prompt that would be sent:'));
-        console.log(chalk.dim(LIVEKIT_SETUP_PROMPT.split('\n').map(l => '  ' + l).join('\n')));
+        console.log(chalk.dim(prompt.split('\n').map(l => '  ' + l).join('\n')));
         return;
     }
-    const from = hostname().split('.')[0];
-    const nodeId = await getHubNodeId(hubUrl, token);
+    const nodeId = manifest.nodeId;
     if (!nodeId) {
         console.log(chalk.red('  ✗ hub manifest not reachable. Is infinicode serve running on the hub?'));
         process.exit(1);
@@ -168,7 +235,7 @@ export async function roboparkSetupLivekit(opts) {
     const dispatchEnv = envelope('task.dispatch', from, {
         description: 'Install LiveKit server on hub via Docker',
         capabilities: ['shell', 'docker', 'reasoning'],
-        prompt: LIVEKIT_SETUP_PROMPT,
+        prompt,
         agent: 'opencode',
         context: { role: 'hub', site: 'fleet-hub' },
     }, { to: nodeId, auth: token });

package/dist/robopark/setup.js

@@ -9,7 +9,7 @@
  *   robopark setup --control --start
  */
 import chalk from 'chalk';
-import { mkdirSync, writeFileSync } from 'node:fs';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { spawn } from 'node:child_process';
@@ -23,6 +23,43 @@ function saveToken(token) {
     mkdirSync(dir, { recursive: true });
     writeFileSync(join(dir, 'mesh.token'), token, 'utf8');
 }
+/**
+ * Clear a stale device identity before a fresh enrollment.
+ *
+ * preview_agent.py only re-enrolls (POSTs /api/devices/enroll) when it has
+ * NO device_token. If ~/.robopark/device_token and ~/.robopark/preview_agent.json
+ * survive from a previous enrollment (e.g. against a different scheduler),
+ * PreviewAgent.__init__ loads that old token/device_id and skips enrollment
+ * entirely — silently reusing a stale identity, which then 401s against the
+ * new target scheduler. An explicit --enrollment-token means the caller
+ * wants a fresh enrollment, not to reuse a stale identity from a previous
+ * target scheduler, so wipe the persisted device_token/device_id (and the
+ * token file) whenever one is passed.
+ */
+function resetStaleEnrollment() {
+    const dir = join(homedir(), '.robopark');
+    const configPath = join(dir, 'preview_agent.json');
+    const tokenPath = join(dir, 'device_token');
+    if (existsSync(tokenPath)) {
+        try {
+            rmSync(tokenPath);
+        }
+        catch (err) {
+            console.log(chalk.yellow(`  ⚠ could not clear stale device token: ${err.message}`));
+        }
+    }
+    if (existsSync(configPath)) {
+        try {
+            const cfg = JSON.parse(readFileSync(configPath, 'utf8'));
+            delete cfg.device_id;
+            delete cfg.device_token;
+            writeFileSync(configPath, JSON.stringify(cfg, null, 2), 'utf8');
+        }
+        catch (err) {
+            console.log(chalk.yellow(`  ⚠ could not clear stale enrollment config: ${err.message}`));
+        }
+    }
+}
 /** Run an external command and detach unless foreground is requested. */
 function runDetached(cmd, args, env) {
     const proc = spawn(cmd, args, {
@@ -193,14 +230,21 @@ async function setupRobot(config, opts, ctx, internal) {
         const robotArgv = await infinicodeArgv(args);
         console.log(chalk.dim('  starting robot satellite node…'));
         runDetached(robotArgv[0], robotArgv.slice(1));
+        // NOTE: there is deliberately no separate `robopark enroll` spawn here.
+        // preview_agent.py's own startup (PreviewAgent.start(), see
+        // packages/robopark/scheduler/preview_agent.py) already performs
+        // enrollment itself whenever it has an --enrollment-token and no
+        // device_token yet. Spawning `robopark enroll` as well used to launch a
+        // SECOND full preview_agent.py process (enroll.ts runs the whole script,
+        // not a one-shot enroll-and-exit) with a different arg set (no
+        // --video-device/--audio-device/vision flags), which raced the "real"
+        // preview-agent process below for the same camera/mic and the vision
+        // webhook port (5057). --enrollment-token is already forwarded via
+        // previewAgentArgs, so one process below covers both enrollment and the
+        // long-running agent.
         if (opts.enrollmentToken) {
-            console.log(chalk.dim('  enrolling robot with scheduler…'));
-            const enrollArgv = [process.execPath, process.argv[1], 'enroll',
-                '--scheduler-url', schedulerUrl,
-                '--robot-id', internal.name,
-                '--enrollment-token', opts.enrollmentToken,
-                '--save-config'];
-            runDetached(enrollArgv[0], enrollArgv.slice(1));
+            console.log(chalk.dim('  fresh --enrollment-token given — clearing any stale device identity…'));
+            resetStaleEnrollment();
         }
         console.log(chalk.dim('  starting preview agent…'));
         const previewArgv = [process.execPath, process.argv[1], ...previewAgentArgs];

package/dist/robopark/stop-all.d.ts

@@ -0,0 +1,6 @@
+export interface StopResult {
+    killedPids: number[];
+    removedUnits: string[];
+    errors: string[];
+}
+export declare function stopAll(): Promise<StopResult>;

package/dist/robopark/stop-all.js

@@ -0,0 +1,125 @@
+/**
+ * RoboPark / infinicode — stop everything on this machine, including whatever
+ * would respawn it.
+ *
+ * `--supervised` nodes (systemd/Task Scheduler/launchd, `Restart=always`) come
+ * back on their own after a plain kill — that's the class of bug that leaves a
+ * stale hub process answering on a port after someone thought they killed it.
+ * This kills every matching PID directly (never a blanket `killall node`) AND
+ * disables/removes the supervisor unit so it does not restart.
+ */
+import { spawnSync } from 'node:child_process';
+// Long-running daemons only — never a short-lived CLI invocation like
+// `robopark setup` or `robopark stop` itself, which would otherwise match
+// its own (or an ancestor shell's) command line and self-terminate mid-run.
+const PATTERNS = [
+    'infinicode serve',
+    'infinicode.js serve',
+    'cli.js serve', // source/dev invocation: `node dist/cli.js serve ...`
+    'robopark serve',
+    'robopark-cli.js serve',
+    'preview_agent.py',
+    'app_pi_clean.py',
+];
+export async function stopAll() {
+    const platform = process.platform;
+    if (platform === 'win32')
+        return stopAllWindows();
+    return stopAllUnix();
+}
+function stopAllWindows() {
+    const killedPids = [];
+    const removedUnits = [];
+    const errors = [];
+    // Find every process whose command line matches, by PID — not by image
+    // name, so we never touch an unrelated node.exe (e.g. an MCP server).
+    const ps = spawnSync('powershell.exe', [
+        '-NoProfile', '-NonInteractive', '-Command',
+        `Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -and ($_.CommandLine -match '${PATTERNS.join('|').replace(/'/g, "''")}') } | Select-Object -ExpandProperty ProcessId`,
+    ], { encoding: 'utf8' });
+    const pids = (ps.stdout ?? '').split(/\r?\n/).map(s => s.trim()).filter(Boolean).map(Number).filter(Number.isFinite);
+    const self = process.pid;
+    for (const pid of pids) {
+        if (pid === self)
+            continue; // never kill the process running this command
+        const kill = spawnSync('taskkill', ['/PID', String(pid), '/F', '/T'], { encoding: 'utf8' });
+        if (kill.status === 0)
+            killedPids.push(pid);
+        else
+            errors.push(`taskkill ${pid}: ${(kill.stderr || kill.stdout || '').trim()}`);
+    }
+    // Remove any Scheduled Tasks registered by `robopark setup --auto-start`
+    // (auto-start.ts names them "RoboPark-<role>-<name>") so they don't relaunch
+    // on next login/boot.
+    const query = spawnSync('schtasks', ['/Query', '/FO', 'CSV', '/NH'], { encoding: 'utf8' });
+    const taskNames = (query.stdout ?? '')
+        .split(/\r?\n/)
+        .map(line => line.split(',')[0]?.replace(/^"|"$/g, ''))
+        .filter((n) => !!n && n.startsWith('\\RoboPark-'));
+    for (const name of taskNames) {
+        const del = spawnSync('schtasks', ['/Delete', '/TN', name, '/F'], { encoding: 'utf8' });
+        if (del.status === 0)
+            removedUnits.push(name);
+        else
+            errors.push(`schtasks /Delete ${name}: ${(del.stderr || del.stdout || '').trim()}`);
+    }
+    return { killedPids, removedUnits, errors };
+}
+function stopAllUnix() {
+    const killedPids = [];
+    const removedUnits = [];
+    const errors = [];
+    const self = process.pid;
+    const ps = spawnSync('ps', ['ax', '-o', 'pid=,command='], { encoding: 'utf8' });
+    const lines = (ps.stdout ?? '').split('\n');
+    const re = new RegExp(PATTERNS.map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'));
+    for (const line of lines) {
+        const m = line.match(/^\s*(\d+)\s+(.*)$/);
+        if (!m)
+            continue;
+        const pid = Number(m[1]);
+        const cmd = m[2];
+        if (pid === self || !re.test(cmd))
+            continue;
+        const kill = spawnSync('kill', ['-9', String(pid)], { encoding: 'utf8' });
+        if (kill.status === 0)
+            killedPids.push(pid);
+        else
+            errors.push(`kill -9 ${pid}: ${(kill.stderr || '').trim()}`);
+    }
+    // Also free the well-known RoboPark ports directly — belt and suspenders
+    // against a supervised process whose command line didn't match a pattern.
+    for (const port of [47913, 47921, 47922, 8080, 5000, 5057]) {
+        const lsof = spawnSync('lsof', ['-t', `-i:${port}`], { encoding: 'utf8' });
+        const pids = (lsof.stdout ?? '').split('\n').map(s => s.trim()).filter(Boolean).map(Number);
+        for (const pid of pids) {
+            if (pid === self || killedPids.includes(pid))
+                continue;
+            const kill = spawnSync('kill', ['-9', String(pid)], { encoding: 'utf8' });
+            if (kill.status === 0)
+                killedPids.push(pid);
+        }
+    }
+    if (process.platform === 'linux') {
+        // Broad match, not just "robopark-*" — known unit names in the wild
+        // include a bare "infinicode.service" (see pi-client install scripts),
+        // which a narrower glob would silently leave running (and respawning
+        // whatever we just killed, if it has Restart=always).
+        const list = spawnSync('systemctl', ['list-units', '--all', '--plain', '--no-legend'], { encoding: 'utf8' });
+        const units = (list.stdout ?? '')
+            .split('\n')
+            .map(l => l.trim().split(/\s+/)[0])
+            .filter((u) => !!u && u.endsWith('.service') && /infinicode|robopark/i.test(u));
+        for (const unit of units) {
+            spawnSync('systemctl', ['stop', unit], { encoding: 'utf8' });
+            const disable = spawnSync('systemctl', ['disable', unit], { encoding: 'utf8' });
+            if (disable.status === 0)
+                removedUnits.push(unit);
+            else
+                errors.push(`systemctl disable ${unit}: ${(disable.stderr || '').trim()}`);
+        }
+        if (units.length)
+            spawnSync('systemctl', ['daemon-reload'], { encoding: 'utf8' });
+    }
+    return { killedPids, removedUnits, errors };
+}

package/dist/robopark-cli.js

@@ -15,6 +15,11 @@ import { attachRoboparkSubcommands as attachLegacy } from './commands/robopark.j
 import { roboparkScan } from './robopark/scan.js';
 import { roboparkServe } from './robopark/serve.js';
 import { roboparkSetup } from './robopark/setup.js';
+import { stopAll } from './robopark/stop-all.js';
+import { roboparkDoctor } from './robopark/doctor.js';
+import { roboparkAddRobot } from './robopark/add-robot.js';
+import { saveHubProfile, clearHubProfile } from './robopark/profile.js';
+import { roboparkAgentUp, roboparkAgentDown, roboparkAgentLogs } from './robopark/agent-ctl.js';
 // Read the real version from package.json so `--version` never drifts from
 // what is actually installed (this was a hardcoded constant that went stale
 // across several releases — see the identical fix + comment in cli.ts).
@@ -135,6 +140,120 @@ program
     const { roboparkVisionAgent } = await import('./robopark/vision-agent-launcher.js');
     await roboparkVisionAgent(opts);
 });
+program
+    .command('stop')
+    .description('Stop every infinicode/robopark process on this device AND remove any supervisor (systemd/Task Scheduler/launchd) that would respawn it')
+    .action(async () => {
+    console.log(chalk.bold('\n  robopark stop\n  ' + '─'.repeat(48)));
+    try {
+        const result = await stopAll();
+        if (result.killedPids.length)
+            console.log(chalk.green(`  ✓ killed ${result.killedPids.length} process(es): ${result.killedPids.join(', ')}`));
+        else
+            console.log(chalk.dim('  no matching processes were running'));
+        if (result.removedUnits.length)
+            console.log(chalk.green(`  ✓ removed ${result.removedUnits.length} supervisor unit(s): ${result.removedUnits.join(', ')}`));
+        else
+            console.log(chalk.dim('  no supervisor units registered'));
+        for (const err of result.errors)
+            console.log(chalk.yellow(`  ! ${err}`));
+        console.log('');
+    }
+    catch (e) {
+        console.error('stop failed:', e instanceof Error ? (e.stack ?? e.message) : e);
+        process.exitCode = 1;
+    }
+});
+program
+    .command('doctor')
+    .description('Run a full fleet health check: hub, scheduler, LiveKit servers, device heartbeats, production mode')
+    .option('--hub-url <url>', 'hub federation URL, e.g. http://100.64.1.2:47913')
+    .option('--token <token>', 'mesh auth token')
+    .option('--scheduler-url <url>', 'scheduler base URL, e.g. http://100.64.1.2:8080')
+    .action(async (opts) => {
+    await roboparkDoctor(opts);
+});
+program
+    .command('server-add')
+    .description('Register a LiveKit server with the RoboPark scheduler')
+    .option('--hub-url <url>', 'hub federation URL, e.g. http://100.64.1.2:47913')
+    .option('--scheduler-url <url>', 'scheduler URL, e.g. http://100.64.1.2:8080 (derived from --hub-url if omitted)')
+    .option('--token <token>', 'mesh auth token (optional)')
+    .requiredOption('--id <id>', 'unique server id, e.g. livekit-hub-docker')
+    .option('--name <name>', 'display name (defaults to --id)')
+    .requiredOption('--url <url>', 'LiveKit ws:// URL, e.g. ws://100.64.1.2:7880')
+    .option('--webhook-url <url>', 'internal http URL for health/metrics (defaults to --url with ws->http)')
+    .option('--api-key <key>', "LiveKit API key (defaults to 'devkey')")
+    .option('--api-secret <secret>', "LiveKit API secret (defaults to 'secret')")
+    .option('--max-sessions <n>', 'max concurrent sessions', '8')
+    .action(async (opts) => {
+    const { roboparkServerAdd } = await import('./robopark/server-add.js');
+    await roboparkServerAdd(opts);
+});
+program
+    .command('llm-set')
+    .description('Upsert LLM_PROVIDER/OLLAMA_* keys into a ROBOVOICE .env file')
+    .requiredOption('--env-path <path>', 'path to the target .env file (e.g. a ROBOVOICE checkout)')
+    .requiredOption('--provider <name>', 'ollama | ollama-cloud | groq')
+    .option('--model <name>', 'model name (ollama providers only)')
+    .option('--host <url>', 'Ollama server URL (ollama providers only)')
+    .option('--api-key <key>', 'API key for cloud auth (ollama-cloud; currently unused by ROBOVOICE — see CLI warning)')
+    .action(async (opts) => {
+    const { roboparkLlmSet } = await import('./robopark/llm-set.js');
+    await roboparkLlmSet(opts);
+});
+program
+    .command('hub-use')
+    .description('Save hub/scheduler/token/site as defaults so other commands stop needing them repeated')
+    .option('--hub-url <url>', 'hub federation URL, e.g. http://100.64.1.2:47913')
+    .option('--token <token>', 'shared mesh token')
+    .option('--scheduler-url <url>', 'scheduler base URL, e.g. http://100.64.1.2:8080')
+    .option('--site <site>', 'physical location, e.g. "Tel Aviv"')
+    .option('--clear', 'wipe the saved hub profile')
+    .action(async (opts) => {
+    if (opts.clear) {
+        clearHubProfile();
+        console.log(chalk.green('  ✓ cleared saved hub profile'));
+        return;
+    }
+    saveHubProfile({ hubUrl: opts.hubUrl, token: opts.token, schedulerUrl: opts.schedulerUrl, site: opts.site });
+    console.log(chalk.green('  ✓ saved hub profile to ~/.robopark/hub-profile.json'));
+});
+program
+    .command('add-robot')
+    .description('Mint a scheduler enrollment token and print (or run) the robot setup one-liner')
+    .requiredOption('--name <name>', 'robot name, e.g. robobmw')
+    .option('--site <site>', 'physical location, e.g. "Tel Aviv"')
+    .option('--hub-url <url>', 'hub federation URL (defaults to saved hub profile / auto-discovery)')
+    .option('--token <token>', 'shared mesh token (defaults to saved hub profile / auto-discovery)')
+    .option('--scheduler-url <url>', 'scheduler base URL (defaults to saved hub profile / auto-discovery)')
+    .option('--start', 'start the robot node on this machine now, instead of printing the one-liner')
+    .action(async (opts) => {
+    await roboparkAddRobot(config, opts);
+});
+program
+    .command('agent-up')
+    .description('Start the ROBOVOICE docker stack and register its LiveKit server with the scheduler')
+    .requiredOption('--path <dir>', 'path to the ROBOVOICE checkout (contains docker-compose.yaml)')
+    .option('--scheduler-url <url>', 'scheduler URL (defaults to resolved hub context)')
+    .option('--hub-url <url>', 'hub URL (defaults to resolved hub context)')
+    .option('--token <token>', 'mesh token')
+    .option('--server-id <id>', "server id to register (default: 'robovoice-<hostname>')")
+    .option('--server-name <name>', 'server display name')
+    .option('--no-register', 'bring up docker only; skip scheduler registration')
+    .action(roboparkAgentUp);
+program
+    .command('agent-down')
+    .description('Stop the ROBOVOICE docker stack')
+    .requiredOption('--path <dir>', 'path to the ROBOVOICE checkout')
+    .action(roboparkAgentDown);
+program
+    .command('agent-logs')
+    .description('Tail ROBOVOICE docker compose logs')
+    .requiredOption('--path <dir>', 'path to the ROBOVOICE checkout')
+    .option('-f, --follow', 'follow log output')
+    .option('--service <name>', 'scope logs to one compose service (e.g. agent, livekit)')
+    .action(roboparkAgentLogs);
 program
     .command('setup')
     .description('Set up this device in one pass')

package/package.json

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