@remcp/remcp 0.2.230 → 0.2.232

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/remcp",
-  "version": "0.2.230",
+  "version": "0.2.232",
   "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/agent-update-monitor.mjs

@@ -15,7 +15,7 @@ const POST_CONNECT_UPDATE_RECHECK_DELAYS_MS = Object.freeze([60_000, 5 * 60_000,
 const POST_CONNECT_UPDATE_RECHECK_JITTER_MS = 30_000;
 const UPDATE_RETRY_COOLDOWN_MS = 30 * 60 * 1000;
 
-export function createAgentUpdateMonitor({ options, serverUrl, queueEvent, getRuntimeState, onStopRequested, restartRuntime, isStopping, stop }) {
+export function createAgentUpdateMonitor({ options, serverUrl, queueEvent, getRuntimeState, onStopRequested, restartRuntime, isStopping, stop, resolveCli = globalCliEntry }) {
   const postConnectUpdateRecheckDelaysMs = (Array.isArray(options.updateRecheckDelaysMs)
     ? options.updateRecheckDelaysMs : POST_CONNECT_UPDATE_RECHECK_DELAYS_MS)
     .map(Number).filter(delay => Number.isFinite(delay) && delay >= 0 && delay < UPDATE_CHECK_INTERVAL_MS).slice(0, 3);
@@ -37,6 +37,8 @@ export function createAgentUpdateMonitor({ options, serverUrl, queueEvent, getRu
   let lastUpdateCheckError = '';
   let lastUpdateCheckErrorAt = 0;
   let lastDiscoveryAt = 0;
+  let lastAnnouncedVersion = '';
+  let lastAnnouncedAt = 0;
 
   function clearPostConnectUpdateChecks() {
     for (const timer of postConnectUpdateTimers) clearTimeout(timer);
@@ -86,10 +88,20 @@ export function createAgentUpdateMonitor({ options, serverUrl, queueEvent, getRu
       const decision = updateDecision({ advertised, cliVersion: VERSION, runtimeVersion, runtimePackageName: options.runtime?.packageName, runtimeDown });
       if (!decision.needed) return;
       const target = decision.target;
-      queueEvent({ event: 'agent_update', at: Date.now(), reason: `${decision.reason}:${target}`.slice(0, 32), success: true });
-      const cli = globalCliEntry();
+      const availabilityKey = `${target}|${decision.runtime}`;
+      const observedAt = Date.now();
+      const announce = availabilityKey !== lastAnnouncedVersion ||
+        observedAt - lastAnnouncedAt >= UPDATE_RETRY_COOLDOWN_MS;
+      if (announce) {
+        lastAnnouncedVersion = availabilityKey;
+        lastAnnouncedAt = observedAt;
+        // Version discovery is not installation success. The running version
+        // proves convergence only after the replacement agent reconnects.
+        queueEvent({ event: 'agent_update_available', at: observedAt, reason: decision.reason.slice(0, 32) });
+      }
+      const cli = resolveCli();
       if (!cli || !existsSync(cli)) {
-        console.error(`ReMCP ${target} is available; run: remcp update`);
+        if (announce) console.error(`ReMCP ${target} is available; run: remcp update`);
         return;
       }
       // A version that already failed to install is retried only after a cooldown, so a broken
@@ -105,6 +117,7 @@ export function createAgentUpdateMonitor({ options, serverUrl, queueEvent, getRu
       const updateArgs = updateInvocationArgs(decision, options.trustRuntime === true);
       const child = spawn(process.execPath, [cli, ...updateArgs], {
         detached: true,
+        windowsHide: true,
         // The updater's own output is the only record of why an install failed, so it is piped back
         // into this agent's log instead of being discarded.
         stdio: ['ignore', 'pipe', 'pipe'],

package/src/agent-update.mjs

@@ -24,7 +24,7 @@ function packageLocalNodeModules() {
 const REPLACEMENT_HANDOVER_TIMEOUT_MS = 20_000;
 
 function globalNodeModules() {
-  const result = spawnSync(npm.command, [...npm.args, 'root', '--global'], { encoding: 'utf8' });
+  const result = spawnSync(npm.command, [...npm.args, 'root', '--global'], { encoding: 'utf8', windowsHide: true });
   if (result.error || result.status !== 0) throw new Error('Could not locate the global npm modules directory');
   return String(result.stdout || '').trim();
 }
@@ -142,7 +142,7 @@ export async function restartToApplyUpdate(cli, stopAgent, markStopping, onRunti
     }
     // Handing over to a version that cannot start would take the machine offline with nobody left to
     // retry. The new CLI has to answer `--version` before this process steps aside.
-    const probe = spawnSync(process.execPath, [cli, '--version'], { encoding: 'utf8', timeout: 30000 });
+    const probe = spawnSync(process.execPath, [cli, '--version'], { encoding: 'utf8', timeout: 30000, windowsHide: true });
     const reported = String(probe.stdout || '').trim();
     if (probe.error || probe.status !== 0 || !/^\d+\.\d+\.\d+/.test(reported)) {
       console.error(`The installed ReMCP ${installed || 'update'} did not run (${probe.error?.message || `exit ${probe.status}`}${reported ? `: ${reported}` : ''}). Keeping ${VERSION} running; retry with: remcp update`);
@@ -150,7 +150,7 @@ export async function restartToApplyUpdate(cli, stopAgent, markStopping, onRunti
     }
     console.log(`ReMCP ${installed || 'a newer version'} installed and verified (${reported}); restarting to apply it.`);
     if (!supervisorRestart()) {
-      spawn(process.execPath, [cli, 'start'], { detached: true, stdio: 'ignore', env: { ...process.env } }).unref();
+      spawn(process.execPath, [cli, 'start'], { detached: true, windowsHide: true, stdio: 'ignore', env: { ...process.env } }).unref();
       // Stepping aside is only safe once the replacement really holds the device: the relay closes
       // this socket with 1012 ('replaced') the moment another agent takes the machine over, and that
       // close is what stops this process. Without the wait, a replacement that cannot start left the
@@ -221,7 +221,7 @@ export function globalCliEntry({ packageLocal = true } = {}) {
   // CLI entry and avoid asking npm which global prefix happens to be active in a minimal service
   // environment (FNM/NVM/Hermes/Homebrew can all disagree with the shell).
   if (packageLocal && existsSync(PACKAGE_CLI_ENTRY)) return PACKAGE_CLI_ENTRY;
-  const prefix = spawnSync(npm.command, [...npm.args, 'prefix', '--global'], { encoding:'utf8' });
+  const prefix = spawnSync(npm.command, [...npm.args, 'prefix', '--global'], { encoding:'utf8', windowsHide:true });
   if (prefix.error || prefix.status !== 0) return null;
   const base = String(prefix.stdout || '').trim();
   return process.platform === 'win32'

package/src/cli/doctor.mjs

@@ -108,7 +108,7 @@ export function runtimeAllowedRoots() {
 }
 
 export function installedVersion(packageName) {
-  const prefix = spawnSync(npm.command, [...npm.args, 'prefix', '--global'], { encoding: 'utf8' });
+  const prefix = spawnSync(npm.command, [...npm.args, 'prefix', '--global'], { encoding: 'utf8', windowsHide: true });
   if (prefix.error || prefix.status !== 0) return null;
   const manifest = path.join(String(prefix.stdout || '').trim(), 'lib', 'node_modules', ...packageName.split('/'), 'package.json');
   try { return JSON.parse(fs.readFileSync(manifest, 'utf8')).version || null; } catch { return null; }

package/src/cli/service-inventory.mjs

@@ -16,7 +16,7 @@ export function persistentServiceExpected(config) {
   if (platform === 'darwin') return fs.existsSync(macServiceFile);
   if (platform === 'win32') {
     return windowsStartupScriptInstalled(windowsStartupScriptFile) ||
-      spawnSync('schtasks.exe', ['/Query', '/TN', windowsTaskName], { stdio: 'ignore' }).status === 0;
+      spawnSync('schtasks.exe', ['/Query', '/TN', windowsTaskName], { stdio: 'ignore', windowsHide: true }).status === 0;
   }
   return false;
 }
@@ -36,7 +36,7 @@ export function persistentServiceState(config) {
     return { expected, installed, active, manager:'launchd', name:macServiceLabel };
   }
   if (platform === 'win32') {
-    const query = spawnSync('schtasks.exe', ['/Query', '/TN', windowsTaskName, '/FO', 'LIST'], { encoding:'utf8' });
+    const query = spawnSync('schtasks.exe', ['/Query', '/TN', windowsTaskName, '/FO', 'LIST'], { encoding:'utf8', windowsHide:true });
     const installed = query.status === 0;
     const outputText = String(query.stdout || '');
     const active = installed && /(?:Status|Состояние):\s*Running/i.test(outputText);

package/src/cli/shell.mjs

@@ -3,14 +3,14 @@
 import { spawnSync } from 'node:child_process';
 
 export function run(command, args, options = {}) {
-  const result = spawnSync(command, args, { stdio: 'inherit', ...options });
+  const result = spawnSync(command, args, { stdio: 'inherit', ...options, windowsHide: true });
   if (result.error) throw result.error;
   if (result.status !== 0) throw new Error(`${command} failed with exit code ${result.status}`);
   return result;
 }
 
 export function output(command, args) {
-  const result = spawnSync(command, args, { encoding: 'utf8' });
+  const result = spawnSync(command, args, { encoding: 'utf8', windowsHide: true });
   if (result.error) throw result.error;
   if (result.status !== 0) throw new Error(`${command} failed with exit code ${result.status}`);
   return String(result.stdout || '').trim();

package/src/cli/windows-cli-shim.mjs

@@ -71,3 +71,65 @@ export function preferWindowsCmdShim(prefix) {
   fs.unlinkSync(powershell);
   return true;
 }
+
+
+// An older auto-updater can install a newer client without running that newer
+// client's post-npm shim cleanup. Repair the canonical npm-owned shadow at
+// agent startup so a Windows account using Restricted PowerShell remains usable.
+// Do not touch arbitrary prefixes, custom scripts, links or nonstandard shims.
+export const WINDOWS_NPM_CMD_SHIM = String.raw`@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\node_modules\@remcp\remcp\bin\remcp.mjs" %*
+`;
+
+function sameCanonicalFile(actual, expected) {
+  if (!actual || !expected) return false;
+  const same = (a, b) => path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase();
+  try {
+    return same(actual, expected) && same(fs.realpathSync(actual), expected)
+      && same(fs.realpathSync(expected), expected);
+  } catch { return false; }
+}
+
+export function repairManagedWindowsPowerShellShimOnStart({
+  platform = process.platform,
+  localAppData = process.env.LOCALAPPDATA,
+  nodePath = process.execPath,
+  cliEntry = process.argv[1],
+} = {}) {
+  if (platform !== 'win32' || !localAppData || !path.isAbsolute(localAppData)) return false;
+  const prefix = path.join(localAppData, 'ReMCP', 'runtime');
+  const expectedNode = path.join(prefix, 'node.exe');
+  const expectedCli = path.join(prefix, 'node_modules', '@remcp', 'remcp', 'bin', 'remcp.mjs');
+  if (!sameCanonicalFile(nodePath, expectedNode) || !sameCanonicalFile(cliEntry, expectedCli)) return false;
+
+  const directory = fs.lstatSync(prefix);
+  if (!directory.isDirectory() || directory.isSymbolicLink()) {
+    throw new Error('Refusing Windows launcher self-repair outside a real managed runtime directory');
+  }
+  if (!assertWindowsNpmPowerShellShimOwned(prefix)) return false;
+  const cmdPath = path.join(prefix, 'remcp.cmd');
+  const cmdStat = fs.lstatSync(cmdPath);
+  if (!cmdStat.isFile() || cmdStat.isSymbolicLink()) {
+    throw new Error('Refusing Windows launcher self-repair without a trusted batch shim');
+  }
+  const cmdBody = fs.readFileSync(cmdPath, 'utf8');
+  if (normalizedShim(cmdBody) !== normalizedShim(WINDOWS_NPM_CMD_SHIM)) {
+    throw new Error('Refusing Windows launcher self-repair for an unrecognized batch shim');
+  }
+  return preferWindowsCmdShim(prefix);
+}

package/src/cli.mjs

@@ -17,6 +17,7 @@ import { auditKnownInstallations } from './cli/installation-audit.mjs';
 import { scheduleMacTemperatureRepair } from './cli/mac-native-temperature.mjs';
 import { guardSupervisorDisconnect } from './cli/supervised-agent-lifecycle.mjs';
 import { repairMacTemperatureAfterStart } from './cli/npm-global.mjs';
+import { repairManagedWindowsPowerShellShimOnStart } from './cli/windows-cli-shim.mjs';
 import { run } from './cli/shell.mjs';
 import { updateCommand } from './cli/update.mjs';
 function fetchConfiguredServer(url, options) {
@@ -165,6 +166,13 @@ export async function main(argv = process.argv.slice(2)) {
       || Boolean(process.env.INVOCATION_ID)
       || String(process.env.XPC_SERVICE_NAME || '').includes('com.remcp.agent');
     const cfg = rememberCurrentInstallation(loadConfig(), { service:supervised });
+    if (process.platform === 'win32') {
+      try { repairManagedWindowsPowerShellShimOnStart(); }
+      catch (error) {
+        // Never take a paired device offline because an old launcher is custom or unreadable.
+        console.error(`ReMCP Windows PowerShell launcher self-repair skipped: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
     // A service can start from an absolute fnm/nvm Node path even when an interactive macOS shell
     // cannot resolve the npm-global `remcp` binary. Refresh the stable user shim on every start so
     // an auto-update repairs the next Terminal session without requiring a manual PATH edit.

package/src/npm.mjs

@@ -62,13 +62,13 @@ export function resolveNpm({ nodePath = process.execPath, home = os.homedir(), p
 
 // The version npm itself reports, or null when it cannot be executed at all.
 export function npmVersion(resolved = resolveNpm()) {
-  const result = spawnSync(resolved.command, [...resolved.args, '--version'], { encoding: 'utf8', timeout: 15000 });
+  const result = spawnSync(resolved.command, [...resolved.args, '--version'], { encoding: 'utf8', timeout: 15000, windowsHide: true });
   if (result.error || result.status !== 0) {
     // A login shell may still find npm (nvm and Homebrew write their PATH into the profile).
-    const shell = process.platform === 'win32' ? null : spawnSync('/bin/sh', ['-lc', 'command -v npm'], { encoding: 'utf8', timeout: 15000 });
+    const shell = process.platform === 'win32' ? null : spawnSync('/bin/sh', ['-lc', 'command -v npm'], { encoding: 'utf8', timeout: 15000, windowsHide: true });
     const found = String(shell?.stdout || '').trim().split('\n').pop();
     if (found && existsSync(found)) {
-      const retry = spawnSync(found, ['--version'], { encoding: 'utf8', timeout: 15000 });
+      const retry = spawnSync(found, ['--version'], { encoding: 'utf8', timeout: 15000, windowsHide: true });
       if (!retry.error && retry.status === 0) return { version: String(retry.stdout).trim(), source: found };
     }
     return null;
@@ -79,5 +79,5 @@ export function npmVersion(resolved = resolveNpm()) {
 // Runs npm with the resolved command, so callers never depend on PATH.
 export function npmRun(args, { encoding = 'utf8', stdio = 'inherit' } = {}) {
   const resolved = resolveNpm();
-  return spawnSync(resolved.command, [...resolved.args, ...args], { encoding, stdio });
+  return spawnSync(resolved.command, [...resolved.args, ...args], { encoding, stdio, windowsHide: true });
 }