@remcp/runtime 0.2.200 → 0.2.201

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.200",
+  "version": "0.2.201",
   "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

@@ -5,6 +5,8 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import process from 'node:process';
 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;
@@ -62,35 +64,9 @@ export async function networkRates() {
 
 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;
+}