infinicode 2.8.59 → 2.8.61

package/dist/robopark/auto-start.js

@@ -73,17 +73,27 @@ 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}
+WorkingDirectory=${service.workingDir ?? homedir()}
+Restart=always
+RestartSec=5
+KillMode=control-group
+TimeoutStopSec=10
+${envLines}
 
 [Install]
 WantedBy=multi-user.target
 `;
     try {
         writeFileSync(unitPath, unit, 'utf8');
-        return { ok: true, message: `wrote systemd unit ${unitPath}. Run: systemctl enable --now ${unitName}` };
+        const reload = spawnSync('systemctl', ['daemon-reload'], { encoding: 'utf8' });
+        if (reload.status !== 0) {
+            return { ok: false, message: `wrote ${unitPath}, but systemctl daemon-reload failed: ${reload.stderr || reload.stdout}` };
+        }
+        const enabled = spawnSync('systemctl', ['enable', '--now', unitName], { encoding: 'utf8' });
+        if (enabled.status !== 0) {
+            return { ok: false, message: `wrote ${unitPath}, but systemctl enable --now failed: ${enabled.stderr || enabled.stdout}` };
+        }
+        return { ok: true, message: `enabled and started systemd unit ${unitName}` };
     }
     catch (e) {
         return { ok: false, message: `could not write ${unitPath}: ${e instanceof Error ? e.message : String(e)}` };

package/dist/robopark/robot-runtime.js

@@ -101,8 +101,6 @@ export async function roboparkRobotRuntime(opts) {
         '--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 = {
@@ -113,6 +111,13 @@ export async function roboparkRobotRuntime(opts) {
         // Keep this in the child environment, never in the persisted robot config.
         env: {
             ROBOPARK_MESH_TOKEN: opts.token,
+            // Keep internal service wiring out of the Commander argument boundary.
+            // This also lets preview start while RoboVision is still warming up.
+            ROBOVISION_URL: opts.vision !== false ? 'http://127.0.0.1:5000' : '',
+            ROBOVISION_MEDIA_URL: opts.vision !== false
+                ? 'http://127.0.0.1:5000/api/media/inventory'
+                : '',
+            ROBOVISION_CAMERA: opts.vision !== false ? '1' : '0',
             // Inventory changes should reach the Control Center promptly.
             HEARTBEAT_INTERVAL: '5',
         },
@@ -121,6 +126,8 @@ export async function roboparkRobotRuntime(opts) {
         const child = spawn(entry.command, entry.args, {
             env: { ...process.env, ...entry.env, ROBOPARK_ROBOT_RUNTIME: '1' },
             stdio: runtimeLog(`robot-${opts.name}-${entry.label}`, foreground),
+            // Give each launcher and its Python descendants one process group.
+            detached: process.platform !== 'win32',
         });
         entry.child = child;
         child.on('error', error => console.error(chalk.red(`  ${entry.label} failed to start: ${error.message}`)));
@@ -141,23 +148,34 @@ export async function roboparkRobotRuntime(opts) {
                 start(entry); }, RESTART_DELAY_MS);
         });
     };
+    const signalChild = (entry, signal) => {
+        const pid = entry.child?.pid;
+        if (!pid)
+            return;
+        try {
+            if (process.platform === 'win32')
+                entry.child?.kill(signal);
+            else
+                process.kill(-pid, signal);
+        }
+        catch {
+            // It may have exited between the liveness check and signal.
+        }
+    };
     const stopChild = async (entry) => {
         const child = entry.child;
         if (!child)
             return;
         await new Promise(resolve => {
-            const timer = setTimeout(resolve, 5_000);
+            const timer = setTimeout(() => {
+                signalChild(entry, 'SIGKILL');
+                resolve();
+            }, 5_000);
             child.once('exit', () => {
                 clearTimeout(timer);
                 resolve();
             });
-            try {
-                child.kill('SIGTERM');
-            }
-            catch {
-                clearTimeout(timer);
-                resolve();
-            }
+            signalChild(entry, 'SIGTERM');
         });
     };
     const recycleAfterMeshUpdate = async () => {
@@ -212,7 +230,7 @@ export async function roboparkRobotRuntime(opts) {
     const shutdown = () => {
         stopping = true;
         for (const entry of [...children, preview])
-            entry.child?.kill('SIGTERM');
+            signalChild(entry, 'SIGTERM');
     };
     process.once('SIGINT', shutdown);
     process.once('SIGTERM', shutdown);

package/dist/robopark/setup.js

@@ -189,7 +189,10 @@ async function setupRobot(config, opts, ctx, internal) {
     console.log('  ' + chalk.cyan(`robopark ${runtimeArgs.join(' ')}`));
     console.log(chalk.dim(`  network: ${network} (scheduler: ${schedulerUrl})`));
     console.log();
-    if (opts.start) {
+    // On Linux, registerAutoStart enables and starts the systemd service. Do not
+    // also launch a detached copy that can leave mesh healthy while preview is
+    // duplicated, blocked, or running under a different HOME.
+    if (opts.start && !(opts.autoStart && process.platform === 'linux')) {
         const robotArgv = [process.execPath, process.argv[1], ...runtimeArgs];
         console.log(chalk.dim('  starting unified robot runtime…'));
         runDetached(robotArgv[0], robotArgv.slice(1));

package/dist/robopark/stop-all.js

@@ -77,6 +77,24 @@ function stopAllUnix() {
     const removedUnits = [];
     const errors = [];
     const self = process.pid;
+    if (process.platform === 'linux') {
+        // Disable restart policies before killing processes so systemd cannot
+        // repopulate the ports between process discovery and cleanup.
+        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) {
+            const disable = spawnSync('systemctl', ['disable', '--now', unit], { encoding: 'utf8' });
+            if (disable.status === 0)
+                removedUnits.push(unit);
+            else
+                errors.push(`systemctl disable --now ${unit}: ${(disable.stderr || '').trim()}`);
+        }
+        if (units.length)
+            spawnSync('systemctl', ['daemon-reload'], { encoding: 'utf8' });
+    }
     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('|'));
@@ -96,7 +114,7 @@ function stopAllUnix() {
     }
     // 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]) {
+    for (const port of [47913, 47921, 47922, 8080, 5000, 5057, 8000]) {
         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) {
@@ -112,21 +130,6 @@ function stopAllUnix() {
         // 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

@@ -135,6 +135,7 @@ program
     .option('--enrollment-token <token>', 'one-time enrollment token')
     .option('--video-device <dev>', 'camera: auto, /dev/video0, 0, picamera', 'auto')
     .option('--audio-device <dev>', 'microphone: default, none, or name/index', 'default')
+    .option('--robovision-url <url>', 'RoboVision base URL used for camera streaming and hardware inventory')
     .option('--width <px>', 'video width', '640')
     .option('--height <px>', 'video height', '480')
     .option('--fps <n>', 'video fps', '15')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.59",
+  "version": "2.8.61",
   "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/preview_agent.py

@@ -337,7 +337,9 @@ def _get_lan_ip() -> Optional[str]:
         return None
 
 
-async def _send_heartbeat(scheduler_url: str, device_id: str, token: str) -> Optional[bool]:
+async def _send_heartbeat(
+    scheduler_url: str, device_id: str, token: str
+) -> tuple[Optional[bool], bool]:
     try:
         inventory = _get_device_inventory()
         headers = {"Authorization": f"Bearer {token}", **_mesh_proxy_headers()}
@@ -348,6 +350,13 @@ async def _send_heartbeat(scheduler_url: str, device_id: str, token: str) -> Opt
                 headers=headers,
                 timeout=10.0,
             )
+            if response.status_code in (401, 404):
+                logger.warning(
+                    "heartbeat credentials rejected for %s (%s)",
+                    device_id,
+                    response.status_code,
+                )
+                return None, False
             response.raise_for_status()
             logger.info(
                 "heartbeat accepted: inventory source=%s camera=%d mic=%d speaker=%d",
@@ -356,10 +365,10 @@ async def _send_heartbeat(scheduler_url: str, device_id: str, token: str) -> Opt
                 len(inventory.get("audio_input", [])),
                 len(inventory.get("audio_output", [])),
             )
-            return bool(response.json().get("production_mode", False))
+            return bool(response.json().get("production_mode", False)), True
     except Exception as e:
         logger.warning(f"heartbeat failed: {e}")
-    return None
+    return None, True
 
 
 @dataclass
@@ -420,18 +429,34 @@ class PreviewAgent:
         self._last_device_config_poll = 0.0
         self._motion_reference = None
         self._last_motion_sample = 0.0
-        self._motion_capture: Optional[VideoCapture] = None
-        self._motion_capture_lock = asyncio.Lock()
-
+        self._motion_capture: Optional[VideoCapture] = None
+        self._motion_capture_lock = asyncio.Lock()
+        self._mesh_bootstrap_ready = False
+        self._next_mesh_bootstrap = 0.0
+
+    async def _ensure_mesh_identity(self) -> bool:
+        if not _mesh_proxy_headers():
+            return bool(self.device_id and self.device_token)
+        now = time.monotonic()
+        if self._mesh_bootstrap_ready:
+            return True
+        if now < self._next_mesh_bootstrap:
+            return False
+        self._next_mesh_bootstrap = now + 5.0
+        try:
+            self.device_id, self.device_token = await _bootstrap_mesh_device(
+                self.scheduler_url, self.robot_id
+            )
+            self._mesh_bootstrap_ready = True
+            return True
+        except Exception as exc:
+            logger.warning("mesh device bootstrap failed: %s", exc)
+            return False
+
     async def run(self) -> None:
         enrollment_token = os.getenv("ENROLLMENT_TOKEN") or self.enrollment_token
         if _mesh_proxy_headers():
-            try:
-                self.device_id, self.device_token = await _bootstrap_mesh_device(
-                    self.scheduler_url, self.robot_id
-                )
-            except Exception as exc:
-                logger.warning("mesh device bootstrap failed: %s", exc)
+            await self._ensure_mesh_identity()
 
         if not self.device_token and enrollment_token:
             self.device_token = await _enroll(self.scheduler_url, enrollment_token, self.robot_id)
@@ -747,13 +772,18 @@ class PreviewAgent:
         await asyncio.to_thread(_play_audio_effect, self.audio_output_device, "disconnect")
         self._current_state = PreviewState()
 
-    async def _heartbeat_loop(self) -> None:
-        while not self._shutdown.is_set():
-            if self.device_id and self.device_token:
-                production_mode = await _send_heartbeat(
-                    self.scheduler_url, self.device_id, self.device_token
-                )
-                if production_mode is not None:
+    async def _heartbeat_loop(self) -> None:
+        while not self._shutdown.is_set():
+            if _mesh_proxy_headers() and not self._mesh_bootstrap_ready:
+                await self._ensure_mesh_identity()
+            if self.device_id and self.device_token:
+                production_mode, credentials_ok = await _send_heartbeat(
+                    self.scheduler_url, self.device_id, self.device_token
+                )
+                if not credentials_ok:
+                    self._mesh_bootstrap_ready = False
+                    self._next_mesh_bootstrap = 0.0
+                if production_mode is not None:
                     self.production_mode = production_mode
                     if not production_mode and self._vision_session_id:
                         await self._end_vision_session()
@@ -1674,7 +1704,9 @@ def main() -> None:
         "video_device": args.video_device,
         "audio_device": args.audio_device,
         "robovision_url": args.robovision_url or os.getenv("ROBOVISION_URL", "http://127.0.0.1:5000"),
-        "use_robovision_camera": bool(args.robovision_url),
+        "use_robovision_camera": bool(args.robovision_url) or os.getenv(
+            "ROBOVISION_CAMERA", ""
+        ).lower() in ("1", "true", "yes", "on"),
         "video_width": args.width,
         "video_height": args.height,
         "video_fps": args.fps,