@remcp/runtime 0.2.85 → 0.2.87

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.2.87 — 2026-09-21
+
+- macOS `event_log` now streams only the requested head lines from `log show` and terminates the child once the limit is reached.
+- Added a bounded child-process line reader with UTF-8-safe decoding, timeout and byte caps, plus regression coverage for noisy output.
+- Runtime tool schemas and the 83-tool release catalog are unchanged.
+
+## 0.2.86 — 2026-09-21
+
+- Runtime capability remains the same 83 granular operations; this patch changes hosted tool metadata only.
+- No runtime schema, permission, handler, or operation name changed.
+- Lockstep patch release with the ReMCP client/server at `0.2.86`.
+
 ## 0.2.85 — 2026-09-21
 
 - Runtime capability remains 83 granular tools; no device-side operation is removed or renamed in this patch.

package/package.json

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

package/src/extended/common.mjs

@@ -4,6 +4,7 @@ import process from 'node:process';
 import { execFile, spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { mkdtemp, rm } from 'node:fs/promises';
+import { StringDecoder } from 'node:string_decoder';
 import { promisify } from 'node:util';
 import { ToolError, fail, structured, text } from '../util.mjs';
 
@@ -101,6 +102,85 @@ export async function runWithInput(file, args = [], input = '', options = {}) {
   });
 }
 
+export async function runFileHeadLines(file, args = [], lineLimit = 200, options = {}) {
+  const timeout = clamp(options.timeout, 15_000, 100, 120_000);
+  const limit = clamp(lineLimit, 200, 1, 5000);
+  const maxBuffer = clamp(options.maxBuffer, 1024 * 1024, 1024, 64 * 1024 * 1024);
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, args.map(String), {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    const decoder = new StringDecoder('utf8');
+    const lines = [];
+    const err = [];
+    let pending = '';
+    let buffered = 0;
+    let settled = false;
+    let reachedLimit = false;
+    let hardKillTimer = null;
+    const finish = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (hardKillTimer) clearTimeout(hardKillTimer);
+      fn(value);
+    };
+    const stopAfterLimit = () => {
+      if (reachedLimit) return;
+      reachedLimit = true;
+      child.kill('SIGTERM');
+      hardKillTimer = setTimeout(() => child.kill('SIGKILL'), 250);
+      hardKillTimer.unref?.();
+    };
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      finish(reject, new ToolError(`${options.label || file} timed out after ${timeout} ms`));
+    }, timeout);
+    child.stdout.on('data', chunk => {
+      if (settled || reachedLimit) return;
+      buffered += chunk.length;
+      if (buffered > maxBuffer) {
+        child.kill('SIGKILL');
+        finish(reject, new ToolError(`${options.label || file} exceeded the ${maxBuffer} byte output limit before producing ${limit} lines`));
+        return;
+      }
+      pending += decoder.write(chunk);
+      while (lines.length < limit) {
+        const newline = pending.indexOf('\n');
+        if (newline < 0) break;
+        lines.push(pending.slice(0, newline));
+        pending = pending.slice(newline + 1);
+      }
+      if (lines.length >= limit) stopAfterLimit();
+    });
+    child.stderr.on('data', chunk => {
+      if (settled || reachedLimit) return;
+      buffered += chunk.length;
+      if (buffered > maxBuffer) {
+        child.kill('SIGKILL');
+        finish(reject, new ToolError(`${options.label || file} exceeded the ${maxBuffer} byte output limit`));
+        return;
+      }
+      err.push(chunk);
+    });
+    child.on('error', error => finish(reject, new ToolError(`${options.label || file} failed: ${error.message}`)));
+    child.on('close', code => {
+      if (settled) return;
+      if (!reachedLimit) {
+        pending += decoder.end();
+        if (pending && lines.length < limit) lines.push(pending);
+      }
+      const stdout = lines.slice(0, limit).join('\n');
+      const stderr = Buffer.concat(err).toString('utf8');
+      if (code === 0 || reachedLimit || options.allowFailure) finish(resolve, { stdout, stderr, code, truncated: reachedLimit });
+      else finish(reject, new ToolError(`${options.label || file} failed: ${stderr.trim() || `exit ${code}`}`));
+    });
+  });
+}
+
 export async function runPowerShell(script, options = {}) {
   const executable = process.env.SystemRoot
     ? path.join(process.env.SystemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')

package/src/extended/diagnostics.mjs

@@ -15,6 +15,7 @@ import {
   optionalString,
   requireEnum,
   runFile,
+  runFileHeadLines,
   runOsa,
   runPowerShell,
   safeEnvironment,
@@ -92,8 +93,8 @@ export async function eventLog(args) {
   if (process.platform === 'darwin') {
     const argv = ['show','--last',since,'--style','ndjson'];
     if (filter) argv.push('--predicate', `eventMessage CONTAINS[c] ${JSON.stringify(filter)}`);
-    const { stdout } = await runFile('/usr/bin/log', argv, { label: 'macOS unified log', timeout: 30_000, maxBuffer: 32 * 1024 * 1024 });
-    return text(stdout.split('\n').slice(0, limit).join('\n'));
+    const { stdout } = await runFileHeadLines('/usr/bin/log', argv, limit, { label: 'macOS unified log', timeout: 30_000, maxBuffer: 4 * 1024 * 1024 });
+    return text(stdout);
   }
   if (!commandExists('journalctl')) unavailable('Event logs', 'journalctl is required on Linux');
   const n = Number.parseInt(since, 10), unit = since.at(-1);