@remcp/remcp 0.2.221 → 0.2.223

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/remcp",
-  "version": "0.2.221",
+  "version": "0.2.223",
   "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",
@@ -18,7 +18,7 @@
     "README.md"
   ],
   "scripts": {
-    "check": "node --check bin/remcp.mjs && node --check src/agent-deploy-reconnect.mjs && node --check src/agent-network-probe-client.mjs && node --check src/agent-relay-connection.mjs && node --check src/agent-responder.mjs && node --check src/agent-runtime-capabilities.mjs && node --check src/agent-update-monitor.mjs && node --check src/agent-update.mjs && node --check src/agent-utilities.mjs && node --check src/agent.mjs && node --check src/cli.mjs && node --check src/cli/config.mjs && node --check src/cli/connect.mjs && node --check src/cli/doctor.mjs && node --check src/cli/env.mjs && node --check src/cli/installation-audit.mjs && node --check src/cli/mac-native-temperature.mjs && node --check src/cli/npm-global.mjs && node --check src/cli/pairing-qr.mjs && node --check src/cli/service-inventory.mjs && node --check src/cli/service-macos.mjs && node --check src/cli/service-paths.mjs && node --check src/cli/service.mjs && node --check src/cli/shell.mjs && node --check src/cli/update.mjs && node --check src/cli/windows-supervisor.mjs && node --check src/cli/windows-task-restart.mjs && node --check src/cli/windows-update-lock.mjs && node --check src/cli/windows-user-supervisor.mjs && node --check src/fetch-update-manifest.mjs && node --check src/fs-access.mjs && node --check src/npm.mjs && node --check src/runtime.mjs && node --check src/version.mjs",
+    "check": "node --check bin/remcp.mjs && node --check src/agent-deploy-reconnect.mjs && node --check src/agent-network-probe-client.mjs && node --check src/agent-relay-connection.mjs && node --check src/agent-responder.mjs && node --check src/agent-runtime-capabilities.mjs && node --check src/agent-update-monitor.mjs && node --check src/agent-update.mjs && node --check src/agent-utilities.mjs && node --check src/agent.mjs && node --check src/cli.mjs && node --check src/cli/config.mjs && node --check src/cli/connect.mjs && node --check src/cli/doctor.mjs && node --check src/cli/env.mjs && node --check src/cli/installation-audit.mjs && node --check src/cli/mac-native-temperature.mjs && node --check src/cli/npm-global.mjs && node --check src/cli/pairing-qr.mjs && node --check src/cli/service-inventory.mjs && node --check src/cli/service-macos.mjs && node --check src/cli/service-paths.mjs && node --check src/cli/service.mjs && node --check src/cli/shell.mjs && node --check src/cli/update.mjs && node --check src/cli/windows-owned-job-source.mjs && node --check src/cli/windows-owned-job.mjs && node --check src/cli/windows-supervisor.mjs && node --check src/cli/windows-task-restart.mjs && node --check src/cli/windows-update-lock.mjs && node --check src/cli/windows-user-supervisor.mjs && node --check src/fetch-update-manifest.mjs && node --check src/fs-access.mjs && node --check src/npm.mjs && node --check src/runtime.mjs && node --check src/version.mjs",
     "test": "node --test test/*.test.mjs"
   },
   "dependencies": {

package/src/cli/windows-owned-job-source.mjs

@@ -0,0 +1,151 @@
+// Windows 10+: assign the child to an unnamed job during CreateProcess itself.
+// https://learn.microsoft.com/windows/win32/api/processthreadsapi/nf-processthreadsapi-updateprocthreadattribute
+// Only the helper holds the job handle. Neither child nor descendants inherit it.
+export const windowsOwnedJobScript = String.raw`
+$ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
+$job = $null
+try {
+Add-Type -TypeDefinition @'
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+public sealed class ReMcpOwnedJob : IDisposable {
+  [StructLayout(LayoutKind.Sequential)] struct Limits {
+    public long ProcessTime, JobTime; public uint Flags;
+    public UIntPtr MinWorkingSet, MaxWorkingSet; public uint ActiveLimit;
+    public UIntPtr Affinity; public uint Priority, Scheduling;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct Io {
+    public ulong ReadOps, WriteOps, OtherOps, ReadBytes, WriteBytes, OtherBytes;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct ExtendedLimits {
+    public Limits Basic; public Io Counters;
+    public UIntPtr ProcessMemory, JobMemory, PeakProcessMemory, PeakJobMemory;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct Accounting {
+    public long UserTime, KernelTime, PeriodUserTime, PeriodKernelTime;
+    public uint PageFaults, TotalProcesses, ActiveProcesses, TerminatedProcesses;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct Startup {
+    public uint Size; public IntPtr Reserved, Desktop, Title;
+    public uint X, Y, XSize, YSize, XChars, YChars, Fill, Flags;
+    public ushort Show, ReservedSize; public IntPtr ReservedData, In, Out, Error;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct StartupEx {
+    public Startup Basic; public IntPtr Attributes;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct ProcessInfo {
+    public IntPtr Process, Thread; public uint Pid, Tid;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct Security {
+    public int Size; public IntPtr Descriptor;
+    [MarshalAs(UnmanagedType.Bool)] public bool Inherit;
+  }
+  [DllImport("kernel32.dll", SetLastError=true)] static extern IntPtr CreateJobObjectW(IntPtr security, IntPtr name);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool SetInformationJobObject(IntPtr job, int kind, ref ExtendedLimits limits, uint size);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool QueryInformationJobObject(IntPtr job, int kind, out Accounting info, uint size, IntPtr returned);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool TerminateJobObject(IntPtr job, uint code);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool InitializeProcThreadAttributeList(IntPtr list, int count, int flags, ref IntPtr size);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool UpdateProcThreadAttribute(IntPtr list, uint flags, IntPtr key, IntPtr value, IntPtr size, IntPtr previous, IntPtr returned);
+  [DllImport("kernel32.dll")] static extern void DeleteProcThreadAttributeList(IntPtr list);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool CreateProcessW(string application, StringBuilder command, IntPtr processSecurity, IntPtr threadSecurity, bool inherit, uint flags, IntPtr environment, string cwd, ref StartupEx startup, out ProcessInfo info);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern IntPtr CreateFileW(string name, uint access, uint share, ref Security security, uint creation, uint flags, IntPtr template);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool GetExitCodeProcess(IntPtr handle, out uint code);
+  [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
+  IntPtr job, process;
+  int stop;
+  static void Check(bool ok) { if (!ok) throw new Win32Exception(Marshal.GetLastWin32Error()); }
+  static void Close(IntPtr handle) { if (handle != IntPtr.Zero && handle != new IntPtr(-1)) CloseHandle(handle); }
+  public ReMcpOwnedJob() {
+    job = CreateJobObjectW(IntPtr.Zero, IntPtr.Zero);
+    if (job == IntPtr.Zero) throw new Win32Exception(Marshal.GetLastWin32Error());
+    try {
+      var limits = new ExtendedLimits();
+      limits.Basic.Flags = 0x2000; // KILL_ON_JOB_CLOSE; no breakaway allowed.
+      Check(SetInformationJobObject(job, 9, ref limits, (uint)Marshal.SizeOf(limits)));
+    } catch { Dispose(); throw; }
+  }
+  public uint Start(string application, string command, string cwd, string log) {
+    var security = new Security { Size=Marshal.SizeOf(typeof(Security)), Inherit=true };
+    IntPtr output=IntPtr.Zero, input=IntPtr.Zero, list=IntPtr.Zero, handles=IntPtr.Zero, jobs=IntPtr.Zero;
+    bool initialized = false;
+    try {
+      output = CreateFileW(log, 4, 7, ref security, 4, 0x80, IntPtr.Zero); // append, OPEN_ALWAYS
+      Check(output != new IntPtr(-1));
+      input = CreateFileW("NUL", 0x80000000, 7, ref security, 3, 0x80, IntPtr.Zero);
+      Check(input != new IntPtr(-1));
+      IntPtr size = IntPtr.Zero;
+      InitializeProcThreadAttributeList(IntPtr.Zero, 2, 0, ref size);
+      Check(size != IntPtr.Zero);
+      list = Marshal.AllocHGlobal(size);
+      Check(InitializeProcThreadAttributeList(list, 2, 0, ref size)); initialized = true;
+      handles = Marshal.AllocHGlobal(IntPtr.Size * 2);
+      Marshal.WriteIntPtr(handles, input); Marshal.WriteIntPtr(handles, IntPtr.Size, output);
+      Check(UpdateProcThreadAttribute(list, 0, new IntPtr(0x20002), handles, new IntPtr(IntPtr.Size * 2), IntPtr.Zero, IntPtr.Zero));
+      jobs = Marshal.AllocHGlobal(IntPtr.Size); Marshal.WriteIntPtr(jobs, job);
+      Check(UpdateProcThreadAttribute(list, 0, new IntPtr(0x2000D), jobs, new IntPtr(IntPtr.Size), IntPtr.Zero, IntPtr.Zero));
+      var startup = new StartupEx();
+      startup.Basic.Size = (uint)Marshal.SizeOf(startup);
+      startup.Basic.Flags = 0x100; // STARTF_USESTDHANDLES
+      startup.Basic.In = input; startup.Basic.Out = output; startup.Basic.Error = output;
+      startup.Attributes = list;
+      ProcessInfo info;
+      // JOB_LIST attaches before execution, avoiding a suspended-but-unassigned orphan window.
+      Check(CreateProcessW(application, new StringBuilder(command), IntPtr.Zero, IntPtr.Zero,
+        true, 0x08080000, IntPtr.Zero, cwd, ref startup, out info));
+      process = info.Process; Close(info.Thread);
+      return info.Pid;
+    } finally {
+      if (initialized) DeleteProcThreadAttributeList(list);
+      if (list != IntPtr.Zero) Marshal.FreeHGlobal(list);
+      if (handles != IntPtr.Zero) Marshal.FreeHGlobal(handles);
+      if (jobs != IntPtr.Zero) Marshal.FreeHGlobal(jobs);
+      Close(input); Close(output);
+    }
+  }
+  public uint Wait() {
+    var reader = new Thread(() => {
+      // EOF is ownership loss: only Node owns the write end of this private pipe.
+      try { Console.ReadLine(); } catch { } finally { Interlocked.Exchange(ref stop, 1); }
+    });
+    reader.IsBackground = true; reader.Start();
+    while (Volatile.Read(ref stop) == 0) {
+      uint state = WaitForSingleObject(process, 50);
+      if (state == 0) break;
+      if (state != 258) throw new Win32Exception(Marshal.GetLastWin32Error());
+    }
+    Check(TerminateJobObject(job, 1));
+    var timer = Stopwatch.StartNew();
+    while (true) {
+      Accounting info;
+      Check(QueryInformationJobObject(job, 1, out info, (uint)Marshal.SizeOf(typeof(Accounting)), IntPtr.Zero));
+      if (info.ActiveProcesses == 0) break;
+      if (timer.ElapsedMilliseconds >= 7000) throw new TimeoutException("Owned job did not become empty");
+      Thread.Sleep(20);
+    }
+    uint code; Check(GetExitCodeProcess(process, out code)); return code;
+  }
+  public void Dispose() { Close(job); job=IntPtr.Zero; Close(process); process=IntPtr.Zero; }
+}
+'@
+$job = New-Object ReMcpOwnedJob
+  [Console]::WriteLine('{"ready":true}')
+  $line = [Console]::ReadLine()
+  if (!$line) { throw 'Job owner disconnected before start' }
+  $request = ConvertFrom-Json -InputObject ([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($line)))
+  $childId = $job.Start($request.application, $request.command, $request.cwd, $request.log)
+  [Console]::WriteLine(('{"started":true,"pid":' + $childId + '}'))
+  $code = $job.Wait()
+  [Console]::WriteLine(('{"empty":true,"exitCode":' + $code + '}'))
+} catch {
+  $cause = $_.Exception.GetBaseException()
+  [Console]::Error.WriteLine(('Windows owned job failed (' + $cause.GetType().Name + '; code=' + $cause.NativeErrorCode + ').'))
+  exit 1
+} finally { if ($job) { $job.Dispose() } }
+`;

package/src/cli/windows-owned-job.mjs

@@ -0,0 +1,68 @@
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { windowsOwnedJobScript } from './windows-owned-job-source.mjs';
+
+function quote(value) {
+  if (typeof value !== 'string' || value.includes('\0')) throw new Error('Invalid owned-job argument');
+  return '"' + value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, '$1$1') + '"';
+}
+
+// The helper owns an unnamed kernel job; no PID enumeration or taskkill is used.
+// Acknowledgement is emitted only after the job's ActiveProcesses count reaches zero.
+export function spawnWindowsOwnedJob(application, args, { cwd, log, env = process.env } = {}) {
+  if (process.platform !== 'win32') throw new Error('Windows owned jobs require Windows');
+  if (![application, cwd, log].every(p => typeof p === 'string' && !p.includes('\0') && path.isAbsolute(p))) {
+    throw new Error('Owned-job paths must be absolute');
+  }
+  const command = [application, ...args].map(quote).join(' ');
+  if (command.length > 32766) throw new Error('Owned-job command line is too long');
+  const powershell = path.join(process.env.SystemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+  const helper = spawn(powershell, ['-NoProfile', '-NonInteractive', '-EncodedCommand',
+    Buffer.from(windowsOwnedJobScript, 'utf16le').toString('base64')], {
+    cwd:path.dirname(powershell), env, windowsHide:true, stdio:['pipe','pipe','pipe'],
+  });
+  let output = '', stderr = '', started = false, empty = false, settled = false;
+  let resolveReady, rejectReady, resolveDone, rejectDone;
+  const ready = new Promise((resolve, reject) => { resolveReady=resolve; rejectReady=reject; });
+  const done = new Promise((resolve, reject) => { resolveDone=resolve; rejectDone=reject; });
+  // Callers may observe readiness and completion separately; suppress unhandled rejection noise.
+  ready.catch(() => {}); done.catch(() => {});
+  const fail = error => { rejectReady(error); rejectDone(error); };
+  const timer = setTimeout(() => { fail(new Error('Windows job startup timed out')); helper.kill(); }, 15000);
+  helper.stdin.on('error', () => {});
+  helper.stderr.on('data', chunk => { stderr = (stderr + chunk).slice(-2048); });
+  helper.stdout.on('data', chunk => {
+    output += chunk.toString('utf8');
+    if (output.length > 4096) { fail(new Error('Invalid Windows job response')); helper.kill(); return; }
+    while (output.includes('\n')) {
+      const index = output.indexOf('\n'), line = output.slice(0,index).trim(); output=output.slice(index+1);
+      try {
+        const message = JSON.parse(line);
+        if (message.ready === true && !started) {
+          // ASCII envelope survives Windows PowerShell 5.1's OEM console codepage.
+          helper.stdin.write(Buffer.from(JSON.stringify({application,command,cwd,log}),'utf8').toString('base64') + '\n');
+        } else if (message.started === true && Number.isSafeInteger(message.pid) && message.pid > 0 && !started) {
+          started=true; helper.ownedJob.running=true; helper.ownedJob.pid=message.pid;
+          clearTimeout(timer); resolveReady(message);
+        } else if (message.empty === true && started) { empty=true; helper.ownedJob.running=false; }
+        else throw new Error('Unexpected Windows job response');
+      } catch { fail(new Error('Invalid Windows job response')); helper.kill(); }
+    }
+  });
+  helper.on('error', error => { clearTimeout(timer); fail(error); });
+  helper.on('close', code => {
+    clearTimeout(timer); helper.ownedJob.running=false; settled=true;
+    helper.ownedJob.confirmedEmpty = code === 0 && started && empty;
+    if (helper.ownedJob.confirmedEmpty) resolveDone();
+    else fail(new Error('Windows owned job failed: ' + stderr.trim().slice(0,300)));
+    if (!started) rejectReady(new Error('Windows job exited before readiness'));
+  });
+  helper.ownedJob = { ready, done, running:false, confirmedEmpty:false, pid:null, stop: async () => {
+    if (!settled) helper.stdin.end('STOP\n');
+    let timeout;
+    try { await Promise.race([done, new Promise((_, reject) => {
+      timeout=setTimeout(() => reject(new Error('Windows owned job stop timed out')), 9000);
+    })]); } finally { clearTimeout(timeout); }
+  }};
+  return helper;
+}

package/src/cli/windows-update-lock.mjs

@@ -67,11 +67,25 @@ export function withWindowsUpdateLock(prefix, operation) {
   }
 
   const onExit = () => removeOwnedLock(directory, token);
-  process.once('exit', onExit);
-  try {
-    return operation();
-  } finally {
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
     process.removeListener('exit', onExit);
     removeOwnedLock(directory, token);
+  };
+  process.once('exit', onExit);
+  try {
+    const result = operation();
+    // A future async installer must retain the prefix lock until it settles.
+    // Releasing here would let another updater move the same package/shims.
+    if (result && typeof result.then === 'function') {
+      return Promise.resolve(result).finally(release);
+    }
+    release();
+    return result;
+  } catch (error) {
+    release();
+    throw error;
   }
 }

package/src/cli/windows-user-supervisor.mjs

@@ -8,6 +8,7 @@ import process from 'node:process';
 import crypto from 'node:crypto';
 import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { spawnWindowsOwnedJob } from './windows-owned-job.mjs';
 
 const currentFile = fileURLToPath(import.meta.url);
 const root = process.env.REMCP_CONFIG_DIR || path.join(os.homedir(), '.config', 'remcp');
@@ -94,33 +95,48 @@ async function serve(cliEntry) {
   let requestedRestart = null;
   let startedAt = 0;
   let lastExit = null;
+  let containmentFailure = null;
   const usedNonces = new Set();
 
   function start() {
-    if (stopped || child) return;
+    if (stopped || child || containmentFailure) return;
     const logFile = path.join(root, 'windows-startup-agent.log');
     try { if (fs.statSync(logFile).size > 4 * 1024 * 1024) fs.truncateSync(logFile, 0); } catch {}
     const log = fs.openSync(logFile, 'a', 0o600);
     const prefix = path.resolve(path.dirname(cliEntry), '../../../../');
     try {
-      child = spawn(process.execPath, [cliEntry, 'start', '--service'], {
-        cwd: root, windowsHide: true, stdio: ['ignore', log, log, 'ipc'],
-        env: { ...process.env, REMCP_USER_STARTUP_SUPERVISOR:'1', NPM_CONFIG_PREFIX: prefix,
-          PATH: path.dirname(process.execPath) + path.delimiter + (process.env.PATH || '') },
-      });
+      const env = { ...process.env, REMCP_USER_STARTUP_SUPERVISOR:'1', NPM_CONFIG_PREFIX: prefix,
+        PATH: path.dirname(process.execPath) + path.delimiter + (process.env.PATH || '') };
+      child = process.platform === 'win32'
+        ? spawnWindowsOwnedJob(process.execPath, [cliEntry, 'start', '--service'], {cwd:root,log:logFile,env})
+        : spawn(process.execPath, [cliEntry, 'start', '--service'], {
+          cwd:root, windowsHide:true, stdio:['ignore',log,log,'ipc'], env,
+        });
     } finally { fs.closeSync(log); }
     const ownChild = child;
     startedAt = Date.now();
+    ownChild.ownedJob?.ready.then(() => { startedAt=Date.now(); }).catch(error => { lastExit=error.message; });
+    ownChild.ownedJob?.done.catch(error => { lastExit=error.message; });
     ownChild.on('error', error => {
       lastExit = error.message;
+      if (ownChild.ownedJob) {
+        containmentFailure = new Error('Windows job ownership failed; restart refused');
+        stopped=true;
+        return; // Retain the owner until close; only confirmedEmpty can release it.
+      }
       if (child === ownChild) {
         child = null;
         if (!stopped) restartTimer = setTimeout(start, 3000);
       }
     });
-    ownChild.on('exit', (code, signal) => {
+    ownChild.on('close', (code, signal) => {
       if (child !== ownChild) return;
       child = null;
+      // Completion failure does not prove the previous tree is empty. Fail closed.
+      if (ownChild.ownedJob && !ownChild.ownedJob.confirmedEmpty) {
+        containmentFailure = new Error('Windows job did not confirm an empty process tree; restart refused');
+        stopped=true; lastExit=containmentFailure.message; return;
+      }
       lastExit = code === null ? String(signal || 'unknown') : String(code);
       if (!stopped) restartTimer = setTimeout(start, 3000);
     });
@@ -128,17 +144,12 @@ async function serve(cliEntry) {
 
   async function endChild() {
     clearTimeout(restartTimer);
+    if (containmentFailure) throw containmentFailure;
     const ownChild = child;
     if (!ownChild) return;
+    if (ownChild.ownedJob) { await ownChild.ownedJob.stop(); return; }
     if (ownChild.exitCode === null && !ownChild.killed) {
-      if (process.platform === 'win32') {
-        const result = spawnSync('taskkill.exe', ['/PID', String(ownChild.pid), '/T', '/F'], {
-          windowsHide: true, encoding: 'utf8', timeout: 7000, maxBuffer: 2048,
-        });
-        if (result.status !== 0 && ownChild.exitCode === null) {
-          throw new Error('Could not terminate owned agent process tree');
-        }
-      } else ownChild.kill('SIGTERM');
+      ownChild.kill('SIGTERM');
     }
     if (ownChild.exitCode === null) await Promise.race([
       new Promise(resolve => ownChild.once('exit', resolve)),
@@ -184,6 +195,7 @@ async function serve(cliEntry) {
               process.exit(0);
             });
           } else if (request.action === 'restart') {
+            if (containmentFailure) throw containmentFailure;
             // Agent-initiated npm updates call this from a child of the current agent.
             // Killing that tree before the update CLI returns can abort the updater itself.
             // Coalesce requests and schedule the owned-child handoff after acknowledgement.
@@ -194,14 +206,14 @@ async function serve(cliEntry) {
                   stopped = true;
                   try { await endChild(); }
                   catch (error) { console.error('ReMCP supervisor restart failed:', error.message); }
-                  finally { stopped = false; if (!child) start(); }
+                  finally { if (!containmentFailure) { stopped = false; if (!child) start(); } }
                 })();
               }, 2500);
             }
             reply({ ok: true, restartScheduled: true });
           } else reply({
-            ok: true, childPid: child?.pid || null,
-            running: Boolean(child?.pid && child.exitCode === null),
+            ok: true, childPid: child?.ownedJob?.pid || child?.pid || null,
+            running: Boolean(child?.pid && child.exitCode === null && (!child.ownedJob || child.ownedJob.running)),
             restartPending: Boolean(requestedRestart),
             uptimeMs: child ? Date.now() - startedAt : null, lastExit,
           });