@remcp/remcp 0.2.93 → 0.2.96

package/package.json

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

@@ -615,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),
     ]);