infinicode 2.8.65 → 2.8.66

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

@@ -14,10 +14,9 @@
  *             for its cam / mic / speaker / hardware drawer)
  *   Sessions & Telemetry — RoboPark scheduler stats + production_mode + controls
  *
- * The Park cam panel targets a LiveKit video track: it fetches a per-robot stream
- * token from /robopark/api/robots/:id/stream and, when the livekit-client SDK and
- * a published track are present, subscribes; otherwise it shows a styled preview.
- * That token/track is produced by the robot-side RoboPark plugin.
+ * The Park cam panel relays RoboVisionAI_PI's existing MJPEG feed through the
+ * authenticated mesh. LiveKit remains the voice transport but is deliberately
+ * not used for dashboard video, avoiding camera ownership conflicts on robots.
  *
  * Kept free of backticks and ${...} so the whole page fits inside this TS
  * template literal without escaping; the client JS uses string concatenation.
@@ -5446,7 +5445,12 @@ button.act:disabled{opacity:0.5;cursor:default;}
     // ── on-demand operator preview: open the robot's cam without a scene-detection session ──
     function updateGoLive(){ var b=$('pk-golive'); if(b){ b.textContent = previewOn?'■ Stop live':'▶ Go live'; b.classList.toggle('danger', previewOn); } }
     function goLive(n){ if(previewOn) stopPreview(n); else startPreview(n); }
-    function startPreview(n){
+    function startPreview(n){
+      previewOn=true; updateGoLive();
+      if(lkRoom){ try{ lkRoom.disconnect(); }catch(e){} lkRoom=null; }
+      idleCam('connecting');
+      tryVisionOverlay(n, true);
+      return;
       previewOn=true; updateGoLive();
       var note=$('pk-golivenote'); if(note) note.textContent='requesting preview…';
       if(lkRoom){ try{ lkRoom.disconnect(); }catch(e){} lkRoom=null; }  // drop any session cam first
@@ -5463,7 +5467,14 @@ button.act:disabled{opacity:0.5;cursor:default;}
         })
         .catch(function(e){ idleCam('unreachable'); if(note) note.textContent='preview request failed'; if(window.console) console.error('RoboPark preview request failed',e); previewOn=false; updateGoLive(); });
     }
-    function stopPreview(n){
+    function stopPreview(n){
+      previewOn=false; updateGoLive();
+      if(previewTimer){ clearInterval(previewTimer); previewTimer=null; }
+      if(lkRoom){ try{ lkRoom.disconnect(); }catch(e){} lkRoom=null; }
+      stopVision();
+      var directNote=$('pk-golivenote'); if(directNote) directNote.textContent='';
+      idleCam('idle');
+      return;
       previewOn=false; updateGoLive();
       if(previewTimer){ clearInterval(previewTimer); previewTimer=null; }
       if(lkRoom){ try{ lkRoom.disconnect(); }catch(e){} lkRoom=null; }
@@ -5478,6 +5489,15 @@ button.act:disabled{opacity:0.5;cursor:default;}
     // server is opt-in because running it beside preview_agent would open the
     // same Windows camera twice and make both feeds unreliable.
     function tryVisionOverlay(n, force){
+      var directImg=$('pk-vision-img'); if(!directImg) return;
+      var directRef=n.nodeId||n.id||n.name;
+      if(!directRef){ visionOn=false; directImg.src=''; directImg.style.display='none'; return; }
+      var directCamNote=$('pk-camnote'), directLiveNote=$('pk-golivenote'), directRes=$('pk-camres');
+      visionOn=true;
+      directImg.onerror=function(){ visionOn=false; directImg.style.display='none'; directImg.src=''; if(directCamNote) directCamNote.textContent='RoboVision feed unavailable on robot'; if(directLiveNote) directLiveNote.textContent='camera unavailable'; if(directRes) directRes.textContent='OFFLINE'; };
+      directImg.onload=function(){ directImg.style.display='block'; if(directCamNote) directCamNote.textContent='live camera via RoboVision mesh relay'; if(directLiveNote) directLiveNote.textContent='live'; if(directRes) directRes.textContent='LIVE'; };
+      directImg.src='/fed/media/robots/'+encodeURIComponent(directRef)+'/video_feed'+QS+(QS?'&':'?')+'_='+Date.now();
+      return;
       var img=$('pk-vision-img'); if(!img) return;
       if(!force && String(window.localStorage.getItem('robopark.visionOverlay')||'').toLowerCase()!=='true'){
         visionOn=false; img.src=''; img.style.display='none'; return;
@@ -6084,7 +6104,10 @@ button.act:disabled{opacity:0.5;cursor:default;}
     function setFill(id,pct){ var e=$(id); if(!e||pct==null) return; e.style.width=Math.max(2,Math.min(100,pct))+'%'; e.style.background=pct>=75?'var(--bad)':pct>=45?'var(--warn)':'var(--gold-bright)'; }
 
     // ── cam: target a LiveKit track; fall back to a styled preview ──
-    function startCam(n){
+    function startCam(n){
+      idleCam('connecting');
+      tryVisionOverlay(n, true);
+      return;
       var note=$('pk-camnote');
       camAbort = ('AbortController' in window)?new AbortController():null;
       idleCam('connecting');

package/dist/kernel/federation/federation.js

@@ -86,6 +86,7 @@ export class Federation {
             logger,
             getManifest: () => buildManifest(identity, this.describeWithBackends()),
             getNodes: () => this.nodeStatuses(),
+            getPeers: () => this.peers(),
             getStatus: () => this.statusSnapshot(),
             runCommand: (input) => this.deps.kernel.command(input),
             commandGate: options.commandGate,

package/dist/kernel/federation/transport-http.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from '../types.js';
-import type { FederationEnvelope, NodeManifest, StreamFrame } from './types.js';
+import type { FederationEnvelope, NodeManifest, PeerInfo, StreamFrame } from './types.js';
 export type RpcHandler = (env: FederationEnvelope, remote: string) => Promise<FederationEnvelope | void>;
 export interface MeshServerOptions {
     host?: string;
@@ -9,6 +9,8 @@ export interface MeshServerOptions {
     getManifest: () => NodeManifest;
     /** Optional: full mesh view (self + peers) for the GET /fed/nodes probe. */
     getNodes?: () => unknown;
+    /** Connected peers and their reachable mesh URLs. */
+    getPeers?: () => PeerInfo[];
     /** Optional: consolidated fleet snapshot (self + nodes + hardware + roles +
      *  runs + recent activity) for the dashboard and `robopark fleet` (GET /fed/status). */
     getStatus?: () => unknown;
@@ -50,6 +52,9 @@ export declare class MeshServer {
     private seq;
     constructor(opts: MeshServerOptions);
     get streamCount(): number;
+    private streamHttp;
+    private streamLocalRoboVision;
+    private streamPeerRoboVision;
     start(): Promise<void>;
     /** Proxy a dashboard request to the RoboPark scheduler (product data). */
     private proxyToScheduler;

package/dist/kernel/federation/transport-http.js

@@ -20,6 +20,7 @@ import { promisify } from 'node:util';
 import { timingSafeEqual } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
+import { once } from 'node:events';
 import { frameToSSE, parseSSE } from './protocol.js';
 const execFileAsync = promisify(execFile);
 /** Read the livekit-client UMD bundle from the installed dependency, once.
@@ -82,6 +83,68 @@ export class MeshServer {
     get streamCount() {
         return this.sse.size;
     }
+    async streamHttp(req, res, target, headers = {}) {
+        const ctrl = new AbortController();
+        req.once('close', () => ctrl.abort());
+        try {
+            const upstream = await fetch(target, { headers, signal: ctrl.signal });
+            if (!upstream.ok || !upstream.body) {
+                const detail = await upstream.text().catch(() => '');
+                res.writeHead(upstream.status, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' });
+                res.end(detail || `media upstream returned ${upstream.status}`);
+                return;
+            }
+            res.writeHead(200, {
+                'content-type': upstream.headers.get('content-type') ?? 'multipart/x-mixed-replace; boundary=frame',
+                'cache-control': 'no-store, no-cache, must-revalidate',
+                pragma: 'no-cache',
+                connection: 'keep-alive',
+            });
+            const reader = upstream.body.getReader();
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done || res.writableEnded)
+                    break;
+                if (!res.write(Buffer.from(value)))
+                    await once(res, 'drain');
+            }
+            if (!res.writableEnded)
+                res.end();
+        }
+        catch (err) {
+            if (ctrl.signal.aborted)
+                return;
+            if (!res.headersSent) {
+                res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' });
+                res.end(`robot camera unavailable: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            else if (!res.writableEnded) {
+                res.end();
+            }
+        }
+    }
+    streamLocalRoboVision(req, res) {
+        void this.streamHttp(req, res, 'http://127.0.0.1:5000/video_feed');
+    }
+    streamPeerRoboVision(req, res, nodeRef) {
+        const ref = decodeURIComponent(nodeRef).toLowerCase();
+        const self = this.opts.getManifest();
+        if (self.nodeId.toLowerCase() === ref || self.displayName.toLowerCase() === ref) {
+            this.streamLocalRoboVision(req, res);
+            return;
+        }
+        const peer = (this.opts.getPeers?.() ?? []).find(candidate => candidate.connected &&
+            (candidate.nodeId.toLowerCase() === ref || candidate.displayName.toLowerCase() === ref));
+        if (!peer) {
+            res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' });
+            res.end(`connected robot mesh node not found: ${nodeRef}`);
+            return;
+        }
+        const headers = {};
+        if (this.opts.token)
+            headers.authorization = `Bearer ${this.opts.token}`;
+        void this.streamHttp(req, res, `${peer.url.replace(/\/+$/, '')}/fed/media/video_feed`, headers);
+    }
     async start() {
         const handler = (req, res) => this.handle(req, res);
         this.server = this.opts.tls
@@ -344,6 +407,18 @@ export class MeshServer {
             res.end(js);
             return;
         }
+        // RoboVision owns the robot camera. Satellites expose the existing local
+        // MJPEG feed, while the hub relays it over the authenticated mesh. This
+        // avoids opening /dev/video0 again in LiveKit and works across private LANs.
+        if (req.method === 'GET' && path === '/fed/media/video_feed') {
+            this.streamLocalRoboVision(req, res);
+            return;
+        }
+        const robotVideo = path.match(/^\/fed\/media\/robots\/([^/]+)\/video_feed$/);
+        if (req.method === 'GET' && robotVideo) {
+            this.streamPeerRoboVision(req, res, robotVideo[1]);
+            return;
+        }
         if (req.method === 'GET' && path === '/fed/status') {
             res.writeHead(200, { 'content-type': 'application/json' });
             res.end(JSON.stringify(this.opts.getStatus?.() ?? {}));

package/package.json

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