@remcp/remcp 0.2.39 → 0.2.41

package/package.json

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

@@ -4,7 +4,7 @@ import process from 'node:process';
 import { spawn, spawnSync } from 'node:child_process';
 import { resolveNpm } from './npm.mjs';
 import { isRuntimeSpecFor, normalizeRuntime } from './runtime.mjs';
-import { VERSION } from './version.mjs';
+import { PACKAGE_NAME, VERSION } from './version.mjs';
 
 const npm = resolveNpm();
 // How long a handing-over agent waits for its replacement to take the device over before it keeps
@@ -61,15 +61,27 @@ function isNewer(candidate, current) {
   return false;
 }
 
+export function updateInvocationArgs({ target, runtime }, trustRuntime = false) {
+  return [
+    'update',
+    ...(trustRuntime ? ['--trust-runtime'] : []),
+    ...(target ? ['--client', target] : []),
+    ...(runtime ? ['--runtime', runtime] : []),
+  ];
+}
+
 // What the agent should install, if anything. The client version alone is not enough: a machine
 // that already runs the newest client but an older local runtime would otherwise never catch up,
 // because its runtime is what executes the tools.
 export function updateDecision({ advertised, cliVersion, runtimeVersion, runtimePackageName, runtimeDown = false }) {
-  const cliSpec = String(advertised?.cli || '');
+  const advertisedCli = String(advertised?.cli || '');
   const advertisedRuntime = String(advertised?.runtime || '');
-  // A spec that is not a plain version of the configured runtime package is ignored rather than
-  // installed: this is the only place a server-chosen string reaches npm.
-  const runtimeSpec = runtimePackageName && advertisedRuntime && !isRuntimeSpecFor(runtimePackageName, advertisedRuntime) ? '' : advertisedRuntime;
+  // Only exact versions of the first-party client and the configured runtime package may cross
+  // from server metadata into the updater. Invalid specs are ignored instead of being handed to npm.
+  const cliSpec = advertisedCli && isRuntimeSpecFor(PACKAGE_NAME, advertisedCli) ? advertisedCli : '';
+  const runtimeSpec = runtimePackageName && advertisedRuntime && isRuntimeSpecFor(runtimePackageName, advertisedRuntime)
+    ? advertisedRuntime
+    : '';
   const installedRuntime = String(runtimeVersion || '');
   const runtimeKnown = Boolean(installedRuntime) && !/^unknown$/i.test(installedRuntime);
   if (isNewer(cliSpec, cliVersion)) return { needed: true, target: cliSpec, runtime: runtimeSpec, reason: 'client' };

package/src/agent.mjs

@@ -13,6 +13,7 @@ import {
   restartToApplyUpdate,
   supervisorRestart,
   updateDecision,
+  updateInvocationArgs,
 } from './agent-update.mjs';
 
 export { localRuntimeEntry, supervisorRestart, updateDecision } from './agent-update.mjs';
@@ -369,10 +370,10 @@ export async function runAgent(options) {
       lastAttemptAt = Date.now();
       updateInFlight = true;
       console.log(`Updating ReMCP to ${target}${decision.runtime ? ` with ${decision.runtime}` : ''} (${decision.reason})…`);
-      // The trust flag is only forwarded when this machine's owner trusted the server at pairing
-      // time; otherwise the update stops at the server's own version and asks the user.
-      const trustFlag = options.trustRuntime === true ? ['--trust-runtime'] : [];
-      const child = spawn(process.execPath, [cli, 'update', ...trustFlag, ...(decision.runtime ? ['--runtime', decision.runtime] : [])], {
+      // Keep the updater pinned to the exact release pair this trusted server advertised. That
+      // prevents a newer public npm tag from getting ahead of production during a public-first rollout.
+      const updateArgs = updateInvocationArgs(decision, options.trustRuntime === true);
+      const child = spawn(process.execPath, [cli, ...updateArgs], {
         detached: true,
         // The updater's own output is the only record of why an install failed, so it is piped back
         // into this agent's log instead of being discarded.

package/src/cli/update.mjs

@@ -1,6 +1,6 @@
-// `remcp update`: install what the server advertises, then let whoever supervises the agent restart
-// it. Only a spec the configured package can satisfy is installed, so a pairing response from a
-// custom server cannot point this machine at a different package or run a git/URL spec.
+// `remcp update`: install the release pair advertised by the paired server, then let whoever
+// supervises the agent restart it. Only exact versions of the configured first-party packages are
+// installable, so a server cannot point this machine at a different package or a git/URL/tag spec.
 import fs from 'node:fs';
 import process from 'node:process';
 
@@ -13,51 +13,192 @@ import { installedVersion } from './doctor.mjs';
 import { linuxServiceFile, macServiceFile, officialOrigin } from './env.mjs';
 import { ensureServiceIfRecorded, npmGlobalInstall, restartPersistentServiceIfInstalled } from './service.mjs';
 
-export async function updateCommand(flags) {
-  const cfg = loadConfig();
-  // The server advertises which runtime version it expects; an agent that is updating
-  // itself passes it through so client and runtime move together.
-  const requested = typeof flags.runtime === 'string' ? flags.runtime.trim() : '';
-  // Whatever the server advertises is installed globally, so it is validated exactly like the
-  // metadata from a pairing response: same package as the configured runtime, a spec that
-  // parses, and an explicit --trust-runtime before a custom server may change it.
-  let runtimeSpec = cfg.runtime.packageSpec;
-  if (requested) {
+const UPDATE_DISCOVERY_TIMEOUT_MS = 5000;
+
+function runtimeTrustAllowed(cfg, flags, env = process.env) {
+  return cfg.trustRuntime === true
+    || Boolean(flags['trust-runtime'])
+    || env.REMCP_TRUST_RUNTIME === '1'
+    // A configuration written before the field existed paired with the official server, which is
+    // trusted by definition; refusing it would silently stop every existing device updating.
+    || new URL(cfg.serverUrl).origin === officialOrigin;
+}
+
+function exactClientSpec(value) {
+  const spec = String(value || '').trim();
+  return isRuntimeSpecFor(PACKAGE_NAME, spec) ? spec : '';
+}
+
+function specVersion(packageName, spec) {
+  const value = String(spec || '');
+  return isRuntimeSpecFor(packageName, value) ? value.slice(`${packageName}@`.length) : '';
+}
+
+function releasePairMatches(clientSpec, runtimePackageName, runtimeSpec) {
+  if (!isRuntimeSpecFor(PACKAGE_NAME, clientSpec) || !isRuntimeSpecFor(runtimePackageName, runtimeSpec)) return false;
+  // First-party client/runtime releases are one contract and intentionally share a version. Custom
+  // runtimes can version independently because their package is controlled by the operator.
+  if (runtimePackageName !== '@remcp/runtime') return true;
+  return specVersion(PACKAGE_NAME, clientSpec) === specVersion(runtimePackageName, runtimeSpec);
+}
+
+export async function resolveUpdateTargets({
+  cfg,
+  flags = {},
+  env = process.env,
+  fetchImpl = globalThis.fetch,
+}) {
+  const requestedRuntime = typeof flags.runtime === 'string' ? flags.runtime.trim() : '';
+  const requestedClient = typeof flags.client === 'string' ? flags.client.trim() : '';
+  const latestClient = `${PACKAGE_NAME}@latest`;
+  const currentClient = `${PACKAGE_NAME}@${VERSION}`;
+  const trusted = runtimeTrustAllowed(cfg, flags, env);
+
+  let clientSpec = latestClient;
+  if (requestedClient) {
+    clientSpec = exactClientSpec(requestedClient);
+    if (!clientSpec) throw new Error(`--client must be ${PACKAGE_NAME}@<version>`);
+  }
+
+  if (requestedRuntime) {
     // Only `<configured package>@<semver>` is installable: an alias, a git/URL/file spec, a tag or
     // a range would run code the user never agreed to.
-    if (!isRuntimeSpecFor(cfg.runtime.packageName, requested)) {
+    if (!isRuntimeSpecFor(cfg.runtime.packageName, requestedRuntime)) {
       throw new Error(`--runtime must be ${cfg.runtime.packageName}@<version>`);
     }
-    const trusted = cfg.trustRuntime === true
-      || Boolean(flags['trust-runtime'])
-      || process.env.REMCP_TRUST_RUNTIME === '1'
-      // A configuration written before the field existed paired with the official server, which is
-      // trusted by definition; refusing it would silently stop every existing device updating.
-      || new URL(cfg.serverUrl).origin === officialOrigin;
     if (!trusted) {
       throw new Error(`This machine was paired without trusting ${cfg.serverUrl} to choose a runtime version. Re-run with --trust-runtime if you trust that server.`);
     }
-    runtimeSpec = normalizeRuntime({ kind: 'npm', packageName: cfg.runtime.packageName, packageSpec: requested, entry: cfg.runtime.entry }).packageSpec;
+    const runtimeSpec = normalizeRuntime({
+      kind: 'npm',
+      packageName: cfg.runtime.packageName,
+      packageSpec: requestedRuntime,
+      entry: cfg.runtime.entry,
+    }).packageSpec;
+    if (requestedClient && !releasePairMatches(clientSpec, cfg.runtime.packageName, runtimeSpec)) {
+      throw new Error('The client and first-party runtime must use the same exact release version.');
+    }
+    if (!requestedClient && cfg.runtime.packageName === '@remcp/runtime' && specVersion(cfg.runtime.packageName, runtimeSpec) !== VERSION) {
+      throw new Error(`--runtime without --client must match the running client version ${VERSION}`);
+    }
+    return {
+      clientSpec: requestedClient ? clientSpec : currentClient,
+      runtimeSpec,
+      persistRuntime: runtimeSpec !== cfg.runtime.packageSpec,
+      installable: true,
+      source: requestedClient ? 'explicit-pair' : 'explicit-runtime',
+      warning: '',
+    };
   }
+
+  // A manual `remcp update` has to move the client and the first-party runtime in lockstep too.
+  // Older versions reused the runtime pin stored at pairing time, so a manual client update could
+  // install a newer client while deliberately reinstalling an older runtime. Resolve the exact
+  // release pair from the same public endpoint the running agent already trusts. During a public-
+  // first rollout this also prevents `@latest` from getting ahead of the version production
+  // actually advertises.
+  if (!trusted) {
+    return {
+      clientSpec,
+      runtimeSpec: cfg.runtime.packageSpec,
+      persistRuntime: false,
+      installable: true,
+      source: 'configured',
+      warning: '',
+    };
+  }
+
+  try {
+    const versionUrl = new URL('/api/agent/version', cfg.serverUrl).toString();
+    const response = await fetchImpl(versionUrl, {
+      headers: { accept: 'application/json' },
+      signal: AbortSignal.timeout(UPDATE_DISCOVERY_TIMEOUT_MS),
+    });
+    if (!response?.ok) {
+      return {
+        clientSpec: currentClient,
+        runtimeSpec: cfg.runtime.packageSpec,
+        persistRuntime: false,
+        installable: false,
+        source: 'configured',
+        warning: `Could not resolve the server release pair (HTTP ${response?.status ?? 'unknown'}); refusing a partial update.`,
+      };
+    }
+
+    const advertised = await response.json();
+    const runtimeCandidate = String(advertised?.runtime || '').trim();
+    const advertisedClient = exactClientSpec(advertised?.cli);
+    const clientCandidate = requestedClient || advertisedClient;
+    if (!advertisedClient
+      || !releasePairMatches(advertisedClient, cfg.runtime.packageName, runtimeCandidate)
+      || (requestedClient && requestedClient !== advertisedClient)) {
+      return {
+        clientSpec: currentClient,
+        runtimeSpec: cfg.runtime.packageSpec,
+        persistRuntime: false,
+        installable: false,
+        source: 'configured',
+        warning: 'Could not resolve a valid server release pair; refusing a partial update.',
+      };
+    }
+
+    const runtimeSpec = normalizeRuntime({
+      kind: 'npm',
+      packageName: cfg.runtime.packageName,
+      packageSpec: runtimeCandidate,
+      entry: cfg.runtime.entry,
+    }).packageSpec;
+    return {
+      clientSpec: clientCandidate,
+      runtimeSpec,
+      persistRuntime: runtimeSpec !== cfg.runtime.packageSpec,
+      installable: true,
+      source: 'server',
+      warning: '',
+    };
+  } catch (error) {
+    return {
+      clientSpec: currentClient,
+      runtimeSpec: cfg.runtime.packageSpec,
+      persistRuntime: false,
+      installable: false,
+      source: 'configured',
+      warning: `Could not resolve the server release pair (${error instanceof Error ? error.message : String(error)}); refusing a partial update.`,
+    };
+  }
+}
+
+export async function updateCommand(flags) {
+  const cfg = loadConfig();
+  const targets = await resolveUpdateTargets({ cfg, flags });
+  if (targets.warning) console.error(`ReMCP update: ${targets.warning}`);
+
   if (flags.check) {
     console.log(JSON.stringify({
       current: VERSION,
       installedRuntime: installedVersion(cfg.runtime.packageName),
-      runtimeSpec: runtimeSpec,
-      available: `${PACKAGE_NAME}@latest`,
+      clientSpec: targets.clientSpec,
+      runtimeSpec: targets.runtimeSpec,
+      updateSource: targets.source,
+      installable: targets.installable,
       managedService: fs.existsSync(linuxServiceFile) || fs.existsSync(macServiceFile),
       supervisor: supervisorRestart() ?? 'none',
     }, null, 2));
     return;
   }
+
+  if (!targets.installable) {
+    throw new Error(targets.warning || 'Could not resolve a complete client/runtime release pair.');
+  }
+
   const before = { cli: VERSION, runtime: installedVersion(cfg.runtime.packageName) };
-  console.log(`Updating ReMCP to the latest published version (${runtimeSpec})…`);
-  npmGlobalInstall(`${PACKAGE_NAME}@latest`, runtimeSpec);
+  console.log(`Updating ReMCP to ${targets.clientSpec} with ${targets.runtimeSpec}…`);
+  npmGlobalInstall(targets.clientSpec, targets.runtimeSpec);
   // The npm prefix can change across Node-manager upgrades. Repair an existing persistent-service
   // launcher only after the install, when globalCliPath() points at the CLI we just installed.
   ensureServiceIfRecorded(cfg);
   // Only a validated spec is persisted, so a failed update cannot leave the install unable to start.
-  if (requested && runtimeSpec !== cfg.runtime.packageSpec) saveConfig({ ...cfg, runtime: { ...cfg.runtime, packageSpec: runtimeSpec } });
+  if (targets.persistRuntime) saveConfig({ ...cfg, runtime: { ...cfg.runtime, packageSpec: targets.runtimeSpec } });
   const after = { cli: installedVersion(PACKAGE_NAME), runtime: installedVersion(cfg.runtime.packageName) };
   const restarted = restartPersistentServiceIfInstalled();
   if (restarted) {