@remcp/runtime 0.2.200 → 0.2.202

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.200",
+  "version": "0.2.202",
   "description": "First-party ReMCP local device runtime: filesystem, terminal, computer-use, browser, diagnostics and document tools over MCP.",
   "type": "module",
   "license": "MIT",

package/src/tools/linux-temperature.mjs

@@ -0,0 +1,95 @@
+// Linux exposes multiple independent hardware temperature channels through hwmon and
+// thermal zones. Never stop at the first thermal zone: that hides real CPU/GPU/SSD data.
+import { readFile as kernelRead, readdir as kernelList } from 'node:fs/promises';
+import { nvidiaTemperatureReadings } from './nvidia-temperature.mjs';
+
+const CHIP = /^[A-Za-z0-9_.+-]{1,32}$/;
+const LABEL = /^[A-Za-z0-9_.:+#() -]{1,40}$/;
+const SAFE_NAME = /^[A-Za-z0-9_.:+#() -]{1,60}$/;
+const SENSOR_LIMIT = 64;
+
+export function linuxTemperatureValue(raw) {
+  const input = String(raw || '').trim();
+  if (!/^-?\d{1,7}$/.test(input)) return null;
+  const celsius = Number(input) / 1000;
+  return Number.isFinite(celsius) && celsius >= -40 && celsius <= 125
+    ? Number(celsius.toFixed(1)) : null;
+}
+
+const priority = name => /^(?:k10temp|coretemp|zenpower|cpu)/i.test(name) ? 0
+  : /^(?:amdgpu|nvidia|gpu)/i.test(name) ? 1
+    : /^nvme/i.test(name) ? 2 : 3;
+
+export async function linuxTemperatureReadings({
+  list = kernelList, read = kernelRead, nvidia = nvidiaTemperatureReadings,
+} = {}) {
+  const entries = [];
+  const chips = [];
+  const seen = new Set();
+  const boundedFile = async name => {
+    const value = String(await read(name, 'utf8'));
+    return value.length <= 128 ? value.trim() : '';
+  };
+  const add = (name, value, chip = '') => {
+    if (value === null || !SAFE_NAME.test(name) || seen.has(name)) return;
+    entries.push({ name, celsius: value, chip });
+    seen.add(name);
+  };
+
+  try {
+    const dirs = (await list('/sys/class/hwmon'))
+      .filter(name => /^hwmon\d{1,3}$/.test(name)).slice(0, 32);
+    for (const dir of dirs) {
+      const base = '/sys/class/hwmon/' + dir;
+      let chip;
+      try { chip = await boundedFile(base + '/name'); } catch { continue; }
+      if (!CHIP.test(chip)) continue;
+      chips.push(chip);
+      let inputs = [];
+      try { inputs = (await list(base)).filter(name => /^temp(?:[1-9]|[1-9]\d)_input$/.test(name)).slice(0, 32); }
+      catch { continue; }
+      for (const file of inputs) {
+        const index = file.match(/^temp(\d+)_input$/)[1];
+        try {
+          const value = linuxTemperatureValue(await boundedFile(base + '/' + file));
+          let label = '';
+          try { label = await boundedFile(base + '/temp' + index + '_label'); } catch { /* Optional. */ }
+          if (!LABEL.test(label)) label = 'temp' + index;
+          const baseName = chip + ': ' + label;
+          // Multiple NVMe drives can share the same chip/label. Preserve each
+          // physical channel using its hwmon ID rather than dropping it.
+          add(seen.has(baseName) ? chip + '(' + dir + '): ' + label : baseName, value, chip);
+        } catch { /* Optional or inaccessible hardware channel. */ }
+      }
+    }
+  } catch { /* No hwmon inventory (VMs, containers, hardened hosts). */ }
+
+  // Thermal zones can expose additional independent channels. Drop an exact
+  // ACPI duplicate when hwmon already reports the same chip and temperature.
+  try {
+    const zones = (await list('/sys/class/thermal'))
+      .filter(name => /^thermal_zone\d{1,3}$/.test(name)).slice(0, 32);
+    for (const zone of zones) {
+      const base = '/sys/class/thermal/' + zone;
+      try {
+        const value = linuxTemperatureValue(await boundedFile(base + '/temp'));
+        const type = await boundedFile(base + '/type').catch(() => '');
+        const duplicate = CHIP.test(type) && entries.some(row =>
+          row.chip === type && value !== null && Math.abs(row.celsius - value) <= 0.1);
+        if (!duplicate) add('Thermal ' + zone.slice('thermal_zone'.length), value);
+      } catch { /* Optional or inaccessible thermal zone. */ }
+    }
+  } catch { /* No thermal zones. */ }
+  // The proprietary NVIDIA driver may not expose GPU temperatures via hwmon.
+  // Query its read-only tool using fixed arguments; missing drivers mean unknown.
+  const vendorGpu = await nvidia().catch(() => []);
+  for (const item of Array.isArray(vendorGpu) ? vendorGpu.slice(0, 16) : []) {
+    if (!/^NVIDIA GPU (?:[0-9]|1[0-5])$/.test(item?.name)) continue;
+    const value = typeof item.celsius === 'number' && Number.isFinite(item.celsius) &&
+      item.celsius >= 0 && item.celsius <= 125 ? item.celsius : null;
+    add(item.name, value, 'nvidia');
+  }
+  // Prefer measured CPU and GPU channels for the compact overview widget.
+  return entries.sort((a, b) => priority(a.chip) - priority(b.chip))
+    .slice(0, SENSOR_LIMIT).map(({ name, celsius }) => ({ name, celsius }));
+}

package/src/tools/nvidia-temperature.mjs

@@ -0,0 +1,24 @@
+// NVIDIA exposes GPU die temperatures through the read-only nvidia-smi CLI
+// on Linux and Windows. Do not execute a shell or user-supplied arguments.
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
+
+export function parseNvidiaTemperatures(stdout) {
+  return String(stdout || '').split(/\r?\n/).slice(0, 16).flatMap((line, index) => {
+    const value = line.trim();
+    if (!/^\d{1,3}(?:\.\d)?$/.test(value)) return [];
+    const celsius = Number(value);
+    return celsius >= 0 && celsius <= 125
+      ? [{ name: 'NVIDIA GPU ' + index, celsius }] : [];
+  });
+}
+
+export async function nvidiaTemperatureReadings({ run = exec } = {}) {
+  try {
+    const result = await run('nvidia-smi',
+      ['--query-gpu=temperature.gpu', '--format=csv,noheader,nounits'],
+      { windowsHide: true, timeout: 2500, maxBuffer: 4096 });
+    return parseNvidiaTemperatures(result.stdout);
+  } catch { return []; }
+}

package/src/tools/system-telemetry.mjs

@@ -3,8 +3,12 @@
 import { readFile, readdir } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import os from 'node:os';
 import process from 'node:process';
+import { setTimeout as delay } from 'node:timers/promises';
 import { darwinTemperatureReadings } from './darwin-temperature.mjs';
+import { linuxTemperatureReadings } from './linux-temperature.mjs';
+import { windowsTemperatureReadings } from './windows-temperature.mjs';
 
 const run = promisify(execFile);
 const numeric = value => Number.isFinite(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER;
@@ -25,6 +29,52 @@ export function parseNetworkCounters(input) {
   return interfaces;
 }
 
+// netstat -ib has multiple address rows per interface on macOS. Only the
+// <Link#N> row contains the canonical byte counters; never sum duplicates.
+export function parseDarwinNetworkCounters(input, activeNames = null) {
+  const lines = String(input).split(/\r?\n/);
+  const header = lines[0]?.trim().split(/\s+/) ?? [];
+  const rxIndex = header.indexOf('Ibytes');
+  const txIndex = header.indexOf('Obytes');
+  if (rxIndex < 0 || txIndex < 0) return [];
+  const found = new Map();
+  for (const line of lines.slice(1, 160)) {
+    const parts = line.trim().split(/\s+/);
+    const name = parts[0];
+    if (!safeName(name) || !/^<Link#\d+>$/.test(parts[2]) ||
+        /^(?:lo\d*|awdl\d*|llw\d*|utun\d*|bridge\d*|gif\d*|stf\d*|ap\d*|anpi\d*)$/.test(name) ||
+        (activeNames && !activeNames.has(name))) continue;
+    const rx = Number(parts[rxIndex]);
+    const tx = Number(parts[txIndex]);
+    if (!numeric(rx) || !numeric(tx)) continue;
+    found.set(name, { name, rx, tx });
+    if (found.size >= 24) break;
+  }
+  return [...found.values()];
+}
+
+// Windows adapter statistics are real cumulative counters, not link-speed estimates.
+export function parseWindowsNetworkCounters(input, activeNames = null) {
+  let parsed;
+  try { parsed = JSON.parse(String(input)); } catch { return []; }
+  const rows = Array.isArray(parsed) ? parsed : [parsed];
+  const found = new Map();
+  for (const row of rows.slice(0, 128)) {
+    const name = row?.Name;
+    if (typeof name !== 'string' || !/^[\p{L}\p{N} _().:#-]{1,64}$/u.test(name) ||
+        (activeNames && !activeNames.has(name))) continue;
+    const parseCounter = value => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0
+      ? value : typeof value === 'string' && /^\d{1,16}$/.test(value) && numeric(Number(value))
+        ? Number(value) : null;
+    const rx = parseCounter(row?.ReceivedBytes);
+    const tx = parseCounter(row?.SentBytes);
+    if (rx === null || tx === null) continue;
+    found.set(name, { name, rx, tx });
+    if (found.size >= 24) break;
+  }
+  return [...found.values()];
+}
+
 export function calculateNetworkRates(current, previous, elapsedSeconds) {
   if (!Array.isArray(current) || !Array.isArray(previous) || !Number.isFinite(elapsedSeconds) ||
       elapsedSeconds < 1 || elapsedSeconds > 300) return null;
@@ -45,52 +95,71 @@ export function calculateNetworkRates(current, previous, elapsedSeconds) {
 }
 
 let lastNetwork = null;
-export async function networkRates() {
-  if (process.platform !== 'linux') return null;
+let pendingNetwork = null;
+
+async function readNetworkCounters() {
+  if (process.platform === 'linux') {
+    const active = new Set(Object.entries(os.networkInterfaces())
+      .filter(([, addresses]) => addresses?.some(address => !address.internal))
+      .map(([name]) => name));
+    return parseNetworkCounters(await readFile('/proc/net/dev', 'utf8'))
+      .filter(row => active.has(row.name) && !/^(?:veth|docker|br-|virbr|tun|tap|wg|lo)/.test(row.name));
+  }
+  if (process.platform === 'darwin') {
+    const { stdout } = await run('/usr/sbin/netstat', ['-ibn'],
+      { timeout: 2500, maxBuffer: 128 * 1024 });
+    const active = new Set(Object.entries(os.networkInterfaces())
+      .filter(([, addresses]) => addresses?.some(address => !address.internal &&
+        !address.address.startsWith('fe80:'))).map(([name]) => name));
+    return parseDarwinNetworkCounters(stdout, active);
+  }
+  if (process.platform === 'win32') {
+    const script = 'Get-NetAdapterStatistics | Select-Object Name,ReceivedBytes,SentBytes | ConvertTo-Json -Compress';
+    const { stdout } = await run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script],
+      { windowsHide: true, timeout: 5000, maxBuffer: 128 * 1024 });
+    const active = new Set(Object.entries(os.networkInterfaces())
+      .filter(([, addresses]) => addresses?.some(address => !address.internal))
+      .map(([name]) => name));
+    return parseWindowsNetworkCounters(stdout, active);
+  }
+  return [];
+}
+
+async function sampleNetworkRates() {
   try {
-    const input = await readFile('/proc/net/dev', 'utf8');
-    const current = parseNetworkCounters(input);
-    const now = performance.now();
-    const previous = lastNetwork;
+    let current = await readNetworkCounters();
+    let now = performance.now();
+    let previous = lastNetwork;
+    const elapsed = previous ? (now - previous.at) / 1000 : 0;
+    // The first diagnostics request must return a measured rate, not null.
+    // Bootstrap from two real counters; never manufacture a zero-rate sample.
+    if (elapsed < 1 || elapsed > 300) {
+      previous = { at: now, interfaces: current };
+      await delay(1100);
+      current = await readNetworkCounters();
+      now = performance.now();
+    }
     lastNetwork = { at: now, interfaces: current };
-    return previous ? calculateNetworkRates(current, previous.interfaces, (now - previous.at) / 1000) : null;
+    return calculateNetworkRates(current, previous.interfaces, (now - previous.at) / 1000);
   } catch {
     lastNetwork = null;
     return null;
   }
 }
 
+export async function networkRates() {
+  if (!['linux', 'darwin', 'win32'].includes(process.platform)) return null;
+  if (pendingNetwork) return pendingNetwork;
+  pendingNetwork = sampleNetworkRates();
+  try { return await pendingNetwork; }
+  finally { pendingNetwork = null; }
+}
+
 export async function thermalReadings() {
   if (process.platform === 'darwin') return darwinTemperatureReadings();
-  if (process.platform !== 'linux') return [];
-  const sensors = [];
-  // Linux thermal zones expose millidegrees Celsius; only fixed kernel paths are read.
-  try {
-    const names = (await readdir('/sys/class/thermal')).filter(name => /^thermal_zone\d{1,3}$/.test(name)).slice(0, 16);
-    for (const name of names) {
-      try {
-        const value = Number((await readFile('/sys/class/thermal/' + name + '/temp', 'utf8')).trim()) / 1000;
-        if (Number.isFinite(value) && value >= -40 && value <= 125)
-          sensors.push({ name: 'Thermal ' + name.slice(12), celsius: Number(value.toFixed(1)) });
-      } catch { /* Sensor is optional or permissions deny reading it. */ }
-    }
-  } catch { /* No thermal zone inventory. */ }
-  // hwmon is common on desktop hardware without usable thermal zones.
-  if (!sensors.length) {
-    try {
-      const chips = (await readdir('/sys/class/hwmon')).filter(name => /^hwmon\d{1,3}$/.test(name)).slice(0, 12);
-      for (const chip of chips) {
-        for (let index = 1; index <= 4 && sensors.length < 12; index++) {
-          try {
-            const value = Number((await readFile('/sys/class/hwmon/' + chip + '/temp' + index + '_input', 'utf8')).trim()) / 1000;
-            if (Number.isFinite(value) && value >= -40 && value <= 125)
-              sensors.push({ name: 'Sensor ' + (sensors.length + 1), celsius: Number(value.toFixed(1)) });
-          } catch { /* Not every chip exposes every temperature index. */ }
-        }
-      }
-    } catch { /* No readable hwmon inventory. */ }
-  }
-  return sensors.slice(0, 12);
+  if (process.platform === 'linux') return linuxTemperatureReadings();
+  if (process.platform === 'win32') return windowsTemperatureReadings();
+  return [];
 }
 
 export function parseDiskVolumes(input) {

package/src/tools/windows-temperature.mjs

@@ -0,0 +1,76 @@
+// Optional read-only Windows temperature sources. Windows has no universal
+// built-in API for CPU/GPU/SSD temperatures: report only exposed real sensors.
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { nvidiaTemperatureReadings } from './nvidia-temperature.mjs';
+export { parseNvidiaTemperatures } from './nvidia-temperature.mjs';
+
+const exec = promisify(execFile);
+const MAX_SENSORS = 64;
+const CLEAN_LABEL = /^[A-Za-z0-9_.:+#() -]{1,60}$/;
+
+// Fixed PowerShell source, with no user-supplied script text or arguments.
+export const WINDOWS_TEMPERATURE_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  "$rows = [System.Collections.Generic.List[object]]::new()",
+  "foreach ($namespace in @('root\\LibreHardwareMonitor','root\\OpenHardwareMonitor')) {",
+  "  try {",
+  "    $sensors = @(Get-CimInstance -Namespace $namespace -ClassName Sensor -ErrorAction Stop)",
+  "    foreach ($sensor in $sensors) {",
+  "      if ($sensor.SensorType -ne 'Temperature') { continue }",
+  "      $rows.Add(@{ name = ('Hardware: ' + [string]$sensor.Name); celsius = $sensor.Value })",
+  "      if ($rows.Count -ge 64) { break }",
+  "    }",
+  "    if ($rows.Count -gt 0) { break }",
+  "  } catch { }",
+  "}",
+  "try {",
+  "  $zones = @(Get-CimInstance -Namespace 'root\\wmi' -ClassName MSAcpi_ThermalZoneTemperature -ErrorAction Stop)",
+  "  $index = 0",
+  "  foreach ($zone in $zones) {",
+  "    $raw = [double]$zone.CurrentTemperature",
+  "    $rows.Add(@{ name = ('ACPI Thermal ' + $index); celsius = (($raw / 10) - 273.15) })",
+  "    $index += 1",
+  "    if ($rows.Count -ge 64) { break }",
+  "  }",
+  "} catch { }",
+  "ConvertTo-Json -InputObject @($rows.ToArray()) -Compress -Depth 3",
+].join('\n');
+
+export function parseWindowsTemperatureReadings(stdout) {
+  let values;
+  try { values = JSON.parse(String(stdout || '')); } catch { return []; }
+  if (!Array.isArray(values)) values = values && typeof values === 'object' ? [values] : [];
+  const sensors = [];
+  const names = new Set();
+  for (const raw of values.slice(0, 128)) {
+    const baseName = String(raw?.name ?? '').trim();
+    const value = raw?.celsius;
+    if (!CLEAN_LABEL.test(baseName) || typeof value !== 'number' ||
+        !Number.isFinite(value) || value < -40 || value > 125) continue;
+    // Separate GPUs/cores can expose identical labels through the same WMI
+    // provider; retain every valid channel with a deterministic index.
+    let name = baseName;
+    if (names.has(name)) name = baseName + ' (' + (sensors.length + 1) + ')';
+    if (!CLEAN_LABEL.test(name) || names.has(name)) continue;
+    names.add(name);
+    sensors.push({ name, celsius: Number(value.toFixed(1)) });
+    if (sensors.length >= MAX_SENSORS) break;
+  }
+  return sensors;
+}
+
+export async function windowsTemperatureReadings({ run = exec } = {}) {
+  const [cim, nvidia] = await Promise.all([
+    run('powershell.exe', ['-NoLogo', '-NoProfile', '-NonInteractive',
+      '-Command', WINDOWS_TEMPERATURE_SCRIPT], {
+      windowsHide: true, timeout: 5500, maxBuffer: 32768,
+    }).then(result => parseWindowsTemperatureReadings(result.stdout)).catch(() => []),
+    nvidiaTemperatureReadings({ run }),
+  ]);
+  const names = new Set(cim.map(item => item.name));
+  for (const item of nvidia) if (!names.has(item.name) && cim.length < MAX_SENSORS) {
+    cim.push(item); names.add(item.name);
+  }
+  return cim;
+}