@remcp/runtime 0.2.171 → 0.2.173

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.2.173 — 2026-10-22
+
+- Return initial terminal output promptly after a bounded 175 ms grace when a long-running process writes without exiting.
+- Preserve exit-status reporting for immediately completing commands, timeout upper bounds and process-session read/termination semantics.
+- Add terminal regression tests; retain 83 runtime operation routes and unchanged authorization and device safety controls.
+
+
+## 0.2.172 — 2026-10-22
+
+- Add bounded host-wide CPU utilization sampling based on deltas from `os.cpus().times` so the dashboard can display real CPU percentages instead of treating load average as CPU%.
+- Add `cpu.frequencyMHz` from reported per-core clock rates, with `null` for unsupported or invalid measurements.
+- Preserve the existing `get_system_info` schema, 83-tool catalog, authentication restrictions, and backwards compatibility.
+
+
 ## 0.2.171 — 2026-10-21
 
 - Require MCP Server SDK 2.3.0 or later; update the published dependency lock to the patched 2.3.x line.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.171",
+  "version": "0.2.173",
   "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/cpu-telemetry.mjs

@@ -0,0 +1,34 @@
+// OS-wide CPU utilization over a short bounded interval, not process CPU time or load average.
+const timeKeys = ['user', 'nice', 'sys', 'idle', 'irq'];
+
+function totals(cpu) {
+  const times = cpu?.times;
+  if (!times || !timeKeys.every(key => Number.isFinite(times[key]) && times[key] >= 0)) return null;
+  return {
+    total: timeKeys.reduce((sum, key) => sum + times[key], 0),
+    idle: times.idle,
+  };
+}
+
+export function cpuUtilizationRatio(before, after) {
+  if (!Array.isArray(before) || !Array.isArray(after) || !before.length || before.length !== after.length) return null;
+  let deltaTotal = 0;
+  let deltaIdle = 0;
+  for (let i = 0; i < before.length; i++) {
+    const previous = totals(before[i]);
+    const current = totals(after[i]);
+    if (!previous || !current) return null;
+    const total = current.total - previous.total;
+    const idle = current.idle - previous.idle;
+    if (total < 0 || idle < 0 || idle > total) return null;
+    deltaTotal += total;
+    deltaIdle += idle;
+  }
+  return deltaTotal > 0 ? Number(Math.max(0, Math.min(1, 1 - deltaIdle / deltaTotal)).toFixed(3)) : null;
+}
+
+export function cpuFrequencyMHz(cores) {
+  if (!Array.isArray(cores) || !cores.length) return null;
+  const speeds = cores.map(core => core?.speed).filter(speed => Number.isFinite(speed) && speed > 0 && speed <= 100000);
+  return speeds.length ? Math.round(speeds.reduce((sum, speed) => sum + speed, 0) / speeds.length) : null;
+}

package/src/tools/system.mjs

@@ -4,6 +4,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { runtimeConfig } from '../config.mjs';
 import { clampInteger, fail, requireInteger, text } from '../util.mjs';
+import { cpuUtilizationRatio, cpuFrequencyMHz } from './cpu-telemetry.mjs';
 
 const run = promisify(execFile);
 
@@ -42,6 +43,12 @@ export async function getSystemInfoTool() {
   const totalMem = os.totalmem();
   const freeMem = os.freemem();
   const load = os.loadavg();
+  // Sample for 140 ms while retrieving disk facts, so CPU % is actual host activity.
+  // Load average is a queue-length metric and must never be displayed as a percentage.
+  const diskPromise = diskUsage();
+  const sampledCpus = await new Promise(resolve => setTimeout(() => resolve(os.cpus()), 140));
+  const utilizationRatio = cpuUtilizationRatio(cpus, sampledCpus);
+  const frequencyMHz = cpuFrequencyMHz(sampledCpus);
   return text(JSON.stringify({
     hostname: os.hostname(),
     platform: process.platform,
@@ -53,6 +60,8 @@ export async function getSystemInfoTool() {
     cpu: {
       model: cpus[0]?.model?.trim() || 'unknown',
       count: cpus.length,
+      utilizationRatio,
+      frequencyMHz,
       loadAverage: process.platform === 'win32' ? null : load.map(value => Number(value.toFixed(2))),
       loadPerCore: process.platform === 'win32' || !cpus.length ? null : Number((load[0] / cpus.length).toFixed(2)),
     },
@@ -61,7 +70,7 @@ export async function getSystemInfoTool() {
       freeBytes: freeMem,
       usedRatio: totalMem ? Number(((totalMem - freeMem) / totalMem).toFixed(3)) : 0,
     },
-    disk: await diskUsage(),
+    disk: await diskPromise,
     home: os.homedir(),
     tempDir: os.tmpdir(),
     runtimeName: runtimeConfig.name,

package/src/tools/terminal.mjs

@@ -14,7 +14,6 @@ import {
   readNewOutput,
   readOutputRange,
   totalLines,
-  waitForProcessExit,
   waitForProcessActivity,
 } from '../sessions.mjs';
 import { clampInteger, fail, requireInteger, requireString, structured, text, truncate } from '../util.mjs';
@@ -66,6 +65,21 @@ function terminalStructured(value, fallbackText) {
   return structured(bounded, fallbackText);
 }
 
+// The start call promises initial output, not process completion. Return once
+// useful output arrives, keeping a short grace window so quick commands can
+// still report their real exit status without requiring a follow-up tool call.
+// Explicit timeout_ms remains an upper bound, including for silent commands.
+async function waitForInitialOutput(session, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  const graceUntil = Date.now() + Math.min(175, timeoutMs);
+  while (!session.exited) {
+    const now = Date.now();
+    if (now >= deadline || (now >= graceUntil && hasNewOutput(session))) break;
+    const wakeAt = now < graceUntil ? Math.min(deadline, graceUntil) : deadline;
+    await waitForProcessActivity(session, Math.min(100, Math.max(1, wakeAt - now)));
+  }
+}
+
 export async function startProcessTool(args, extra = {}) {
   const command = requireString(args.command, 'command');
   const verdict = assertAllowedCommand(command);
@@ -105,7 +119,7 @@ export async function startProcessTool(args, extra = {}) {
   child.on('exit', (code, signal) => markProcessExited(session, code, signal));
   child.on('close', (code, signal) => markProcessExited(session, code, signal));
 
-  await waitForProcessExit(session, timeoutMs);
+  await waitForInitialOutput(session, timeoutMs);
   const headline = session.exited
     ? `Process ${session.pid} finished${session.exitCode === null ? '' : ` with code ${session.exitCode}`}${session.signal ? ` (${session.signal})` : ''}.`
     : `Process ${session.pid} is running.`;