infinicode 2.8.60 → 2.8.62

package/dist/robopark/auto-start.js

@@ -74,9 +74,11 @@ Wants=network-online.target
 Type=simple
 ExecStart=${service.command} ${service.args.map(shellQuote).join(' ')}
 WorkingDirectory=${service.workingDir ?? homedir()}
-Restart=always
-RestartSec=5
-${envLines}
+Restart=always
+RestartSec=5
+KillMode=control-group
+TimeoutStopSec=10
+${envLines}
 
 [Install]
 WantedBy=multi-user.target

package/dist/robopark/robot-runtime.js

@@ -126,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}`)));
@@ -146,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 () => {
@@ -217,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

@@ -162,10 +162,10 @@ async function setupRobot(config, opts, ctx, internal) {
     // repointed the mesh connection while the scheduler (enroll/heartbeat/
     // preview-agent) silently kept talking to whatever hub auto-discovery
     // found (e.g. a real hub reachable over Tailscale), not the one requested.
-    const hubHost = new URL(hubUrl).hostname;
-    const schedulerUrl = network === 'tailscale'
-        ? `${hubUrl.replace(/\/+$/, '')}/robopark`
-        : `http://${hubHost}:${opts.schedulerPort ? parseInt(opts.schedulerPort, 10) : DEFAULT_SCHEDULER_PORT}`;
+    // Keep the scheduler private on the hub. Both LAN and Tailscale robots use
+    // the authenticated mesh proxy instead of depending on port 8080 binding,
+    // firewall rules, or a separately routable scheduler address.
+    const schedulerUrl = `${hubUrl.replace(/\/+$/, '')}/robopark`;
     // 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).

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

@@ -180,13 +180,10 @@ robotProgram
     .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 ?? (opts.tailscale
-            ? `${opts.hubUrl.replace(/\/+$/, '')}/robopark`
-            : `http://${hub.hostname}:8080`),
+        schedulerUrl: opts.schedulerUrl ?? `${opts.hubUrl.replace(/\/+$/, '')}/robopark`,
         token: opts.token,
         port: opts.port,
         network: opts.tailscale ? 'tailscale' : 'lan',

package/package.json

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

package/packages/robopark/vision/app_pi_clean.py

@@ -7,9 +7,10 @@ import os
 import sys
 import time
 import numpy as np
-import threading
-import requests
-import base64
+import threading
+import requests
+import base64
+import struct
 
 app = Flask(__name__)
 CORS(app)
@@ -20,6 +21,9 @@ camera = None
 audio_input_device = "default"
 audio_output_device = "default"
 ROBOVISION_AUDIO_URL = os.getenv("ROBOVISION_AUDIO_URL", "http://127.0.0.1:8000")
+_camera_inventory_cache = []
+_camera_inventory_cache_at = 0.0
+CAMERA_INVENTORY_CACHE_SECONDS = 30.0
 
 def _open_camera(index):
     # On Windows, cv2.VideoCapture(index) with no explicit backend can
@@ -318,13 +322,53 @@ def caption_mode():
 
 @app.route('/api/cameras', methods=['GET'])
 def list_cameras():
+    global _camera_inventory_cache, _camera_inventory_cache_at
+    now = time.monotonic()
+    if now - _camera_inventory_cache_at < CAMERA_INVENTORY_CACHE_SECONDS:
+        return jsonify({"cameras": _camera_inventory_cache, "current": current_camera_index})
+
     available = []
-    candidates = sorted(glob.glob('/dev/video*')) if sys.platform != 'win32' else list(range(4))
-    for candidate in candidates:
-        cap = _open_camera(candidate)
-        if cap.isOpened():
-            available.append({"index": candidate, "id": str(candidate), "name": f"Camera {candidate}", "backend": "v4l2" if sys.platform != 'win32' else "dshow"})
+    if sys.platform.startswith('linux'):
+        # Query capabilities without starting a stream. Opening every V4L2
+        # node through OpenCV also opens metadata/output nodes and can contend
+        # with the camera stream already owned by RoboVision.
+        import fcntl
+        vidioc_querycap = 0x80685600
+        video_capture = 0x00000001
+        video_capture_mplane = 0x00001000
+        device_caps_flag = 0x80000000
+        for candidate in sorted(glob.glob('/dev/video*')):
+            fd = None
+            try:
+                fd = os.open(candidate, os.O_RDONLY | os.O_NONBLOCK)
+                capability = bytearray(104)
+                fcntl.ioctl(fd, vidioc_querycap, capability, True)
+                capabilities = struct.unpack_from('=I', capability, 84)[0]
+                device_caps = struct.unpack_from('=I', capability, 88)[0]
+                effective = device_caps if capabilities & device_caps_flag else capabilities
+                if not effective & (video_capture | video_capture_mplane):
+                    continue
+                card = bytes(capability[16:48]).split(b'\0', 1)[0].decode('utf-8', 'replace')
+                available.append({
+                    "index": candidate,
+                    "id": candidate,
+                    "name": card or f"Camera {candidate}",
+                    "backend": "v4l2",
+                })
+            except (OSError, ValueError):
+                continue
+            finally:
+                if fd is not None:
+                    os.close(fd)
+    else:
+        for candidate in range(4):
+            cap = _open_camera(candidate)
+            if cap.isOpened():
+                available.append({"index": candidate, "id": str(candidate), "name": f"Camera {candidate}", "backend": "dshow"})
             cap.release()
+
+    _camera_inventory_cache = available
+    _camera_inventory_cache_at = now
     return jsonify({"cameras": available, "current": current_camera_index})
 
 @app.route('/api/camera/switch', methods=['POST'])
@@ -374,11 +418,6 @@ def _audio_inventory():
 @app.route('/api/media/inventory', methods=['GET'])
 def media_inventory():
     cameras = list_cameras().get_json().get("cameras", [])
-    if not cameras and sys.platform != 'win32':
-        # The active V4L2 handle may reject a second probe. The node path is
-        # still a valid selectable camera and is safer than hiding it.
-        cameras = [{"id": path, "index": path, "name": f"Camera {path}", "backend": "v4l2"}
-                   for path in sorted(glob.glob('/dev/video*'))]
     inputs, outputs, audio_state = _audio_inventory()
     return jsonify({
         "video": [{"id": "auto", "name": "Auto detect"}, {"id": "none", "name": "Disable camera"}] + cameras,