@remcp/remcp 0.2.197 → 0.2.199

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/remcp",
-  "version": "0.2.197",
+  "version": "0.2.199",
   "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-relay-connection.mjs

@@ -9,7 +9,6 @@ import { nextDeployReconnect } from './agent-deploy-reconnect.mjs';
 const RECONNECT_BASE_MS = 2_000;
 const RECONNECT_FIRST_MS = 500;
 const RECONNECT_MAX_MS = 60_000;
-
 // Higher-level agent owns runtime supervision/telemetry; this controller owns only relay transport.
 export function createAgentRelayConnection({
   agentUrl, serverUrl, deviceToken, deviceId, deviceName,
@@ -22,6 +21,7 @@ export function createAgentRelayConnection({
   let reconnectTimer = null;
   let askedToReconnect = false;
   let requestedReconnectDelayMs = 0;
+  let requestedReconnectReason = '';
   let connectedAt = 0;
   let rapidDeployDisconnects = 0;
   function scheduleReconnect(delay) {
@@ -121,6 +121,8 @@ export function createAgentRelayConnection({
       if (message?.type === 'reconnect') {
         askedToReconnect = true;
         requestedReconnectDelayMs = boundedReconnectDelay(message.delayMs, 150);
+        requestedReconnectReason = ['deploy', 'credentials', 'capacity'].includes(message.reason)
+          ? message.reason : 'transient';
         return;
       }
       if (message?.type === 'request') void respond(ws, message);
@@ -133,37 +135,33 @@ export function createAgentRelayConnection({
       clearPostConnectUpdateChecks();
       for (const controller of inFlight.values()) controller.abort();
       if (isStopping()) return;
-      // 1013 ('reconnect') is what a replica sends before it is replaced by a deployment. The machine
-      // is not down, it is moving: reconnect at once and forget the backoff, so the person and the
-      // model see nothing at all.
+      // A replacement owner or revoked device takes precedence over a reconnect hint.
+      if (code === 1008 || revoked) {
+        console.error('ReMCP access for this device was revoked. Pair the machine again from the ReMCP workspace: remcp connect --server <url> --code <code> --install');
+        return;
+      }
+      if (code === 1012) {
+        console.error('Another ReMCP agent connected for this device; this process will stop. Run one agent per machine (a service manager or the remcp start command).');
+        markStopping();
+        void stop().finally(() => setTimeout(() => process.exit(0), 100));
+        return;
+      }
       if (code === 1013 || askedToReconnect) {
+        // 1013 covers transient overload and relay-store failures, not just deployment.
+        // Preserve a fast first handover while bounding repeated short-lived sessions.
         const reconnect = nextDeployReconnect({
           requestedDelayMs: requestedReconnectDelayMs || 150,
           rapidDisconnects: rapidDeployDisconnects,
           connectionUptimeMs: connectedAt ? Date.now() - connectedAt : 0,
         });
         rapidDeployDisconnects = reconnect.rapidDisconnects;
-        const delayMs = reconnect.delayMs;
+        const reason = requestedReconnectReason || 'transient';
         askedToReconnect = false;
+        requestedReconnectReason = '';
         requestedReconnectDelayMs = 0;
         setReconnects(0);
-        console.log(`ReMCP relay is being redeployed; reconnecting in ${delayMs}ms.`);
-        scheduleReconnect(delayMs);
-        return;
-      }
-      if (code === 1008 || revoked) {
-        // The relay closes with 1008 when the device was revoked. Retrying forever would
-        // hide that from the person at the computer.
-        console.error('ReMCP access for this device was revoked. Pair the machine again from the ReMCP workspace: remcp connect --server <url> --code <code> --install');
-        return;
-      }
-      if (code === 1012) {
-        // 1012 ('service restart') is what the relay sends when another agent process took over this
-        // device. Staying alive would keep a second runtime and a reconnect loop, so this process
-        // stops and leaves the device to the agent that owns the connection.
-        console.error('Another ReMCP agent connected for this device; this process will stop. Run one agent per machine (a service manager or the remcp start command).');
-        markStopping();
-        void stop().finally(() => setTimeout(() => process.exit(0), 100));
+        console.log(`ReMCP relay reconnect (${reason}); retrying in ${reconnect.delayMs}ms.`);
+        scheduleReconnect(reconnect.delayMs);
         return;
       }
       scheduleBackoffReconnect();

package/src/agent-update-monitor.mjs

@@ -6,7 +6,9 @@ import { fetchUpdateManifest } from './fetch-update-manifest.mjs';
 import { globalCliEntry, globalInstalledVersion, isNewer, restartToApplyUpdate, updateDecision, updateInvocationArgs } from './agent-update.mjs';
 
 export const UPDATE_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
-const UPDATE_CHECK_TIMEOUT_MS = 5000;
+const UPDATE_CHECK_TIMEOUT_MS = 12000;
+// A flapping relay must not trigger update discovery on every successful reconnect.
+const UPDATE_CHECK_RECONNECT_GAP_MS = 30000;
 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;
 const UPDATE_RETRY_COOLDOWN_MS = 30 * 60 * 1000;
@@ -32,6 +34,7 @@ export function createAgentUpdateMonitor({ options, serverUrl, queueEvent, getRu
   let lastAttemptAt = 0;
   let lastUpdateCheckError = '';
   let lastUpdateCheckErrorAt = 0;
+  let lastDiscoveryAt = 0;
 
   function clearPostConnectUpdateChecks() {
     for (const timer of postConnectUpdateTimers) clearTimeout(timer);
@@ -47,16 +50,24 @@ export function createAgentUpdateMonitor({ options, serverUrl, queueEvent, getRu
         : 0;
       const timer = setTimeout(() => {
         postConnectUpdateTimers = postConnectUpdateTimers.filter(candidate => candidate !== timer);
-        void checkForUpdate();
+        void checkForUpdate({ scheduled: true });
       }, delay + jitter);
       timer.unref?.();
       postConnectUpdateTimers.push(timer);
     }
   }
 
-  async function checkForUpdate() {
+  async function checkForUpdate({ scheduled = false } = {}) {
     if (options.autoUpdate === false) return;
     if (updateInFlight) return;
+    const minimumGap = Number.isFinite(Number(options.updateCheckMinGapMs))
+      ? Math.max(0, Math.min(UPDATE_CHECK_RECONNECT_GAP_MS, Number(options.updateCheckMinGapMs)))
+      : UPDATE_CHECK_RECONNECT_GAP_MS;
+    const now = Date.now();
+    // Scheduled bounded convergence polls are distinct from reconnect-triggered discovery.
+    // Do not starve release-pause/Redis-recovery checks behind the reconnect storm cooldown.
+    if (!scheduled && lastDiscoveryAt && now - lastDiscoveryAt < minimumGap) return;
+    lastDiscoveryAt = now;
     try {
       // This request contains no local file payload; the config-derived URL is the explicitly paired relay.
       // codeql[js/file-access-to-http]

package/src/cli/service.mjs

@@ -23,9 +23,28 @@ export function quoteSystemd(value) {
   return `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
 }
 
-function writeLinuxServiceLauncher(cliPath = globalCliPath(), nodePath = process.execPath) {
+// A systemd user's PATH may resolve system npm even when the CLI lives under nvm.
+// Pin the npm installation target to the CLI's own existing global prefix.
+export function linuxServiceLauncherText(cliPath, nodePath) {
+  if (!path.isAbsolute(cliPath) || !path.isAbsolute(nodePath) || path.basename(path.dirname(cliPath)) !== 'bin') {
+    throw new Error('Linux service needs absolute CLI and Node paths in a global bin directory');
+  }
+  const prefix = path.dirname(path.dirname(cliPath));
   const cliScript = resolvedCliScript(cliPath);
-  const launcher = `#!/bin/sh\nexec ${shellQuote(nodePath)} ${shellQuote(cliScript)} \"$@\"\n`;
+  const lines = [
+    '#!/bin/sh',
+    'NPM_CONFIG_PREFIX=' + shellQuote(prefix),
+    'export NPM_CONFIG_PREFIX',
+    'PATH=' + shellQuote(path.dirname(nodePath)) + ':"$PATH"',
+    'export PATH',
+    'exec ' + shellQuote(nodePath) + ' ' + shellQuote(cliScript) + ' "$@"',
+    '',
+  ];
+  return lines.join('\n');
+}
+
+function writeLinuxServiceLauncher(cliPath = globalCliPath(), nodePath = process.execPath) {
+  const launcher = linuxServiceLauncherText(cliPath, nodePath);
   fs.mkdirSync(path.dirname(linuxServiceLauncherFile), { recursive: true, mode: 0o700 });
   const temporary = `${linuxServiceLauncherFile}.${process.pid}.${Date.now()}.tmp`;
   fs.writeFileSync(temporary, launcher, { mode: 0o700 });