@remcp/remcp 0.2.206 → 0.2.208

package/README.md

@@ -63,7 +63,20 @@ Two things it deliberately does not do:
   a non-interactive command cannot type one. Nothing in this mode grants root by itself.
 
 While it is on, `get_runtime_info` reports `policy.unrestricted: true`, so the model can see it and
-say so instead of assuming the guardrails are still there.
+say so instead of assuming the guardrails are still there. The same response includes
+`osPrivilegeBoundary`, reporting effective user and `NoNewPrivs` on Linux, the user boundary on
+macOS, and the actual Windows process integrity level detected via `whoami.exe /groups`.
+If that command is unavailable, Windows elevation remains `unknown`; process integrity
+is not equivalent to blanket administrator access.
+
+The owner-managed Linux `remcp-agent.service` does not set `NoNewPrivileges=true`: sudo/polkit
+may request normal OS approval instead of being blocked by systemd. `remcp update` also removes
+this legacy line from older user units. A systemd `daemon-reload` does not change an already
+running process; activating the new privilege boundary requires an agent restart, which can stop
+running terminal sessions and child processes. This does **not** enable passwordless root.
+On macOS, launchd runs as the signed-in user, and TCC controls Full Disk Access and Accessibility.
+On Windows, the interactive scheduled task requests the highest privileges available to its
+principal; UAC and the actual process token remain authoritative.
 
 ## macOS folder permissions
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/remcp",
-  "version": "0.2.206",
+  "version": "0.2.208",
   "description": "ReMCP device client: pair a computer with ReMCP and run the outbound-only agent that hosts the local MCP runtime.",
   "type": "module",
   "license": "MIT",

package/src/cli/mac-native-temperature.mjs

@@ -3,12 +3,35 @@
 // after verifying its installed manifest and on-disk path. No sudo or shell.
 import fs from 'node:fs';
 import path from 'node:path';
+import process from 'node:process';
+import { spawn } from 'node:child_process';
 
 const SENSOR_NAME = 'macos-temperature-sensor';
 const SENSOR_VERSION = '2.1.1';
 const SCRIPT = 'node-gyp rebuild';
 const BINARY = path.join('build', 'Release', 'mac_temp_native.node');
 
+// Repair a module omitted by an old updater after starting the new agent.
+export function scheduleMacTemperatureRepair({
+  platform = process.platform, runtimePackageName, nodeExecutable = process.execPath,
+  cliEntry = process.argv[1], environment = process.env,
+  spawnProcess = spawn, warn = console.error,
+} = {}) {
+  if (platform !== 'darwin' || runtimePackageName !== '@remcp/runtime') return false;
+  if (!path.isAbsolute(nodeExecutable) || !path.isAbsolute(cliEntry || '')) return false;
+  try {
+    const child = spawnProcess(nodeExecutable, [cliEntry, '__repair-macos-temperature'], {
+      detached: true, stdio: ['ignore', 'inherit', 'inherit'], env: environment,
+    });
+    child.on?.('error', () => warn('ReMCP: optional macOS temperature repair could not start.'));
+    child.unref?.();
+    return true;
+  } catch {
+    warn('ReMCP: optional macOS temperature repair could not start.');
+    return false;
+  }
+}
+
 function checkedManifest(file) {
   const stats = fs.lstatSync(file);
   if (!stats.isFile() || stats.size > 16384) throw new Error('invalid manifest');

package/src/cli/npm-global.mjs

@@ -67,6 +67,23 @@ export function npmGlobalInstall(...specs) {
   }
 }
 
+// Called only by the post-start macOS helper: an older updater may have
+// installed this version while leaving the optional native binary missing.
+// The same version-pinned, path-checked installer is reused; no npm install
+// or arbitrary dependency lifecycle scripts are permitted.
+export function repairMacTemperatureAfterStart(runtimePackageName) {
+  if (servicePlatform() !== 'darwin' || runtimePackageName !== '@remcp/runtime') return false;
+  try {
+    return buildVettedMacTemperatureAddon({
+      runtimeRoot:globalPackagePath(assertSafeReMcpNpmPrefix(globalPrefix()), '@remcp/runtime'),
+      resolved:npm, runCommand:run,
+    });
+  } catch {
+    console.error('ReMCP: optional macOS temperature sensor unavailable; other tools remain functional.');
+    return false;
+  }
+}
+
 function pathEntryExists(file) {
   try {
     fs.lstatSync(file);

package/src/cli/service.mjs

@@ -62,7 +62,7 @@ function writeLinuxServiceLauncher(cliPath = globalCliPath(), nodePath = process
 
 export function installLinuxService(cliPath = globalCliPath(), nodePath = process.execPath) {
   const launcherFile = writeLinuxServiceLauncher(cliPath, nodePath);
-  const unit = `[Unit]\nDescription=ReMCP device agent\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nExecStart=${quoteSystemd(launcherFile)} start --service\nRestart=always\nRestartSec=3\nNoNewPrivileges=true\n\n[Install]\nWantedBy=default.target\n`;
+  const unit = `[Unit]\nDescription=ReMCP device agent\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nExecStart=${quoteSystemd(launcherFile)} start --service\nRestart=always\nRestartSec=3\n\n[Install]\nWantedBy=default.target\n`;
   fs.mkdirSync(path.dirname(linuxServiceFile), { recursive: true });
   fs.writeFileSync(linuxServiceFile, unit);
   run('systemctl', ['--user', 'daemon-reload']);
@@ -279,23 +279,29 @@ export function ensureServiceIfRecorded(config) {
           const launcherFile = writeLinuxServiceLauncher(cliPath, nodePath);
           const unit = fs.readFileSync(fd, 'utf8');
           const expected = `ExecStart=${quoteSystemd(launcherFile)} start --service`;
-          if (!unit.includes(expected)) {
-            const repaired = /^ExecStart=/m.test(unit) ? unit.replace(/^ExecStart=.*$/m, expected) : '';
-            if (!repaired) {
-              reinstall = true;
-            } else {
-              const data = Buffer.from(repaired, 'utf8');
-              fs.ftruncateSync(fd, 0);
-              let offset = 0;
-              while (offset < data.length) {
-                const written = fs.writeSync(fd, data, offset, data.length - offset, offset);
-                if (!written) throw new Error('Could not finish rewriting the systemd unit');
-                offset += written;
-              }
-              fs.ftruncateSync(fd, data.length);
-              fs.fsyncSync(fd);
-              run('systemctl', ['--user', 'daemon-reload']);
+          // Legacy versions added NoNewPrivileges=true to the user agent unit.
+          // Drop that line when repairing so ordinary OS-authenticated sudo/polkit
+          // can work for the owner's session. ReMCP never becomes root by itself.
+          // Do not modify unrelated systemd services or owner-managed drop-ins.
+          let repaired = unit.replace(/^NoNewPrivileges=true\r?\n/gm, '');
+          if (!repaired.includes(expected)) {
+            repaired = /^ExecStart=/m.test(repaired)
+              ? repaired.replace(/^ExecStart=.*$/m, expected) : '';
+          }
+          if (!repaired) {
+            reinstall = true;
+          } else if (repaired !== unit) {
+            const data = Buffer.from(repaired, 'utf8');
+            fs.ftruncateSync(fd, 0);
+            let offset = 0;
+            while (offset < data.length) {
+              const written = fs.writeSync(fd, data, offset, data.length - offset, offset);
+              if (!written) throw new Error('Could not finish rewriting the systemd unit');
+              offset += written;
             }
+            fs.ftruncateSync(fd, data.length);
+            fs.fsyncSync(fd);
+            run('systemctl', ['--user', 'daemon-reload']);
           }
         } finally {
           fs.closeSync(fd);

package/src/cli.mjs

@@ -12,6 +12,8 @@ import { assertRuntimeTrust, assertSecureServerUrl, pairWithDeviceCode } from '.
 import { diagnoseLocalRuntime, installedVersion, runtimeAllowedRoots } from './cli/doctor.mjs';
 import { configFile, npm, officialOrigin, runtimeConfigFile } from './cli/env.mjs';
 import { currentInstallationInfo, ensureMacCliCommand, installPersistentAgent, persistentServiceState, servicePlatform, rememberCurrentInstallation, restartPersistentServiceIfInstalled, serviceInstallationInfo, uninstallPersistentService } from './cli/service.mjs';
+import { scheduleMacTemperatureRepair } from './cli/mac-native-temperature.mjs';
+import { repairMacTemperatureAfterStart } from './cli/npm-global.mjs';
 import { run } from './cli/shell.mjs';
 import { updateCommand } from './cli/update.mjs';
 function fetchConfiguredServer(url, options) {
@@ -156,6 +158,9 @@ export async function main(argv = process.argv.slice(2)) {
       console.log(`ReMCP is already running as a background service (${service.name}). Use \`remcp status\` to inspect it or \`remcp doctor\` to diagnose it.`);
       return;
     }
+    // Older updaters can leave the optional native binary absent. Repair via
+    // a separate, fixed-purpose process without delaying the relay connection.
+    scheduleMacTemperatureRepair({ runtimePackageName: cfg.runtime?.packageName });
     const telemetry = telemetryState();
     const agent = await runAgent({
       ...cfg,
@@ -179,6 +184,16 @@ export async function main(argv = process.argv.slice(2)) {
     return;
   }
 
+  if (command === '__repair-macos-temperature') {
+    // Only the pinned first-party sensor is eligible; no external script input.
+    if (servicePlatform() !== 'darwin') return;
+    const cfg = loadConfig(false);
+    if (repairMacTemperatureAfterStart(cfg?.runtime?.packageName)) {
+      console.log('ReMCP: vetted macOS temperature sensor is ready.');
+    }
+    return;
+  }
+
   if (command === 'auto-update') {
     const action = String(positional[0] || 'status').toLowerCase();
     const cfg = loadConfig(false) || {};