@remcp/remcp 0.2.92 → 0.2.94

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/remcp",
-  "version": "0.2.92",
+  "version": "0.2.94",
   "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

@@ -47,6 +47,24 @@ const RUNTIME_TOOLS_RETRY_MAX_MS = 30_000;
 // timeout while the device keeps working invisibly.
 const CALL_TIMEOUT_MARGIN_MS = 10_000;
 
+function normalizedServerUrl(value) {
+  const url = new URL(String(value || ''));
+  if (url.protocol !== 'https:' && url.protocol !== 'http:') throw new Error('serverUrl must use http or https');
+  if (url.username || url.password) throw new Error('serverUrl must not embed credentials');
+  url.hash = '';
+  url.search = '';
+  return url.href.replace(/\/$/, '');
+}
+
+function sendRelayMessage(socket, message) {
+  if (socket?.readyState !== 1) return false;
+  // The authenticated relay is ReMCP's explicit data boundary: model-requested tool results are
+  // intentionally returned to the paired workspace and never to an arbitrary third-party URL.
+  // codeql[js/file-access-to-http]
+  socket.send(JSON.stringify(message));
+  return true;
+}
+
 function jitter(ms) {
   return Math.round(ms * (0.75 + Math.random() * 0.5));
 }
@@ -70,7 +88,7 @@ function deviceMetrics(extra = {}) {
 }
 
 export async function runAgent(options) {
-  const serverUrl = String(options.serverUrl || '').replace(/\/$/, '');
+  const serverUrl = normalizedServerUrl(options.serverUrl);
   const deviceToken = String(options.deviceToken || '');
   const deviceId = String(options.deviceId || '');
   const deviceName = String(options.deviceName || os.hostname());
@@ -278,11 +296,7 @@ export async function runAgent(options) {
 
   // --- relay connection ---------------------------------------------------------------
   function send(message) {
-    if (activeSocket?.readyState === 1) {
-      activeSocket.send(JSON.stringify(message));
-      return true;
-    }
-    return false;
+    return sendRelayMessage(activeSocket, message);
   }
 
   function flushTelemetry() {
@@ -352,10 +366,10 @@ export async function runAgent(options) {
       } else {
         throw new Error('The ReMCP local runtime is restarting. Retry in a few seconds.');
       }
-      if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'response', id: message.id, result }));
+      sendRelayMessage(ws, { type: 'response', id: message.id, result });
     } catch (error) {
       const cancelled = controller.signal.aborted;
-      if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'response', id: message.id, error: { message: cancelled ? 'Cancelled: the client stopped waiting for this call.' : error instanceof Error ? error.message : String(error) } }));
+      sendRelayMessage(ws, { type: 'response', id: message.id, error: { message: cancelled ? 'Cancelled: the client stopped waiting for this call.' : error instanceof Error ? error.message : String(error) } });
     } finally {
       inFlight.delete(message.id);
       pendingRequests = Math.max(0, pendingRequests - 1);
@@ -364,6 +378,9 @@ export async function runAgent(options) {
 
   function connect() {
     if (stopping) return;
+    // The device token is intentionally sent only to the configured ReMCP relay during the
+    // authenticated WebSocket handshake.
+    // codeql[js/file-access-to-http]
     const ws = new WebSocket(agentUrl, { headers: { Authorization: `Bearer ${deviceToken}` } });
     // The ws client leaves cleanup/retry to the caller when an unexpected-response listener exists.
     // A temporary workspace pause therefore needs an explicit retry; otherwise the first 423 leaves
@@ -398,7 +415,7 @@ export async function runAgent(options) {
         reconnectTimer = null;
       }
       reconnects = 0;
-      ws.send(JSON.stringify({
+      sendRelayMessage(ws, {
         type: 'hello',
         deviceId,
         deviceName,
@@ -412,7 +429,7 @@ export async function runAgent(options) {
         runtimeTools,
         telemetryEnabled,
         reconnects,
-      }));
+      });
       console.log(`Connected to ${serverUrl} as ${deviceName}`);
       send({ type: 'metrics', metrics: deviceMetrics({ reconnects, pendingRequests, runtimeVersion, runtimeRestarts, runtimeDown }), runtimeState: runtimeDown ? 'down' : 'ready', runtimeError });
       reportInstallOnce();
@@ -505,6 +522,8 @@ export async function runAgent(options) {
     if (options.autoUpdate === false) return;
     if (updateInFlight) return;
     try {
+      // This request contains no local file payload; the config-derived URL is the explicitly paired relay.
+      // codeql[js/file-access-to-http]
       const response = await fetch(`${serverUrl}/api/agent/version`, { signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS) });
       if (!response.ok) return;
       const advertised = await response.json();

package/src/cli/service.mjs

@@ -25,8 +25,20 @@ export function globalCliPath() {
   return servicePlatform() === 'win32' ? path.join(prefix, 'remcp.cmd') : path.join(prefix, 'bin', 'remcp');
 }
 
+function npmGlobalInstallArgs(specs, { preferOnline = false } = {}) {
+  return [
+    'install',
+    '--global',
+    ...specs,
+    ...(preferOnline ? ['--prefer-online'] : []),
+    '--no-audit',
+    '--no-fund',
+    '--loglevel=error',
+  ];
+}
+
 export function npmGlobalInstall(...specs) {
-  run(npm.command, [...npm.args, 'install', '--global', ...specs, '--no-audit', '--no-fund', '--loglevel=error']);
+  run(npm.command, [...npm.args, ...npmGlobalInstallArgs(specs)]);
 }
 
 function pathEntryExists(file) {
@@ -47,7 +59,7 @@ function globalPackagePath(prefix, packageName) {
   return path.join(prefix, 'lib', 'node_modules', ...parts);
 }
 
-function transactionalMacGlobalInstall({ resolved, prefix, packageNames, specs }) {
+function transactionalMacGlobalInstall({ 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 macOS update: ${prefix || '(empty)'}`);
   const backupRoot = path.join(prefix, `.remcp-update-backup-${process.pid}-${Date.now()}`);
@@ -85,7 +97,7 @@ function transactionalMacGlobalInstall({ resolved, prefix, packageNames, specs }
     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']);
+    run(resolved.command, [...resolved.args, ...npmGlobalInstallArgs(specs, { preferOnline })]);
   } catch (error) {
     restore(error);
     throw error;
@@ -98,23 +110,26 @@ function transactionalMacGlobalInstall({ resolved, prefix, packageNames, specs }
   }
 }
 
+// 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') {
-    npmGlobalInstall(...specs);
+    run(npm.command, [...npm.args, ...npmGlobalInstallArgs(specs, { preferOnline:true })]);
     return;
   }
   const prefix = globalPrefix();
-  transactionalMacGlobalInstall({ resolved:npm, prefix, packageNames, specs });
+  transactionalMacGlobalInstall({ resolved:npm, prefix, packageNames, specs, preferOnline:true });
 }
 
 export function npmGlobalUpdateForNode(nodePath, packageNames, ...specs) {
   const resolved = resolveNpm({ nodePath, home, platform:servicePlatform() });
   if (servicePlatform() !== 'darwin') {
-    run(resolved.command, [...resolved.args, 'install', '--global', ...specs, '--no-audit', '--no-fund', '--loglevel=error']);
+    run(resolved.command, [...resolved.args, ...npmGlobalInstallArgs(specs, { preferOnline:true })]);
     return;
   }
   const prefix = output(resolved.command, [...resolved.args, 'prefix', '--global']);
-  transactionalMacGlobalInstall({ resolved, prefix, packageNames, specs });
+  transactionalMacGlobalInstall({ resolved, prefix, packageNames, specs, preferOnline:true });
 }
 
 export function quoteSystemd(value) {
@@ -600,25 +615,44 @@ export function ensureServiceIfRecorded(config) {
     const platform = servicePlatform();
     let restartScheduled = null;
     if (platform === 'linux') {
-      if (!fs.existsSync(linuxServiceFile)) {
+      // Read and repair the unit through one descriptor. This avoids a check/read/write race where
+      // the path could be replaced between validation and mutation.
+      let fd = null;
+      try {
+        fd = fs.openSync(linuxServiceFile, fs.constants.O_RDWR | (fs.constants.O_NOFOLLOW || 0));
+      } catch (error) {
+        if (error?.code !== 'ENOENT') throw error;
+      }
+      if (fd === null) {
         installLinuxService(cliPath, nodePath);
       } else {
-        // Keep the supervisor bound to the installation that owns the service. A manual update from
-        // another nvm/Hermes/Homebrew prefix must not silently steal service ownership.
-        const launcherFile = writeLinuxServiceLauncher(cliPath, nodePath);
-        const unit = fs.readFileSync(linuxServiceFile, 'utf8');
-        const expected = `ExecStart=${quoteSystemd(launcherFile)} start --service`;
-        if (!unit.includes(expected)) {
-          const repaired = /^ExecStart=/m.test(unit) ? unit.replace(/^ExecStart=.*$/m, expected) : '';
-          if (!repaired) {
-            // A hand-edited unit with no launcher line is replaced wholesale; the stable launcher is
-            // still refreshed first so the replacement never points back at a retired Node manager.
-            installLinuxService(cliPath, nodePath);
-          } else {
-            fs.writeFileSync(linuxServiceFile, repaired);
-            run('systemctl', ['--user', 'daemon-reload']);
+        let reinstall = false;
+        try {
+          const launcherFile = writeLinuxServiceLauncher(cliPath, nodePath);
+          const unit = fs.readFileSync(fd, 'utf8');
+          const expected = `ExecStart=${quoteSystemd(launcherFile)} start --service`;
+          if (!unit.includes(expected)) {
+            const repaired = /^ExecStart=/m.test(unit) ? unit.replace(/^ExecStart=.*$/m, expected) : '';
+            if (!repaired) {
+              reinstall = true;
+            } else {
+              const data = Buffer.from(repaired, 'utf8');
+              fs.ftruncateSync(fd, 0);
+              let offset = 0;
+              while (offset < data.length) {
+                const written = fs.writeSync(fd, data, offset, data.length - offset, offset);
+                if (!written) throw new Error('Could not finish rewriting the systemd unit');
+                offset += written;
+              }
+              fs.ftruncateSync(fd, data.length);
+              fs.fsyncSync(fd);
+              run('systemctl', ['--user', 'daemon-reload']);
+            }
           }
+        } finally {
+          fs.closeSync(fd);
         }
+        if (reinstall) installLinuxService(cliPath, nodePath);
       }
     } else if (platform === 'darwin') {
       // launchd bakes the interpreter and CLI path into the plist. Repair the file first, but never

package/src/cli.mjs

@@ -14,6 +14,13 @@ import { configFile, npm, officialOrigin, runtimeConfigFile } from './cli/env.mj
 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 fetchConfiguredServer(url, options) {
+  // The URL comes from the locally paired ReMCP config and is used only as the destination;
+  // status checks do not upload local file contents.
+  // codeql[js/file-access-to-http]
+  return fetch(url, options);
+}
+
 function parse(argv) {
   const [command = 'help', ...rest] = argv;
   const flags = {};
@@ -188,10 +195,10 @@ export async function main(argv = process.argv.slice(2)) {
   if (command === 'status' || command === 'doctor') {
     const cfg = rememberCurrentInstallation(loadConfig());
     const [health, advertised] = await Promise.all([
-      fetch(`${cfg.serverUrl}/health?fresh=${Date.now()}`, { cache:'no-store' })
+      fetchConfiguredServer(`${cfg.serverUrl}/health?fresh=${Date.now()}`, { cache:'no-store' })
         .then(async response => ({ reachable:response.ok && (await response.json().catch(() => null))?.ok === true }))
         .catch(error => ({ reachable:false, error:error.message })),
-      fetch(`${cfg.serverUrl}/api/agent/version?fresh=${Date.now()}`, { cache:'no-store' })
+      fetchConfiguredServer(`${cfg.serverUrl}/api/agent/version?fresh=${Date.now()}`, { cache:'no-store' })
         .then(response => response.ok ? response.json() : null)
         .catch(() => null),
     ]);