@remcp/remcp 0.2.54 → 0.2.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/remcp",
-  "version": "0.2.54",
+  "version": "0.2.56",
   "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/service.mjs

@@ -29,9 +29,92 @@ export function npmGlobalInstall(...specs) {
   run(npm.command, [...npm.args, 'install', '--global', ...specs, '--no-audit', '--no-fund', '--loglevel=error']);
 }
 
-export function npmGlobalInstallForNode(nodePath, ...specs) {
+function pathEntryExists(file) {
+  try {
+    fs.lstatSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function globalPackagePath(prefix, packageName) {
+  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);
+}
+
+function transactionalMacGlobalInstall({ resolved, prefix, packageNames, specs }) {
+  prefix = String(prefix || '').trim();
+  if (!path.isAbsolute(prefix)) throw new Error(`npm global prefix must be absolute for a macOS update: ${prefix || '(empty)'}`);
+  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 macOS 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), `package-${index}`));
+    if (uniqueNames.includes(PACKAGE_NAME)) moveAside(path.join(prefix, 'bin', 'remcp'), 'bin-remcp');
+
+    run(resolved.command, [...resolved.args, 'install', '--global', ...specs, '--no-audit', '--no-fund', '--loglevel=error']);
+  } catch (error) {
+    restore(error);
+    throw error;
+  }
+
+  try {
+    fs.rmSync(backupRoot, { recursive:true, force:true });
+  } catch (error) {
+    console.error(`ReMCP update: could not remove macOS rollback backup ${backupRoot}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export function npmGlobalUpdate(packageNames, ...specs) {
+  if (servicePlatform() !== 'darwin') {
+    npmGlobalInstall(...specs);
+    return;
+  }
+  const prefix = globalPrefix();
+  transactionalMacGlobalInstall({ resolved:npm, prefix, packageNames, specs });
+}
+
+export function npmGlobalUpdateForNode(nodePath, packageNames, ...specs) {
   const resolved = resolveNpm({ nodePath, home, platform:servicePlatform() });
-  run(resolved.command, [...resolved.args, 'install', '--global', ...specs, '--no-audit', '--no-fund', '--loglevel=error']);
+  if (servicePlatform() !== 'darwin') {
+    run(resolved.command, [...resolved.args, 'install', '--global', ...specs, '--no-audit', '--no-fund', '--loglevel=error']);
+    return;
+  }
+  const prefix = output(resolved.command, [...resolved.args, 'prefix', '--global']);
+  transactionalMacGlobalInstall({ resolved, prefix, packageNames, specs });
 }
 
 export function quoteSystemd(value) {
@@ -75,6 +158,100 @@ function shellQuote(value) {
   return `'${String(value).replaceAll("'", "'\\''")}'`;
 }
 
+const remcpPathBlockStart = '# >>> ReMCP CLI PATH >>>';
+const remcpPathBlockEnd = '# <<< ReMCP CLI PATH <<<';
+const remcpCliShimMarker = '# ReMCP managed CLI shim';
+
+function macCliShimPath() {
+  return path.join(home, '.local', 'bin', 'remcp');
+}
+
+function interactiveShellProfile() {
+  const shell = String(process.env.REMCP_TEST_SHELL || process.env.SHELL || os.userInfo().shell || '/bin/zsh');
+  const name = path.basename(shell);
+  if (name === 'zsh') return path.join(home, '.zshrc');
+  if (name === 'bash') return path.join(home, '.bash_profile');
+  return '';
+}
+
+function upsertManagedPathBlock(file) {
+  if (!file) return false;
+  const block = [
+    remcpPathBlockStart,
+    'case ":$PATH:" in',
+    '  *":$HOME/.local/bin:"*) ;;',
+    '  *) export PATH="$HOME/.local/bin:$PATH" ;;',
+    'esac',
+    remcpPathBlockEnd,
+  ].join('\n');
+  let current = '';
+  try { current = fs.readFileSync(file, 'utf8'); } catch {}
+  const start = current.indexOf(remcpPathBlockStart);
+  const end = start >= 0 ? current.indexOf(remcpPathBlockEnd, start + remcpPathBlockStart.length) : -1;
+  let next;
+  if (start >= 0 && end >= 0) {
+    next = current.slice(0, start) + block + current.slice(end + remcpPathBlockEnd.length);
+  } else {
+    const prefix = current && !current.endsWith('\n') ? current + '\n' : current;
+    next = prefix + (prefix ? '\n' : '') + block + '\n';
+  }
+  if (next === current) return false;
+  fs.writeFileSync(file, next, { mode:0o600 });
+  return true;
+}
+
+function removeManagedPathBlock(file) {
+  if (!file) return;
+  let current = '';
+  try { current = fs.readFileSync(file, 'utf8'); } catch { return; }
+  const start = current.indexOf(remcpPathBlockStart);
+  const end = start >= 0 ? current.indexOf(remcpPathBlockEnd, start + remcpPathBlockStart.length) : -1;
+  if (start < 0 || end < 0) return;
+  let before = current.slice(0, start);
+  let after = current.slice(end + remcpPathBlockEnd.length);
+  if (before.endsWith('\n') && after.startsWith('\n')) after = after.slice(1);
+  const next = before + after;
+  fs.writeFileSync(file, next, { mode:0o600 });
+}
+
+export function ensureMacCliCommand(config = {}, { cliPath = '', nodePath = '' } = {}) {
+  if (servicePlatform() !== 'darwin') return null;
+  const effectiveCli = cliPath || (persistentServiceExpected(config) ? canonicalServiceCliPath(config) : globalCliPath());
+  const effectiveNode = nodePath || (persistentServiceExpected(config) ? canonicalServiceNodePath(config) : process.execPath);
+  const cliScript = resolvedCliScript(effectiveCli);
+  const shim = macCliShimPath();
+  try {
+    const existing = fs.readFileSync(shim, 'utf8');
+    if (!existing.includes(remcpCliShimMarker)) {
+      console.error(`ReMCP did not replace ${shim} because it is not a ReMCP-managed command.`);
+      return null;
+    }
+  } catch (error) {
+    if (error?.code && error.code !== 'ENOENT') {
+      console.error(`ReMCP could not inspect ${shim}: ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }
+  }
+  const launcher = `#!/bin/sh\n${remcpCliShimMarker}\nexec ${shellQuote(effectiveNode)} ${shellQuote(cliScript)} "$@"\n`;
+  fs.mkdirSync(path.dirname(shim), { recursive:true, mode:0o755 });
+  const temporary = `${shim}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(temporary, launcher, { mode:0o755 });
+  fs.chmodSync(temporary, 0o755);
+  fs.renameSync(temporary, shim);
+  upsertManagedPathBlock(interactiveShellProfile());
+  return shim;
+}
+
+function removeMacCliCommand() {
+  if (servicePlatform() !== 'darwin') return;
+  const shim = macCliShimPath();
+  try {
+    const existing = fs.readFileSync(shim, 'utf8');
+    if (existing.includes(remcpCliShimMarker)) fs.unlinkSync(shim);
+  } catch {}
+  removeManagedPathBlock(interactiveShellProfile());
+}
+
 function macServicePlist(cliPath, nodePath = process.execPath) {
   // launchd wants an absolute path; a symlinked prefix that npm has not materialised yet (or a path
   // that is about to be replaced by the next install) must not abort the repair — a stale plist is
@@ -337,7 +514,7 @@ export function syncKnownInstallations(config, ...specs) {
     seen.add(resolvedNode);
     const required = Boolean(candidate?.service) || resolvedNode === serviceInfo.nodePath;
     try {
-      npmGlobalInstallForNode(resolvedNode, ...specs);
+      npmGlobalUpdateForNode(resolvedNode, [PACKAGE_NAME, config.runtime.packageName], ...specs);
       results.push({ nodePath:resolvedNode, ok:true, required });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -403,8 +580,10 @@ export function installPersistentAgent(config) {
   const cliScript = resolvedCliScript(cliPath);
   const nodePath = process.execPath;
   if (platform === 'linux') installLinuxService(cliPath, nodePath);
-  else if (platform === 'darwin') installMacService(cliPath, { nodePath });
-  else installWindowsService(cliPath);
+  else if (platform === 'darwin') {
+    installMacService(cliPath, { nodePath });
+    ensureMacCliCommand(config, { cliPath:cliScript, nodePath });
+  } else installWindowsService(cliPath);
   configurePostInstallAccess();
   saveConfig({ ...config, serviceInstalled: true, serviceCliPath: cliScript, serviceNodePath: nodePath });
   console.log('ReMCP is installed as a background service. Future updates: remcp update');
@@ -447,6 +626,7 @@ export function ensureServiceIfRecorded(config) {
       // installMacService either leaves an unchanged loaded job alone, bootstraps an unloaded job, or
       // hands a changed launcher to an independent transient launchd helper.
       const state = installMacService(cliPath, { restart: false, nodePath });
+      ensureMacCliCommand(config, { cliPath, nodePath });
       if (state === 'reload-scheduled') restartScheduled = macServiceLabel;
     } else if (platform === 'win32') installWindowsService(cliPath);
     // Upgrade the legacy inferred state only after the supervisor repair succeeded. A failed repair
@@ -503,6 +683,7 @@ export function uninstallPersistentService() {
     const domain = macLaunchDomain();
     spawnSync('launchctl', ['bootout', domain, macServiceFile], { stdio: 'ignore' });
     try { fs.unlinkSync(macServiceFile); } catch {}
+    removeMacCliCommand();
   } else if (platform === 'win32') {
     spawnSync('schtasks.exe', ['/End', '/TN', windowsTaskName], { stdio: 'ignore' });
     spawnSync('schtasks.exe', ['/Delete', '/TN', windowsTaskName, '/F'], { stdio: 'ignore' });

package/src/cli/update.mjs

@@ -11,7 +11,7 @@ import { PACKAGE_NAME, VERSION } from '../version.mjs';
 import { loadConfig, saveConfig } from './config.mjs';
 import { installedVersion } from './doctor.mjs';
 import { linuxServiceFile, macServiceFile, officialOrigin } from './env.mjs';
-import { currentInstallationInfo, ensureServiceIfRecorded, installationVersionsAtCliPath, npmGlobalInstall, persistentServiceExpected, rememberCurrentInstallation, restartPersistentServiceIfInstalled, serviceInstallationInfo, syncKnownInstallations } from './service.mjs';
+import { currentInstallationInfo, ensureMacCliCommand, ensureServiceIfRecorded, installationVersionsAtCliPath, npmGlobalUpdate, persistentServiceExpected, rememberCurrentInstallation, restartPersistentServiceIfInstalled, serviceInstallationInfo, syncKnownInstallations } from './service.mjs';
 
 const UPDATE_DISCOVERY_TIMEOUT_MS = 5000;
 
@@ -232,6 +232,9 @@ export async function updateCommand(flags) {
   }
 
   if (alreadyCurrent) {
+    // `npx @remcp/remcp@latest update` is the recovery path when a Node-manager prefix was never
+    // exported into the user's shell. Even with no package delta, repair the stable macOS command.
+    ensureMacCliCommand(cfg);
     if (targets.persistRuntime) {
       saveConfig({ ...cfg, runtime:{ ...cfg.runtime, packageSpec:targets.runtimeSpec } });
     }
@@ -242,7 +245,7 @@ export async function updateCommand(flags) {
 
   const before = { cli: VERSION, runtime: installedVersion(cfg.runtime.packageName) };
   console.log(`Updating ReMCP to ${targets.clientSpec} with ${targets.runtimeSpec}…`);
-  npmGlobalInstall(targets.clientSpec, targets.runtimeSpec);
+  npmGlobalUpdate([PACKAGE_NAME, cfg.runtime.packageName], targets.clientSpec, targets.runtimeSpec);
 
   // Converge every ReMCP installation this account has actually used on this machine. The canonical
   // service installation is mandatory; secondary nvm/Hermes/Homebrew copies are best-effort and

package/src/cli.mjs

@@ -11,7 +11,7 @@ import { ensureMachineId, loadConfig, readJsonFile, saveConfig, setTelemetry, te
 import { assertRuntimeTrust, pairWithDeviceCode } from './cli/connect.mjs';
 import { diagnoseLocalRuntime, installedVersion, runtimeAllowedRoots } from './cli/doctor.mjs';
 import { configFile, npm, officialOrigin, runtimeConfigFile } from './cli/env.mjs';
-import { currentInstallationInfo, installPersistentAgent, persistentServiceState, rememberCurrentInstallation, restartPersistentServiceIfInstalled, serviceInstallationInfo, uninstallPersistentService } from './cli/service.mjs';
+import { currentInstallationInfo, ensureMacCliCommand, installPersistentAgent, persistentServiceState, rememberCurrentInstallation, restartPersistentServiceIfInstalled, serviceInstallationInfo, uninstallPersistentService } from './cli/service.mjs';
 import { run } from './cli/shell.mjs';
 import { updateCommand } from './cli/update.mjs';
 function parse(argv) {
@@ -97,6 +97,10 @@ 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 });
+    // 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.
+    ensureMacCliCommand(cfg);
     const service = persistentServiceState(cfg);
     if (!supervised && service.active) {
       console.log(`ReMCP is already running as a background service (${service.name}). Use \`remcp status\` to inspect it or \`remcp doctor\` to diagnose it.`);