@remcp/remcp 0.2.55 → 0.2.57

package/package.json

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

@@ -21,6 +21,10 @@ export { localRuntimeEntry, supervisorRestart, updateDecision } from './agent-up
 
 const UPDATE_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
 const UPDATE_CHECK_TIMEOUT_MS = 5000;
+// A deployment can briefly leave one HA replica advertising the previous release. Recheck a few
+// times after a stable connection instead of making that unlucky first answer stick for six hours.
+const POST_CONNECT_UPDATE_RECHECK_DELAYS_MS = Object.freeze([60_000, 5 * 60_000, 15 * 60_000]);
+const POST_CONNECT_UPDATE_RECHECK_JITTER_MS = 30_000;
 // A version that failed to install is retried after this cooldown instead of on every reconnect.
 const UPDATE_RETRY_COOLDOWN_MS = 30 * 60 * 1000;
 const METRICS_INTERVAL_MS = 60_000;
@@ -75,12 +79,22 @@ export async function runAgent(options) {
   const callTimeoutMs = Math.max(5_000, Number(options.rpcTimeoutMs || 120000) - CALL_TIMEOUT_MARGIN_MS);
   const telemetryEnabled = options.telemetryEnabled !== false;
   const persistState = typeof options.persistState === 'function' ? options.persistState : () => {};
+  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);
+  const postConnectUpdateRecheckJitterMs = Number.isFinite(Number(options.updateRecheckJitterMs))
+    ? Math.max(0, Math.min(60_000, Number(options.updateRecheckJitterMs)))
+    : POST_CONNECT_UPDATE_RECHECK_JITTER_MS;
   let stopping = false;
   let revoked = false;
   const inFlight = new Map();
   let activeSocket;
   let reconnects = 0;
   let reconnectTimer = null;
+  let postConnectUpdateTimers = [];
   // Set when a replica asks this agent to move before it is replaced; the close handler reads it.
   let askedToReconnect = false;
   let pendingRequests = 0;
@@ -377,6 +391,7 @@ export async function runAgent(options) {
       reportInstallOnce();
       flushTelemetry();
       void checkForUpdate();
+      schedulePostConnectUpdateChecks();
     });
     ws.on('message', raw => {
       let message;
@@ -392,6 +407,7 @@ export async function runAgent(options) {
       }
     });
     ws.on('close', code => {
+      clearPostConnectUpdateChecks();
       for (const controller of inFlight.values()) controller.abort();
       if (stopping) return;
       // 1013 ('reconnect') is what a replica sends before it is replaced by a deployment. The machine
@@ -436,6 +452,28 @@ export async function runAgent(options) {
   let lastAttemptAt = 0;
   let lastUpdateCheckError = '';
   let lastUpdateCheckErrorAt = 0;
+
+  function clearPostConnectUpdateChecks() {
+    for (const timer of postConnectUpdateTimers) clearTimeout(timer);
+    postConnectUpdateTimers = [];
+  }
+
+  function schedulePostConnectUpdateChecks() {
+    clearPostConnectUpdateChecks();
+    if (options.autoUpdate === false) return;
+    for (const delay of postConnectUpdateRecheckDelaysMs) {
+      const jitter = postConnectUpdateRecheckJitterMs > 0
+        ? Math.floor(Math.random() * (postConnectUpdateRecheckJitterMs + 1))
+        : 0;
+      const timer = setTimeout(() => {
+        postConnectUpdateTimers = postConnectUpdateTimers.filter(candidate => candidate !== timer);
+        void checkForUpdate();
+      }, delay + jitter);
+      timer.unref?.();
+      postConnectUpdateTimers.push(timer);
+    }
+  }
+
   async function checkForUpdate() {
     if (options.autoUpdate === false) return;
     if (updateInFlight) return;
@@ -550,6 +588,7 @@ export async function runAgent(options) {
     runtimeToolsRetryTimer = null;
     clearTimeout(reconnectTimer);
     reconnectTimer = null;
+    clearPostConnectUpdateChecks();
     if (telemetryTimer) clearInterval(telemetryTimer);
     clearInterval(telemetryFlushTimer);
     clearInterval(updateTimer);

package/src/cli/service.mjs

@@ -158,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
@@ -486,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');
@@ -530,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
@@ -586,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, npmGlobalUpdate, 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 } });
     }

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.`);