infinicode 2.6.1 → 2.7.0

package/dist/kernel/federation/telemetry.d.ts

@@ -7,6 +7,11 @@ export declare class TelemetryCollector {
     /** Per-core % from a single snapshot (approximate, no per-core delta kept). */
     private perCore;
     private network;
+    /** Usage of the primary filesystem (root on POSIX, system drive on Windows) via
+     *  fs.statfs (Node ≥18.15, no native deps). Never throws. */
+    private diskUsage;
+    /** CPU temperature in °C from the Linux thermal zone (Pi/SBC). null elsewhere. */
+    private temperatureC;
     collect(): HardwareSnapshot;
 }
 /** A 0–100 load figure derived from a snapshot (used by the compute router). */

package/dist/kernel/federation/telemetry.js

@@ -9,6 +9,7 @@
  * on a fixed cadence (~1 Hz) so deltas are meaningful.
  */
 import os from 'node:os';
+import { readFileSync, statfsSync } from 'node:fs';
 export class TelemetryCollector {
     lastCpu = null;
     lastNet = new Map();
@@ -44,22 +45,83 @@ export class TelemetryCollector {
         });
     }
     network() {
-        // node:os doesn't expose byte counters; report interface presence with
-        // zeroed rates by default. A platform collector can override later.
-        const ifaces = os.networkInterfaces();
+        // Real rx/tx byte-rate deltas where the kernel exposes counters. Linux lists
+        // per-interface byte totals in /proc/net/dev; we diff against the previous
+        // tick. On platforms without it (e.g. Windows) rates stay 0 but interface
+        // presence is still reported. Never throws — a read failure degrades to the
+        // os.networkInterfaces() presence list with zeroed rates.
+        const now = Date.now();
         const out = [];
+        let counters = null;
+        if (os.platform() === 'linux') {
+            try {
+                counters = new Map();
+                for (const line of readFileSync('/proc/net/dev', 'utf8').split('\n')) {
+                    const m = line.match(/^\s*([^:]+):\s*(.+)$/);
+                    if (!m)
+                        continue;
+                    const cols = m[2].trim().split(/\s+/).map(Number);
+                    // Receive bytes = column 0, Transmit bytes = column 8.
+                    counters.set(m[1].trim(), { rx: cols[0] || 0, tx: cols[8] || 0 });
+                }
+            }
+            catch {
+                counters = null;
+            }
+        }
+        const ifaces = os.networkInterfaces();
         for (const [name, addrs] of Object.entries(ifaces)) {
             if (!addrs || addrs.every(a => a.internal))
                 continue;
             const prev = this.lastNet.get(name);
-            const now = Date.now();
-            // Without kernel counters we can't compute a true rate; keep 0 but retain
-            // the hook so a native collector can populate rx/tx deltas.
-            out.push({ name, rxBytesPerSec: 0, txBytesPerSec: 0 });
-            this.lastNet.set(name, { rx: prev?.rx ?? 0, tx: prev?.tx ?? 0, at: now });
+            const cur = counters?.get(name);
+            let rxRate = 0;
+            let txRate = 0;
+            if (cur && prev && prev.at) {
+                const dt = (now - prev.at) / 1000;
+                if (dt > 0) {
+                    rxRate = Math.max(0, Math.round((cur.rx - prev.rx) / dt));
+                    txRate = Math.max(0, Math.round((cur.tx - prev.tx) / dt));
+                }
+            }
+            out.push({ name, rxBytesPerSec: rxRate, txBytesPerSec: txRate });
+            this.lastNet.set(name, { rx: cur?.rx ?? 0, tx: cur?.tx ?? 0, at: now });
         }
         return { interfaces: out };
     }
+    /** Usage of the primary filesystem (root on POSIX, system drive on Windows) via
+     *  fs.statfs (Node ≥18.15, no native deps). Never throws. */
+    diskUsage() {
+        const path = os.platform() === 'win32'
+            ? (process.env.SystemDrive ? process.env.SystemDrive + '\\' : 'C:\\')
+            : '/';
+        try {
+            const st = statfsSync(path);
+            const totalBytes = Number(st.blocks) * Number(st.bsize);
+            const freeBytes = Number(st.bavail) * Number(st.bsize);
+            const usedBytes = Math.max(0, totalBytes - freeBytes);
+            const percent = totalBytes > 0 ? Math.round((usedBytes / totalBytes) * 100) : 0;
+            return { mounts: [{ path, totalBytes, usedBytes, percent }] };
+        }
+        catch {
+            return { mounts: [] };
+        }
+    }
+    /** CPU temperature in °C from the Linux thermal zone (Pi/SBC). null elsewhere. */
+    temperatureC() {
+        if (os.platform() !== 'linux')
+            return null;
+        try {
+            const milli = Number(readFileSync('/sys/class/thermal/thermal_zone0/temp', 'utf8').trim());
+            if (!Number.isFinite(milli) || milli <= 0)
+                return null;
+            // Usually millidegrees (47000 = 47°C); some SoCs report whole °C.
+            return Math.round((milli > 1000 ? milli / 1000 : milli) * 10) / 10;
+        }
+        catch {
+            return null;
+        }
+    }
     collect() {
         const total = os.totalmem();
         const free = os.freemem();
@@ -80,7 +142,7 @@ export class TelemetryCollector {
                 percent: total > 0 ? Math.round((used / total) * 100) : 0,
             },
             gpu: null, // populated by an optional platform GPU probe later
-            disk: { mounts: [] },
+            disk: this.diskUsage(),
             network: this.network(),
             system: {
                 hostname: os.hostname(),
@@ -90,6 +152,7 @@ export class TelemetryCollector {
                 kernelRelease: os.release(),
             },
             processes: [],
+            temperatureC: this.temperatureC(),
             timestamp: Date.now(),
         };
     }

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

@@ -16,7 +16,28 @@
 import { createServer } from 'node:http';
 import { createServer as createHttpsServer } from 'node:https';
 import { timingSafeEqual } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { frameToSSE, parseSSE } from './protocol.js';
+/** Read the livekit-client UMD bundle from the installed dependency, once.
+ *  Returns null (cached) if the package isn't present — the dashboard then
+ *  falls back to an idle camera panel instead of erroring. */
+let _lkUmd;
+function loadLiveKitUmd() {
+    if (_lkUmd !== undefined)
+        return _lkUmd;
+    try {
+        const require = createRequire(import.meta.url);
+        // The package's exports map blocks deep subpaths, but its main/require entry
+        // IS the UMD bundle — so a bare resolve returns dist/livekit-client.umd.js.
+        const file = require.resolve('livekit-client');
+        _lkUmd = readFileSync(file, 'utf8');
+    }
+    catch {
+        _lkUmd = null;
+    }
+    return _lkUmd;
+}
 /** Constant-time string compare — avoids leaking the token via response timing. */
 function safeEqual(a, b) {
     const ab = Buffer.from(a);
@@ -131,6 +152,20 @@ export class MeshServer {
             res.end(this.opts.dashboardHtml);
             return;
         }
+        // LiveKit browser SDK, served from the installed dependency so the Park
+        // tab can subscribe to a robot's live camera track. Loaded by the dashboard
+        // with the ?token= appended (so it passes the auth gate above). Optional:
+        // if livekit-client isn't installed, the dashboard just shows an idle cam.
+        if (req.method === 'GET' && path === '/vendor/livekit-client.umd.js') {
+            const js = loadLiveKitUmd();
+            if (!js) {
+                res.writeHead(404).end('livekit-client not installed');
+                return;
+            }
+            res.writeHead(200, { 'content-type': 'application/javascript; charset=utf-8', 'cache-control': 'public, max-age=86400' });
+            res.end(js);
+            return;
+        }
         if (req.method === 'GET' && path === '/fed/status') {
             res.writeHead(200, { 'content-type': 'application/json' });
             res.end(JSON.stringify(this.opts.getStatus?.() ?? {}));

package/dist/kernel/federation/types.d.ts

@@ -107,6 +107,9 @@ export interface HardwareSnapshot {
         cpuPercent: number;
         memoryBytes: number;
     }>;
+    /** CPU package temperature in °C (Pi thermal zone / lm-sensors). null when the
+     *  platform doesn't expose it (e.g. most Windows hosts). */
+    temperatureC?: number | null;
     timestamp: number;
 }
 /** Node status entry consumed by the mesh map (neutral form of nodes.status). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.6.1",
+  "version": "2.7.0",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",
@@ -75,6 +75,7 @@
     "conf": "^12.0.0",
     "execa": "^9.3.0",
     "inquirer": "^9.2.23",
+    "livekit-client": "^2.20.1",
     "mitt": "^3.0.1",
     "nanoid": "^5.0.7",
     "node-fetch": "^3.3.2",
@@ -88,12 +89,12 @@
     "typescript": "^5.4.5"
   },
   "optionalDependencies": {
-    "playwright": "^1.47.0",
-    "infinicode-tui-win32-x64": "^2.3.0",
-    "infinicode-tui-win32-arm64": "^2.3.0",
-    "infinicode-tui-linux-x64": "^2.3.0",
-    "infinicode-tui-linux-arm64": "^2.3.0",
+    "infinicode-tui-darwin-arm64": "^2.3.0",
     "infinicode-tui-darwin-x64": "^2.3.0",
-    "infinicode-tui-darwin-arm64": "^2.3.0"
+    "infinicode-tui-linux-arm64": "^2.3.0",
+    "infinicode-tui-linux-x64": "^2.3.0",
+    "infinicode-tui-win32-arm64": "^2.3.0",
+    "infinicode-tui-win32-x64": "^2.3.0",
+    "playwright": "^1.47.0"
   }
 }