infinicode 2.8.54 → 2.8.57

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-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.54",
+  "version": "2.8.57",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",

package/packages/robopark/scheduler/main.py

@@ -1881,10 +1881,13 @@ async def robot_stream(robot_id: str,
     if not await get_production_mode():
         return {"active": False, "reason": "production_mode_off"}
 
-    async with aiosqlite.connect(DB_PATH) as db:
-        db.row_factory = aiosqlite.Row
-        async with db.execute("SELECT * FROM robots WHERE id = ?", (robot_id,)) as c:
-            robot = await c.fetchone()
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        resolved_id = await _resolve_robot_reference(db, robot_id)
+        if not resolved_id:
+            raise HTTPException(404, "Robot not found")
+        async with db.execute("SELECT * FROM robots WHERE id = ?", (resolved_id,)) as c:
+            robot = await c.fetchone()
         if not robot:
             raise HTTPException(404, "Robot not found")
         if not robot["current_session_id"]:
@@ -1909,7 +1912,7 @@ async def robot_stream(robot_id: str,
     except ImportError:
         raise HTTPException(503, "livekit-api not installed on scheduler")
 
-    identity = f"viewer:{robot_id}:{int(datetime.utcnow().timestamp())}"
+    identity = f"viewer:{resolved_id}:{int(datetime.utcnow().timestamp())}"
     grants = VideoGrants(
         room=room_name,
         room_join=True,
@@ -1947,7 +1950,7 @@ async def robot_stream(robot_id: str,
 PREVIEW_TTL_SECONDS = 45  # preview auto-expires this long after the last keepalive
 DEFAULT_VISION_PORT = 5000  # RoboVisionAI_PI's default Flask port (/video_feed, /api/motion/*)
 
-async def _mirror_device_to_robot(db, device_id: str):
+async def _mirror_device_to_robot(db, device_id: str):
     """Ensure a `robots` row exists for an enrolled device, so id-keyed routes
     (/stream, /preview/*) work even before the device's first real voice
     session (device_request_session normally creates this mirror, but only on
@@ -1965,8 +1968,30 @@ async def _mirror_device_to_robot(db, device_id: str):
         (device_id, device["name"] or device_id, device["character_id"]),
     )
     await db.commit()
-    async with db.execute("SELECT * FROM robots WHERE id = ?", (device_id,)) as c:
-        return await c.fetchone()
+    async with db.execute("SELECT * FROM robots WHERE id = ?", (device_id,)) as c:
+        return await c.fetchone()
+
+async def _resolve_robot_reference(db, robot_ref: str) -> Optional[str]:
+    """Resolve a display name to its active enrolled device id when needed."""
+    async with db.execute("SELECT id FROM devices WHERE id = ?", (robot_ref,)) as c:
+        row = await c.fetchone()
+    if row:
+        return row["id"]
+    async with db.execute(
+        """SELECT id FROM devices WHERE lower(name) = lower(?)
+           ORDER BY CASE lower(status) WHEN 'online' THEN 0 WHEN 'running' THEN 1 ELSE 2 END,
+                    last_heartbeat DESC, enrolled_at DESC LIMIT 1""",
+        (robot_ref,),
+    ) as c:
+        row = await c.fetchone()
+    if row:
+        return row["id"]
+    async with db.execute(
+        "SELECT id FROM robots WHERE id = ? OR lower(name) = lower(?) LIMIT 1",
+        (robot_ref, robot_ref),
+    ) as c:
+        row = await c.fetchone()
+    return row["id"] if row else None
 
 async def _pick_preview_server(db, prefer_id: Optional[str] = None):
     """Return a LiveKit server row for a preview: a preferred one if still present,
@@ -2010,15 +2035,18 @@ def _mint_lk(server, room, identity, name, publish: bool, ttl_min: int):
     )
 
 @app.post("/api/robots/{robot_id}/preview/start")
-async def preview_start(robot_id: str):
+async def preview_start(robot_id: str):
     """Operator dashboard: begin an on-demand live camera preview for a robot.
     Returns a SUBSCRIBE-only viewer token + the preview room."""
-    if not await get_production_mode():
-        return {"active": False, "reason": "production_mode_off"}
-    async with aiosqlite.connect(DB_PATH) as db:
-        db.row_factory = aiosqlite.Row
-        if not await _mirror_device_to_robot(db, robot_id):
-            raise HTTPException(404, "Robot not found")
+    if not await get_production_mode():
+        return {"active": False, "reason": "production_mode_off"}
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        robot_id = await _resolve_robot_reference(db, robot_id)
+        if not robot_id:
+            raise HTTPException(404, "Robot not found")
+        if not await _mirror_device_to_robot(db, robot_id):
+            raise HTTPException(404, "Robot not found")
         async with db.execute("SELECT * FROM previews WHERE robot_id = ?", (robot_id,)) as c:
             existing = await c.fetchone()
         server = await _pick_preview_server(db, existing["server_id"] if existing else None)
@@ -2043,11 +2071,15 @@ async def preview_start(robot_id: str):
             "identity": identity, "expires_in": PREVIEW_TTL_SECONDS}
 
 @app.post("/api/robots/{robot_id}/preview/keepalive")
-async def preview_keepalive(robot_id: str):
-    """Dashboard pings while the operator is watching, to keep the preview alive."""
-    expires = (datetime.utcnow() + timedelta(seconds=PREVIEW_TTL_SECONDS)).isoformat()
-    async with aiosqlite.connect(DB_PATH) as db:
-        cur = await db.execute("UPDATE previews SET expires_at = ? WHERE robot_id = ?", (expires, robot_id))
+async def preview_keepalive(robot_id: str):
+    """Dashboard pings while the operator is watching, to keep the preview alive."""
+    expires = (datetime.utcnow() + timedelta(seconds=PREVIEW_TTL_SECONDS)).isoformat()
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        robot_id = await _resolve_robot_reference(db, robot_id)
+        if not robot_id:
+            return {"active": False}
+        cur = await db.execute("UPDATE previews SET expires_at = ? WHERE robot_id = ?", (expires, robot_id))
         await db.commit()
         if cur.rowcount == 0:
             return {"active": False}
@@ -2055,10 +2087,14 @@ async def preview_keepalive(robot_id: str):
     return {"active": True, "expires_in": PREVIEW_TTL_SECONDS}
 
 @app.post("/api/robots/{robot_id}/preview/stop")
-async def preview_stop(robot_id: str):
-    """Dashboard closed / operator stopped watching -> end the preview now."""
-    async with aiosqlite.connect(DB_PATH) as db:
-        await db.execute("DELETE FROM previews WHERE robot_id = ?", (robot_id,))
+async def preview_stop(robot_id: str):
+    """Dashboard closed / operator stopped watching -> end the preview now."""
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        robot_id = await _resolve_robot_reference(db, robot_id)
+        if not robot_id:
+            return {"stopped": False}
+        await db.execute("DELETE FROM previews WHERE robot_id = ?", (robot_id,))
         await db.commit()
     await _log_history("preview", "robot", robot_id, "stop", "operator")
     return {"stopped": True}
@@ -2068,11 +2104,14 @@ async def preview_agent(robot_id: str, authorization: Optional[str] = Header(def
     """The ROBOT polls this. While an operator preview is active it returns a
     PUBLISH token + room so the Pi opens its cam and joins; otherwise
     {active:false} so the Pi stops publishing. Enrolled-device auth."""
-    if not await _authorize_fleet(authorization):
-        raise HTTPException(401, "Invalid or missing device token")
-    async with aiosqlite.connect(DB_PATH) as db:
-        db.row_factory = aiosqlite.Row
-        async with db.execute("SELECT * FROM previews WHERE robot_id = ?", (robot_id,)) as c:
+    if not await _authorize_fleet(authorization):
+        raise HTTPException(401, "Invalid or missing device token")
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        robot_id = await _resolve_robot_reference(db, robot_id)
+        if not robot_id:
+            return {"active": False}
+        async with db.execute("SELECT * FROM previews WHERE robot_id = ?", (robot_id,)) as c:
             row = await c.fetchone()
         if not _preview_active(row):
             return {"active": False}

package/packages/robopark/scheduler/preview_agent.py

@@ -302,19 +302,27 @@ def _get_lan_ip() -> Optional[str]:
         return None
 
 
-async def _send_heartbeat(scheduler_url: str, device_id: str, token: str) -> Optional[bool]:
-    try:
-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                f"{scheduler_url.rstrip('/')}/api/devices/{device_id}/heartbeat",
-                json={"status": "online", "ip": _get_lan_ip(), "device_inventory": _get_device_inventory()},
-                headers={"Authorization": f"Bearer {token}"},
-                timeout=10.0,
-            )
-            response.raise_for_status()
-            return bool(response.json().get("production_mode", False))
-    except Exception as e:
-        logger.debug(f"heartbeat failed: {e}")
+async def _send_heartbeat(scheduler_url: str, device_id: str, token: str) -> Optional[bool]:
+    try:
+        inventory = _get_device_inventory()
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{scheduler_url.rstrip('/')}/api/devices/{device_id}/heartbeat",
+                json={"status": "online", "ip": _get_lan_ip(), "device_inventory": inventory},
+                headers={"Authorization": f"Bearer {token}"},
+                timeout=10.0,
+            )
+            response.raise_for_status()
+            logger.info(
+                "heartbeat accepted: inventory source=%s camera=%d mic=%d speaker=%d",
+                inventory.get("source", "local"),
+                len(inventory.get("video", [])),
+                len(inventory.get("audio_input", [])),
+                len(inventory.get("audio_output", [])),
+            )
+            return bool(response.json().get("production_mode", False))
+    except Exception as e:
+        logger.warning(f"heartbeat failed: {e}")
     return None