@remcp/remcp 0.2.116 → 0.2.118

package/README.md

@@ -9,10 +9,12 @@ remcp --version
 remcp status
 ```
 
-Pairing commands are generated in the workspace at <https://remcp.site/app/connect>. The
-generated command runs `remcp connect --server … --code … --install`, which stores a per-device
-credential under `~/.config/remcp/`, installs the runtime from npm, and registers a user service
-(systemd on Linux, LaunchAgent on macOS, Scheduled Task on Windows).
+Pairing commands are generated in the workspace at <https://remcp.site/app/connect>. On Windows,
+the browser shows a PowerShell bootstrap that needs no preinstalled system Node.js/npm/npx/winget;
+it keeps the ReMCP runtime under `%LOCALAPPDATA%\ReMCP`. Generated one-time commands ultimately run
+`remcp connect --server … --code … --install`, which stores a per-device credential, installs the
+runtime, and registers a user service (systemd on Linux, LaunchAgent on macOS, Scheduled Task on
+Windows).
 
 ## Commands
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/remcp",
-  "version": "0.2.116",
+  "version": "0.2.118",
   "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/env.mjs

@@ -16,6 +16,7 @@ export const macServiceLabel = 'com.remcp.agent';
 export const macServiceFile = path.join(home, 'Library', 'LaunchAgents', `${macServiceLabel}.plist`);
 export const macLogFile = path.join(home, 'Library', 'Logs', 'remcp-agent.log');
 export const windowsTaskName = 'ReMCP Agent';
+export const windowsServiceLauncherFile = path.join(configDir, 'remcp-agent.cmd');
 // How npm is invoked is resolved from the running node when possible: a background service has a
 // minimal PATH, which is why auto-update used to find no npm on macOS. See src/npm.mjs.
 export const npm = resolveNpm();

package/src/cli/service.mjs

@@ -9,7 +9,7 @@ import { resolveNpm } from '../npm.mjs';
 import { PACKAGE_NAME, VERSION } from '../version.mjs';
 
 import { saveConfig } from './config.mjs';
-import { configDir, home, linuxServiceFile, linuxServiceLauncherFile, macLogFile, macServiceFile, macServiceLabel, npm, windowsTaskName } from './env.mjs';
+import { configDir, home, linuxServiceFile, linuxServiceLauncherFile, macLogFile, macServiceFile, macServiceLabel, npm, windowsServiceLauncherFile, windowsTaskName } from './env.mjs';
 import { output, run } from './shell.mjs';
 
 export function servicePlatform() {
@@ -51,13 +51,30 @@ function pathEntryExists(file) {
   }
 }
 
-function globalPackagePath(prefix, packageName) {
+function globalPackagePath(prefix, packageName, platform = servicePlatform()) {
   const name = String(packageName || '').trim();
   const parts = name.split('/');
   const validUnscoped = parts.length === 1 && parts[0] && !parts[0].startsWith('@') && parts[0] !== '.' && parts[0] !== '..';
   const validScoped = parts.length === 2 && /^@[^/]+$/.test(parts[0]) && parts[1] && parts[1] !== '.' && parts[1] !== '..';
   if (!validUnscoped && !validScoped) throw new Error(`Invalid npm package name for update: ${name || '(empty)'}`);
-  return path.join(prefix, 'lib', 'node_modules', ...parts);
+  const modulesRoot = platform === 'win32'
+    ? path.join(prefix, 'node_modules')
+    : path.join(prefix, 'lib', 'node_modules');
+  return path.join(modulesRoot, ...parts);
+}
+
+function managedWindowsRuntimePrefix() {
+  return path.resolve(
+    process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local'),
+    'ReMCP',
+    'runtime',
+  );
+}
+
+function isManagedWindowsRuntimePrefix(prefix) {
+  const actual = path.resolve(String(prefix || ''));
+  const expected = managedWindowsRuntimePrefix();
+  return actual.toLowerCase() === expected.toLowerCase();
 }
 
 function transactionalMacGlobalInstall({ resolved, prefix, packageNames, specs, preferOnline = false }) {
@@ -111,26 +128,93 @@ function transactionalMacGlobalInstall({ resolved, prefix, packageNames, specs,
   }
 }
 
+function transactionalWindowsGlobalInstall({ resolved, prefix, packageNames, specs, preferOnline = false }) {
+  prefix = String(prefix || '').trim();
+  if (!path.isAbsolute(prefix)) throw new Error(`npm global prefix must be absolute for a Windows update: ${prefix || '(empty)'}`);
+  if (!isManagedWindowsRuntimePrefix(prefix)) {
+    run(resolved.command, [...resolved.args, ...npmGlobalInstallArgs(specs, { preferOnline })]);
+    return;
+  }
+
+  const backupRoot = path.join(prefix, `.remcp-update-backup-${process.pid}-${Date.now()}`);
+  const moved = [];
+  const moveAside = (source, label) => {
+    if (!pathEntryExists(source)) return;
+    const backup = path.join(backupRoot, label);
+    fs.renameSync(source, backup);
+    moved.push({ source, backup });
+  };
+  const restore = originalError => {
+    let rollbackError = null;
+    for (const item of [...moved].reverse()) {
+      try {
+        if (pathEntryExists(item.source)) fs.rmSync(item.source, { recursive:true, force:true });
+        fs.mkdirSync(path.dirname(item.source), { recursive:true });
+        fs.renameSync(item.backup, item.source);
+      } catch (error) {
+        rollbackError ??= error;
+      }
+    }
+    try { fs.rmSync(backupRoot, { recursive:true, force:true }); } catch (error) { rollbackError ??= error; }
+    if (rollbackError) {
+      throw new Error(
+        `ReMCP update failed and the previous Windows installation could not be fully restored: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`,
+        { cause:originalError },
+      );
+    }
+  };
+
+  fs.mkdirSync(prefix, { recursive:true });
+  fs.mkdirSync(backupRoot, { recursive:false, mode:0o700 });
+  try {
+    const uniqueNames = [...new Set(packageNames.map(name => String(name || '').trim()).filter(Boolean))];
+    uniqueNames.forEach((name, index) => moveAside(globalPackagePath(prefix, name, 'win32'), `package-${index}`));
+    if (uniqueNames.includes(PACKAGE_NAME)) {
+      for (const shim of ['remcp', 'remcp.cmd', 'remcp.ps1']) moveAside(path.join(prefix, shim), `bin-${shim}`);
+    }
+    run(resolved.command, [...resolved.args, ...npmGlobalInstallArgs(specs, { preferOnline })]);
+  } catch (error) {
+    restore(error);
+    throw error;
+  }
+
+  try {
+    fs.rmSync(backupRoot, { recursive:true, force:true });
+  } catch (error) {
+    console.error(`ReMCP update: could not remove Windows rollback backup ${backupRoot}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
 // Release updates use exact versions that may have been published only moments ago. npm can keep a
 // cached pre-publication packument long enough to answer ETARGET after the registry already serves the
 // version, so updates revalidate metadata while retaining npm's cache for package bytes.
 export function npmGlobalUpdate(packageNames, ...specs) {
-  if (servicePlatform() !== 'darwin') {
-    run(npm.command, [...npm.args, ...npmGlobalInstallArgs(specs, { preferOnline:true })]);
+  const platform = servicePlatform();
+  const prefix = globalPrefix();
+  if (platform === 'darwin') {
+    transactionalMacGlobalInstall({ resolved:npm, prefix, packageNames, specs, preferOnline:true });
     return;
   }
-  const prefix = globalPrefix();
-  transactionalMacGlobalInstall({ resolved:npm, prefix, packageNames, specs, preferOnline:true });
+  if (platform === 'win32') {
+    transactionalWindowsGlobalInstall({ resolved:npm, prefix, packageNames, specs, preferOnline:true });
+    return;
+  }
+  run(npm.command, [...npm.args, ...npmGlobalInstallArgs(specs, { preferOnline:true })]);
 }
 
 export function npmGlobalUpdateForNode(nodePath, packageNames, ...specs) {
-  const resolved = resolveNpm({ nodePath, home, platform:servicePlatform() });
-  if (servicePlatform() !== 'darwin') {
-    run(resolved.command, [...resolved.args, ...npmGlobalInstallArgs(specs, { preferOnline:true })]);
+  const platform = servicePlatform();
+  const resolved = resolveNpm({ nodePath, home, platform });
+  const prefix = output(resolved.command, [...resolved.args, 'prefix', '--global']);
+  if (platform === 'darwin') {
+    transactionalMacGlobalInstall({ resolved, prefix, packageNames, specs, preferOnline:true });
     return;
   }
-  const prefix = output(resolved.command, [...resolved.args, 'prefix', '--global']);
-  transactionalMacGlobalInstall({ resolved, prefix, packageNames, specs, preferOnline:true });
+  if (platform === 'win32') {
+    transactionalWindowsGlobalInstall({ resolved, prefix, packageNames, specs, preferOnline:true });
+    return;
+  }
+  run(resolved.command, [...resolved.args, ...npmGlobalInstallArgs(specs, { preferOnline:true })]);
 }
 
 export function quoteSystemd(value) {
@@ -350,8 +434,32 @@ export function installMacService(cliPath = globalCliPath(), { restart = true, n
   return 'bootstrapped';
 }
 
-export function installWindowsService(cliPath = globalCliPath()) {
-  const command = `"${cliPath}" start --service`;
+function windowsBatchValue(value) {
+  return String(value).replaceAll('%', '%%');
+}
+
+export function writeWindowsServiceLauncher(cliPath = globalCliPath(), nodePath = process.execPath) {
+  const prefix = path.dirname(cliPath);
+  const nodeDir = path.dirname(nodePath);
+  const launcher = [
+    '@echo off',
+    'setlocal DisableDelayedExpansion',
+    `set "NPM_CONFIG_PREFIX=${windowsBatchValue(prefix)}"`,
+    `set "PATH=${windowsBatchValue(nodeDir)};%PATH%"`,
+    `call "${windowsBatchValue(cliPath)}" start --service`,
+    'exit /b %ERRORLEVEL%',
+    '',
+  ].join('\r\n');
+  fs.mkdirSync(configDir, { recursive:true, mode:0o700 });
+  const temporary = `${windowsServiceLauncherFile}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(temporary, launcher, { mode:0o700 });
+  fs.renameSync(temporary, windowsServiceLauncherFile);
+  return windowsServiceLauncherFile;
+}
+
+export function installWindowsService(cliPath = globalCliPath(), { nodePath = process.execPath } = {}) {
+  const launcherFile = writeWindowsServiceLauncher(cliPath, nodePath);
+  const command = `"${launcherFile}"`;
   run('schtasks.exe', ['/Create', '/TN', windowsTaskName, '/TR', command, '/SC', 'ONLOGON', '/RL', 'HIGHEST', '/F']);
   run('schtasks.exe', ['/Run', '/TN', windowsTaskName]);
 }
@@ -450,13 +558,24 @@ function packageVersionBesideCli(cliPath, packageName) {
   return versionFromPackageJson(path.join(nodeModules, ...String(packageName).split('/'), 'package.json'));
 }
 
+function packageVersionForCli(cliPath, packageName) {
+  const beside = packageVersionBesideCli(cliPath, packageName);
+  if (beside || servicePlatform() !== 'win32' || !cliPath || !packageName) return beside;
+  // npm's Windows global executable is a .cmd shim in the prefix root, not a symlink into
+  // node_modules. realpath() therefore cannot reveal the package directory like it does on Unix.
+  // Resolve the package from the same prefix layout npm uses on Windows.
+  if (path.basename(cliPath).toLowerCase() !== 'remcp.cmd') return null;
+  const prefix = path.dirname(cliPath);
+  return versionFromPackageJson(path.join(prefix, 'node_modules', ...String(packageName).split('/'), 'package.json'));
+}
+
 export function installationVersionsAtCliPath(cliPath, runtimePackageName) {
   if (!cliPath) return { cliVersion:null, runtimeVersion:null, cliPath:null };
   let resolvedCliPath = cliPath;
   try { if (fs.existsSync(cliPath)) resolvedCliPath = fs.realpathSync(cliPath); } catch {}
   return {
-    cliVersion:packageVersionBesideCli(resolvedCliPath, PACKAGE_NAME),
-    runtimeVersion:packageVersionBesideCli(resolvedCliPath, runtimePackageName),
+    cliVersion:packageVersionForCli(resolvedCliPath, PACKAGE_NAME),
+    runtimeVersion:packageVersionForCli(resolvedCliPath, runtimePackageName),
     cliPath:resolvedCliPath,
   };
 }
@@ -468,8 +587,8 @@ export function serviceInstallationInfo(config) {
   let resolvedCliPath = cliPath;
   try { if (cliPath && fs.existsSync(cliPath)) resolvedCliPath = fs.realpathSync(cliPath); } catch {}
   return {
-    cliVersion:packageVersionBesideCli(resolvedCliPath, PACKAGE_NAME),
-    runtimeVersion:packageVersionBesideCli(resolvedCliPath, config?.runtime?.packageName),
+    cliVersion:packageVersionForCli(resolvedCliPath, PACKAGE_NAME),
+    runtimeVersion:packageVersionForCli(resolvedCliPath, config?.runtime?.packageName),
     cliPath:resolvedCliPath || cliPath,
     nodePath,
   };
@@ -480,7 +599,7 @@ export function currentInstallationInfo(config) {
   try { if (cliPath && fs.existsSync(cliPath)) cliPath = fs.realpathSync(cliPath); } catch {}
   return {
     cliVersion:VERSION,
-    runtimeVersion:config?.runtime?.packageName ? packageVersionBesideCli(cliPath, config.runtime.packageName) : null,
+    runtimeVersion:config?.runtime?.packageName ? packageVersionForCli(cliPath, config.runtime.packageName) : null,
     cliPath:cliPath || null,
     nodePath:process.execPath,
   };
@@ -599,7 +718,7 @@ export function installPersistentAgent(config) {
   else if (platform === 'darwin') {
     installMacService(cliPath, { nodePath });
     ensureMacCliCommand(config, { cliPath:cliScript, nodePath });
-  } else installWindowsService(cliPath);
+  } else installWindowsService(cliPath, { nodePath });
   configurePostInstallAccess();
   saveConfig({ ...config, serviceInstalled: true, serviceCliPath: cliScript, serviceNodePath: nodePath });
   console.log('ReMCP is installed as a background service. Future updates: remcp update');
@@ -663,7 +782,7 @@ export function ensureServiceIfRecorded(config) {
       const state = installMacService(cliPath, { restart: false, nodePath });
       ensureMacCliCommand(config, { cliPath, nodePath });
       if (state === 'reload-scheduled') restartScheduled = macServiceLabel;
-    } else if (platform === 'win32') installWindowsService(cliPath);
+    } else if (platform === 'win32') installWindowsService(cliPath, { nodePath });
     // Upgrade the legacy inferred state only after the supervisor repair succeeded. A failed repair
     // must not turn a stale artifact into a permanent "managed service" declaration.
     const cliScript = resolvedCliScript(cliPath);
@@ -722,5 +841,6 @@ export function uninstallPersistentService() {
   } else if (platform === 'win32') {
     spawnSync('schtasks.exe', ['/End', '/TN', windowsTaskName], { stdio: 'ignore' });
     spawnSync('schtasks.exe', ['/Delete', '/TN', windowsTaskName, '/F'], { stdio: 'ignore' });
+    try { fs.unlinkSync(windowsServiceLauncherFile); } catch {}
   }
 }