infinicode 2.8.53 → 2.8.56

package/dist/kernel/federation/dashboard-html.js

@@ -1324,9 +1324,21 @@ button.act:disabled{opacity:0.5;cursor:default;}
       var rows = data[0], devices = data[1];
       var deviceById = {}, deviceByName = {};
       function norm(v){ return String(v||'').trim().toLowerCase(); }
+      // A stale re-enrollment can leave more than one row with the same
+      // display name. Keep the live/fresh device, never whichever SQLite
+      // happened to return last, because all operator routes are id-keyed.
+      function deviceScore(device){
+        var status=norm(device&&device.status), at=Date.parse(device&&device.last_heartbeat||''), score=0;
+        if(status==='online'||status==='running'||status==='detecting'||status==='connecting') score+=10000;
+        if(Number.isFinite(at)) score+=Math.max(0, Math.floor(at/1000));
+        return score;
+      }
       (Array.isArray(devices)?devices:[]).forEach(function(device){
         deviceById[device.id] = device;
-        if(device.name) deviceByName[norm(device.name)] = device;
+        if(device.name){
+          var key=norm(device.name), current=deviceByName[key];
+          if(!current || deviceScore(device)>deviceScore(current)) deviceByName[key] = device;
+        }
       });
       schedulerDevicesById = deviceById;
       schedulerDevicesByName = deviceByName;
@@ -1336,7 +1348,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
       // legacy robots table has not been populated for that device yet.
       (Array.isArray(devices)?devices:[]).forEach(function(device){
         var already = candidates.some(function(row){
-          return norm(row.id||row.robot_id)===norm(device.id) || norm(row.name)===norm(device.name);
+          return norm(row.id||row.robot_id)===norm(device.id);
         });
         if(!already) candidates.push({id:device.id, name:device.name});
       });
@@ -5313,8 +5325,9 @@ button.act:disabled{opacity:0.5;cursor:default;}
     // name, which is not necessarily the scheduler's robots.id (e.g. an
     // enrolled device's id is a generated dev_xxxx, distinct from its name).
     // Falls back to n.name if telemetry hasn't matched a row yet.
-    function schedRow(n){
-      var row=roboparkByName[String(n.name||'').toLowerCase()] || roboparkByName[n.name], exact=row, keys=(n.telemKeys||[]).concat([String(n.name||'').toLowerCase()]);
+    function schedRow(n){
+      var preferred=schedulerDevice(n), preferredId=preferred&&preferred.id;
+      var row=(preferredId&&roboparkByName[String(preferredId).toLowerCase()]) || roboparkByName[String(n.name||'').toLowerCase()] || roboparkByName[n.name], exact=row, keys=(n.telemKeys||[]).concat([String(n.name||'').toLowerCase(),String(preferredId||'').toLowerCase()]);
       var seen={}, candidates=[];
       for(var rk in roboparkByName){
         var candidate=roboparkByName[rk], cid=candidate&&(candidate.robot_id||candidate.id);
@@ -5324,8 +5337,9 @@ button.act:disabled{opacity:0.5;cursor:default;}
         for(var ki=0;ki<keys.length;ki++){ var key=String(keys[ki]||'').toLowerCase(); if(key&&(label===key||idlabel===key||label.indexOf(key)>-1||key.indexOf(label)>-1)){ matches=true; break; } }
         if(matches) candidates.push(candidate);
       }
-      function readyScore(candidate){
-        var device=schedulerDevicesById[candidate.robot_id||candidate.id]||{}, status=String(candidate.device_status||device.status||'').toLowerCase(), score=0;
+      function readyScore(candidate){
+        var device=schedulerDevicesById[candidate.robot_id||candidate.id]||{}, status=String(candidate.device_status||device.status||'').toLowerCase(), score=0;
+        if(preferredId && String(candidate.robot_id||candidate.id||'')===String(preferredId)) score+=100000;
         if(candidate.production_mode===true||device.production_mode===true) score+=1000;
         if(status==='online'||status==='running'||status==='detecting') score+=500;
         if(candidate.readiness_code==='ready') score+=250;
@@ -5335,12 +5349,14 @@ button.act:disabled{opacity:0.5;cursor:default;}
       candidates.sort(function(a,b){ return readyScore(b)-readyScore(a); });
       return candidates[0]||row;
     }
-    function schedId(n){
-      var row=schedRow(n); if(row&&(row.id||row.robot_id)) return row.id||row.robot_id;
-      if(n.schedulerRobotId) return n.schedulerRobotId;
-      var byName=schedulerDevicesByName[String(n.name||'').toLowerCase()]; if(byName&&byName.id) return byName.id;
-      return n.name;
-    }
+    function schedId(n){
+      // Device ids are authoritative. A legacy robots row may share the
+      // name but have no preview, heartbeat, or hardware inventory.
+      var device=schedulerDevice(n); if(device&&device.id) return device.id;
+      var row=schedRow(n); if(row&&(row.id||row.robot_id)) return row.id||row.robot_id;
+      if(n.schedulerRobotId) return n.schedulerRobotId;
+      return n.name;
+    }
     function closeDrawer(){
       // tell the scheduler to end any live preview so the robot stops its cam
       if(previewOn && drawerId){ var pn=byId[drawerId]; if(pn){ try{ fetch('/robopark/api/robots/'+encodeURIComponent(schedId(pn))+'/preview/stop'+QS,{method:'POST',keepalive:true}); }catch(e){} } }
@@ -5474,10 +5490,18 @@ button.act:disabled{opacity:0.5;cursor:default;}
         refreshDrawer();
       }).catch(function(){});
     }
-    function schedulerDevice(n){
-      var row=schedRow(n), id=row&&(row.robot_id||row.id);
-      return (id&&schedulerDevicesById[id]) || schedulerDevicesById[n.schedulerDeviceId] || schedulerDevicesById[n.schedulerRobotId] || schedulerDevicesByName[String(n.name||'').toLowerCase()] || schedulerDevicesById[n.name] || null;
-    }
+    function schedulerDevice(n){
+      // Deliberately does not call schedRow: telemetry can contain a legacy
+      // robot name, while this lookup must choose the current enrolled device.
+      var ids=[n.schedulerDeviceId,n.schedulerRobotId,n.id,n.nodeId];
+      for(var i=0;i<ids.length;i++) if(ids[i]&&schedulerDevicesById[ids[i]]) return schedulerDevicesById[ids[i]];
+      var names=[n.name,n.displayName,n.label];
+      for(var j=0;j<names.length;j++){
+        var key=String(names[j]||'').toLowerCase();
+        if(key&&schedulerDevicesByName[key]) return schedulerDevicesByName[key];
+      }
+      return null;
+    }
     function deviceList(inv, key, fallback){
       var list=inv&&Array.isArray(inv[key])?inv[key]:[];
       return list.length?list:fallback.map(function(id){ return {id:id,name:id}; });

package/dist/robopark/auto-start.d.ts

@@ -1,5 +1,5 @@
 export interface ServiceArgs {
-    role: 'hub' | 'robot' | 'control' | 'hub-scheduler' | 'robot-preview-agent' | 'robot-vision-agent';
+    role: 'hub' | 'robot' | 'control' | 'hub-scheduler' | 'robot-runtime' | 'robot-preview-agent' | 'robot-vision-agent';
     name: string;
     command: string;
     args: string[];

package/dist/robopark/auto-start.js

@@ -8,10 +8,10 @@
  *
  * This is used by `robopark setup --auto-start`.
  */
-import { writeFileSync, mkdirSync } from 'node:fs';
+import { existsSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 function shellQuote(s) {
     if (!/[^a-zA-Z0-9_./:=,-]/.test(s))
         return s;
@@ -138,5 +138,31 @@ export function unregisterAutoStart(role, name) {
             return { ok: false, message: `failed: ${e instanceof Error ? e.message : String(e)}` };
         }
     }
-    return { ok: false, message: `unregister not implemented for ${platform}` };
+    if (platform === 'linux') {
+        const unitName = `robopark-${role}-${name.toLowerCase().replace(/[^a-z0-9]+/g, '-')}.service`;
+        const unitPath = `/etc/systemd/system/${unitName}`;
+        const stopped = spawnSync('systemctl', ['disable', '--now', unitName], { encoding: 'utf8' });
+        try {
+            if (existsSync(unitPath))
+                rmSync(unitPath);
+        }
+        catch { /* systemd output is more useful below */ }
+        spawnSync('systemctl', ['daemon-reload'], { stdio: 'ignore' });
+        return {
+            ok: stopped.status === 0 || !existsSync(unitPath),
+            message: `removed systemd unit ${unitName}`,
+        };
+    }
+    if (platform === 'darwin') {
+        const label = `ai.robopark.${role}.${name}`;
+        const plistPath = join(homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
+        spawnSync('launchctl', ['unload', plistPath], { stdio: 'ignore' });
+        try {
+            if (existsSync(plistPath))
+                rmSync(plistPath);
+        }
+        catch { /* ignore */ }
+        return { ok: true, message: `removed launchd plist ${plistPath}` };
+    }
+    return { ok: false, message: `unregister not supported on ${platform}` };
 }

package/dist/robopark/robot-runtime.d.ts

@@ -0,0 +1,14 @@
+export interface RobotRuntimeOptions {
+    name: string;
+    hubUrl: string;
+    schedulerUrl: string;
+    token: string;
+    port?: string;
+    network?: 'lan' | 'tailscale';
+    enrollmentToken?: string;
+    videoDevice?: string;
+    audioDevice?: string;
+    vision?: boolean;
+    foreground?: boolean;
+}
+export declare function roboparkRobotRuntime(opts: RobotRuntimeOptions): Promise<void>;

package/dist/robopark/robot-runtime.js

@@ -0,0 +1,163 @@
+/**
+ * RoboPark robot runtime.
+ *
+ * One long-lived parent for a robot's mesh satellite, RoboVision camera/audio
+ * service, and preview agent. Starting these as unrelated detached commands
+ * allowed a healthy-looking mesh node with no motion service or no device
+ * inventory. The runtime starts dependencies in order and restarts a child if
+ * it exits unexpectedly.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, createWriteStream, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+import { resolveInfinicodeBin } from './serve.js';
+const VISION_URL = 'http://127.0.0.1:5000/api/media/inventory';
+const RESTART_DELAY_MS = 5_000;
+function resetStaleEnrollment() {
+    const configDir = join(homedir(), '.robopark');
+    const tokenPath = join(configDir, 'device_token');
+    const configPath = join(configDir, 'preview_agent.json');
+    try {
+        if (existsSync(tokenPath))
+            rmSync(tokenPath);
+    }
+    catch { /* enrollment will report a real error */ }
+    if (!existsSync(configPath))
+        return;
+    try {
+        const config = JSON.parse(readFileSync(configPath, 'utf8'));
+        delete config.device_id;
+        delete config.device_token;
+        writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+    }
+    catch {
+        // A malformed optional config must not block first boot.
+    }
+}
+function roboparkCliPath() {
+    // dist/robopark/robot-runtime.js -> package root -> dist/robopark-cli.js
+    const packageRoot = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+    const compiledCli = join(packageRoot, 'dist', 'robopark-cli.js');
+    return existsSync(compiledCli) ? compiledCli : process.argv[1];
+}
+function runtimeLog(label, foreground) {
+    if (foreground)
+        return 'inherit';
+    const logDir = join(homedir(), '.robopark', 'logs');
+    mkdirSync(logDir, { recursive: true });
+    return [
+        'ignore',
+        createWriteStream(join(logDir, `${label}.log`), { flags: 'a' }),
+        createWriteStream(join(logDir, `${label}.err.log`), { flags: 'a' }),
+    ];
+}
+async function waitForVision() {
+    const deadline = Date.now() + 120_000;
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetch(VISION_URL, { signal: AbortSignal.timeout(1_500) });
+            if (response.ok)
+                return true;
+        }
+        catch {
+            // Dependency installation on a fresh Pi can take a little while.
+        }
+        await new Promise(resolve => setTimeout(resolve, 1_000));
+    }
+    return false;
+}
+export async function roboparkRobotRuntime(opts) {
+    const port = opts.port ?? '47913';
+    const network = opts.network ?? 'lan';
+    const foreground = opts.foreground === true;
+    const cli = roboparkCliPath();
+    const children = [];
+    let stopping = false;
+    const infinicode = await resolveInfinicodeBin();
+    if (!infinicode)
+        throw new Error('could not resolve infinicode CLI');
+    children.push({
+        label: 'mesh',
+        command: infinicode.node,
+        args: [infinicode.script, 'serve', '--role', 'satellite', '--name', opts.name,
+            '--port', port, '--token', opts.token, '--seed', opts.hubUrl,
+            network === 'tailscale' ? '--tailscale' : '--lan', '--auto-update'],
+    });
+    if (opts.vision !== false) {
+        children.push({
+            label: 'vision',
+            command: process.execPath,
+            args: [cli, 'vision-agent', '--foreground', '--port', '5000',
+                '--motion-webhook-url', 'http://127.0.0.1:5057/'],
+        });
+    }
+    const previewArgs = [cli, 'preview-agent', '--foreground',
+        '--scheduler-url', opts.schedulerUrl, '--robot-id', opts.name,
+        '--video-device', opts.videoDevice ?? 'auto', '--audio-device', opts.audioDevice ?? 'default',
+        '--save-config'];
+    if (opts.vision !== false)
+        previewArgs.push('--robovision-url', 'http://127.0.0.1:5000');
+    if (opts.enrollmentToken)
+        previewArgs.push('--enrollment-token', opts.enrollmentToken);
+    const preview = { label: 'preview', command: process.execPath, args: previewArgs };
+    const start = (entry) => {
+        const child = spawn(entry.command, entry.args, {
+            env: { ...process.env, ...entry.env, ROBOPARK_ROBOT_RUNTIME: '1' },
+            stdio: runtimeLog(`robot-${opts.name}-${entry.label}`, foreground),
+        });
+        entry.child = child;
+        child.on('error', error => console.error(chalk.red(`  ${entry.label} failed to start: ${error.message}`)));
+        child.on('exit', (code, signal) => {
+            entry.child = undefined;
+            if (stopping)
+                return;
+            console.error(chalk.yellow(`  ${entry.label} exited (${signal ?? code ?? 'unknown'}); restarting in 5s`));
+            setTimeout(() => { if (!stopping)
+                start(entry); }, RESTART_DELAY_MS);
+        });
+    };
+    console.log(chalk.bold('\n  robopark robot up'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  robot:     ${chalk.cyan(opts.name)}`);
+    console.log(`  scheduler: ${chalk.cyan(opts.schedulerUrl)}`);
+    console.log(`  network:   ${chalk.cyan(network)}`);
+    console.log(`  services:  ${opts.vision === false ? 'mesh + preview' : 'mesh + RoboVision + preview'}`);
+    console.log();
+    if (opts.enrollmentToken) {
+        console.log(chalk.dim('  clearing stale device identity for fresh enrollment…'));
+        resetStaleEnrollment();
+    }
+    // The mesh can reconnect independently; camera/audio must be healthy before
+    // preview sends its first inventory heartbeat or opens the motion webhook.
+    start(children[0]);
+    if (opts.vision !== false) {
+        start(children[1]);
+        console.log(chalk.dim('  waiting for RoboVision camera/audio inventory…'));
+        if (!await waitForVision()) {
+            stopping = true;
+            for (const entry of children)
+                entry.child?.kill('SIGTERM');
+            throw new Error('RoboVision did not become healthy at http://127.0.0.1:5000 within 120s');
+        }
+        console.log(chalk.green('  ✓ RoboVision ready; starting preview agent'));
+    }
+    start(preview);
+    const shutdown = () => {
+        stopping = true;
+        for (const entry of [...children, preview])
+            entry.child?.kill('SIGTERM');
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+    await new Promise(resolve => {
+        const check = setInterval(() => {
+            if (stopping && ![...children, preview].some(entry => entry.child)) {
+                clearInterval(check);
+                resolve();
+            }
+        }, 250);
+    });
+}

package/dist/robopark/setup.js

@@ -9,12 +9,12 @@
  *   robopark setup --control --start
  */
 import chalk from 'chalk';
-import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+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 { registerAutoStart, unregisterAutoStart } from './auto-start.js';
 import { resolveInfinicodeBin } from './serve.js';
 const DEFAULT_MESH_PORT = 47913;
 const DEFAULT_SCHEDULER_PORT = 8080;
@@ -23,43 +23,6 @@ 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,16 +156,6 @@ async function setupRobot(config, opts, ctx, internal) {
         lan: network === 'lan',
     };
     config.set('federation', fed);
-    const args = [
-        'serve', '--role', 'satellite',
-        '--name', internal.name,
-        '--port', String(internal.port),
-        '--token', internal.token,
-        '--seed', hubUrl,
-        networkFlag,
-        '--auto-update',
-        '--supervised',
-    ];
     // Derive the scheduler host from the SAME hubUrl used for the mesh seed
     // (respects an explicit --hub-url), not from ctx.hub — using auto-discovery
     // here independently of the mesh seed meant an explicit --hub-url only
@@ -211,86 +164,46 @@ async function setupRobot(config, opts, ctx, internal) {
     // found (e.g. a real hub reachable over Tailscale), not the one requested.
     const hubHost = new URL(hubUrl).hostname;
     const schedulerUrl = `http://${hubHost}:${opts.schedulerPort ? parseInt(opts.schedulerPort, 10) : DEFAULT_SCHEDULER_PORT}`;
-    const previewAgentArgs = [
-        'preview-agent',
+    // Vision (camera/motion detection -> presence-triggered session) is the
+    // production trigger — on by default. --no-vision opts out (e.g. no camera
+    // on this box, or RoboVisionAI_PI isn't installed).
+    const visionEnabled = opts.vision !== false;
+    const runtimeArgs = [
+        'robot', 'up',
+        '--name', internal.name,
+        '--hub-url', hubUrl,
         '--scheduler-url', schedulerUrl,
-        '--robot-id', internal.name,
+        '--token', internal.token,
+        '--port', String(internal.port),
+        networkFlag,
         '--video-device', opts.videoDevice ?? 'auto',
         '--audio-device', opts.audioDevice ?? 'default',
-        '--save-config',
     ];
     if (opts.enrollmentToken)
-        previewAgentArgs.push('--enrollment-token', opts.enrollmentToken);
-    // Vision (camera/motion detection -> presence-triggered session) is the
-    // production trigger — on by default. --no-vision opts out (e.g. no camera
-    // on this box, or RoboVisionAI_PI isn't installed).
-    const visionEnabled = opts.vision !== false;
-    if (visionEnabled)
-        previewAgentArgs.push('--robovision-url', 'http://127.0.0.1:5000');
-    const visionAgentArgs = ['vision-agent'];
-    console.log(chalk.dim('  robot command:'));
-    console.log('  ' + chalk.cyan(`infinicode ${args.join(' ')}`));
-    console.log('  ' + chalk.cyan(`robopark ${previewAgentArgs.join(' ')}`));
-    if (visionEnabled)
-        console.log('  ' + chalk.cyan(`robopark ${visionAgentArgs.join(' ')}`));
+        runtimeArgs.push('--enrollment-token', opts.enrollmentToken);
+    if (!visionEnabled)
+        runtimeArgs.push('--no-vision');
+    console.log(chalk.dim('  single robot command:'));
+    console.log('  ' + chalk.cyan(`robopark ${runtimeArgs.join(' ')}`));
     console.log(chalk.dim(`  network: ${network} (scheduler: ${schedulerUrl})`));
     console.log();
     if (opts.start) {
-        const robotArgv = await infinicodeArgv(args);
-        console.log(chalk.dim('  starting robot satellite node…'));
+        const robotArgv = [process.execPath, process.argv[1], ...runtimeArgs];
+        console.log(chalk.dim('  starting unified robot runtime…'));
         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('  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];
-        runDetached(previewArgv[0], previewArgv.slice(1));
-        if (visionEnabled) {
-            console.log(chalk.dim('  starting vision agent…'));
-            const visionArgv = [process.execPath, process.argv[1], ...visionAgentArgs];
-            runDetached(visionArgv[0], visionArgv.slice(1));
-        }
     }
     if (opts.autoStart) {
-        const robotArgv = await infinicodeArgv(args);
+        const robotArgv = [process.execPath, process.argv[1], ...runtimeArgs, '--foreground'];
+        for (const role of ['robot', 'robot-preview-agent', 'robot-vision-agent']) {
+            unregisterAutoStart(role, internal.name);
+        }
         const reg = await registerAutoStart({
-            role: 'robot',
+            role: 'robot-runtime',
             name: internal.name,
             command: robotArgv[0],
             args: robotArgv.slice(1),
         });
         console.log(reg.ok ? chalk.green(`  ✓ ${reg.message}`) : chalk.yellow(`  ⚠ ${reg.message}`));
-        const previewArgv = [process.execPath, process.argv[1], ...previewAgentArgs, '--foreground'];
-        const reg2 = await registerAutoStart({
-            role: 'robot-preview-agent',
-            name: internal.name,
-            command: previewArgv[0],
-            args: previewArgv.slice(1),
-        });
-        console.log(reg2.ok ? chalk.green(`  ✓ ${reg2.message}`) : chalk.yellow(`  ⚠ ${reg2.message}`));
-        if (visionEnabled) {
-            const visionArgv = [process.execPath, process.argv[1], ...visionAgentArgs, '--foreground'];
-            const reg3 = await registerAutoStart({
-                role: 'robot-vision-agent',
-                name: internal.name,
-                command: visionArgv[0],
-                args: visionArgv.slice(1),
-            });
-            console.log(reg3.ok ? chalk.green(`  ✓ ${reg3.message}`) : chalk.yellow(`  ⚠ ${reg3.message}`));
-        }
     }
 }
 async function setupControl(config, opts, ctx, internal) {

package/dist/robopark/stop-all.js

@@ -18,6 +18,9 @@ const PATTERNS = [
     'cli.js serve', // source/dev invocation: `node dist/cli.js serve ...`
     'robopark serve',
     'robopark-cli.js serve',
+    'robopark-cli.js robot-run',
+    'robopark-cli.js robot up',
+    'robopark.js robot up',
     // `robopark serve` detaches this child, so the Node launcher is gone while
     // the Python scheduler remains. Match both Windows and POSIX separators.
     'scheduler.{0,3}main\\.py',

package/dist/robopark/vision-agent-launcher.js

@@ -23,7 +23,7 @@ export async function roboparkVisionAgent(opts) {
     // Real Pi: opencv comes from `apt install python3-opencv`, not pip (see
     // requirements_pi_unified.txt) — pip-installing it here would fight the
     // ARM-optimized system build. Everywhere else: plain pip install works.
-    const reqFile = isPiArm() ? 'requirements_pi_unified.txt' : 'requirements-demo.txt';
+    const reqFile = isPiArm() ? 'requirements_vision_agent.txt' : 'requirements-demo.txt';
     const requiredModules = isPiArm() ? [...VISION_REQUIRED_MODULES, 'fastapi', 'uvicorn', 'sounddevice', 'soundfile', 'groq'] : VISION_REQUIRED_MODULES;
     const python = prepareRobotPython(basePython, script, requiredModules, reqFile);
     if (!python)

package/dist/robopark-cli.js

@@ -21,6 +21,7 @@ import { roboparkAddRobot } from './robopark/add-robot.js';
 import { saveHubProfile, clearHubProfile } from './robopark/profile.js';
 import { roboparkAgentUp, roboparkAgentDown, roboparkAgentLogs } from './robopark/agent-ctl.js';
 import { roboparkSecrets } from './robopark/secrets.js';
+import { roboparkRobotRuntime } from './robopark/robot-runtime.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).
@@ -157,6 +158,42 @@ program
     const { roboparkVisionAgent } = await import('./robopark/vision-agent-launcher.js');
     await roboparkVisionAgent(opts);
 });
+const robotProgram = program
+    .command('robot')
+    .description('Run the complete robot runtime as one supervised service');
+robotProgram
+    .command('up')
+    .description('Start mesh, RoboVision, audio, motion webhook, and preview agent in dependency order')
+    .requiredOption('--name <name>', 'robot name')
+    .requiredOption('--hub-url <url>', 'hub mesh URL, e.g. http://192.168.1.12:47913')
+    .requiredOption('--token <token>', 'shared mesh token')
+    .option('--scheduler-url <url>', 'scheduler URL (derived from --hub-url when omitted)')
+    .option('--enrollment-token <token>', 'one-time scheduler enrollment token for a fresh device')
+    .option('--port <port>', 'robot mesh port', '47913')
+    .option('--lan', 'use LAN transport (default)')
+    .option('--tailscale', 'use Tailscale transport')
+    .option('--video-device <dev>', 'camera selection', 'auto')
+    .option('--audio-device <dev>', 'microphone selection', 'default')
+    .option('--no-vision', 'do not start RoboVision camera/audio/motion services')
+    .option('--foreground', 'keep logs in this terminal instead of ~/.robopark/logs')
+    .action(async (opts) => {
+    if (opts.lan && opts.tailscale)
+        throw new Error('choose exactly one of --lan or --tailscale');
+    const hub = new URL(opts.hubUrl);
+    await roboparkRobotRuntime({
+        name: opts.name,
+        hubUrl: opts.hubUrl,
+        schedulerUrl: opts.schedulerUrl ?? `http://${hub.hostname}:8080`,
+        token: opts.token,
+        port: opts.port,
+        network: opts.tailscale ? 'tailscale' : 'lan',
+        enrollmentToken: opts.enrollmentToken,
+        videoDevice: opts.videoDevice,
+        audioDevice: opts.audioDevice,
+        vision: opts.vision,
+        foreground: opts.foreground,
+    });
+});
 program
     .command('stop')
     .description('Stop every infinicode/robopark process on this device AND remove any supervisor (systemd/Task Scheduler/launchd) that would respawn it')

package/package.json

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