@remcp/remcp 0.2.30 → 0.2.32

package/README.md

@@ -27,6 +27,7 @@ remcp install                Install or repair the user service
 remcp uninstall              Remove the user service
 remcp uninstall --purge      Remove the service and the global packages
 remcp telemetry [status|on|off]
+remcp godmode [status|on|off]
 remcp --version
 ```
 
@@ -47,7 +48,8 @@ Two things it deliberately does not do:
   or `unrestricted: true` in `~/.config/remcp/runtime.json`) can turn it on. That is what keeps a
   prompt injection from becoming root.
 - **It does not make the agent root.** Commands run as the user the agent runs as. `sudo` is no longer
-  blocked, but it still needs your sudoers rules; to run everything as root, run the agent as root.
+  blocked, but the operating system still asks for a password unless your sudoers rules say otherwise;
+  a non-interactive command cannot type one. Nothing in this mode grants root by itself.
 
 While it is on, `get_runtime_info` reports `policy.unrestricted: true`, so the model can see it and
 say so instead of assuming the guardrails are still there.
@@ -62,6 +64,32 @@ background service: open **System Settings → Privacy & Security → Full Disk
 binary that `remcp doctor` prints, and run `remcp start`. Folders outside those four need no new
 permission, and `remcp doctor` reports the state of each one.
 
+## Updates
+
+The agent asks the server which versions it should run when it connects and every six hours, installs
+a newer client and runtime in the background, and restarts the service so they take effect. A failed
+install is retried no more often than every thirty minutes, so a broken release cannot turn into an
+install loop. `remcp update` does the same immediately; `remcp auto-update off` turns the automatic
+check off for a machine that must not change on its own.
+
+## Screenshots
+
+`take_screenshot` returns the screen of this computer as an image, and each desktop keeps its own
+gate — ReMCP names the one that refused instead of printing a generic error:
+
+- **macOS** wants Screen Recording for the binary that runs the tools (`remcp doctor` prints its
+  path), then `remcp start`.
+- **Windows** needs an unlocked interactive session; a locked or signed-out machine cannot be
+  captured.
+- **Linux on Wayland** needs a capture backend: `grim` on wlroots desktops (sway, hyprland), and
+  `gnome-screenshot` on GNOME — GNOME refuses the shell's own screenshot API to background processes
+  and `grim` cannot read a GNOME session. On X11, `scrot`, ImageMagick `import` or `gnome-screenshot`
+  all work.
+- A machine with no graphical session (a server, a container) says so: there is nothing to capture.
+
+A screenshot larger than the inline limit is saved on the computer, and the result says where it is
+and how to fetch it in chunks.
+
 ## What runs on your computer
 
 - the agent (`remcp start`), which holds the device credential and dials

package/package.json

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

@@ -25,6 +25,9 @@ const TELEMETRY_QUEUE_LIMIT = 500;
 const TELEMETRY_BATCH_LIMIT = 100;
 const TELEMETRY_SEND_INTERVAL_MS = 5_000;
 const RECONNECT_BASE_MS = 2_000;
+// The first retry after an unexpected drop: fast enough that a blip is invisible, slow enough not to
+// hammer a server that is genuinely down.
+const RECONNECT_FIRST_MS = 500;
 // Must stay above the runtime's own output ceiling (8 MiB), otherwise a large but legal tool result
 // closes the stdio connection and restarts the runtime mid-call.
 const RUNTIME_STDIO_BUFFER_BYTES = 24 * 1024 * 1024;
@@ -240,6 +243,8 @@ export async function runAgent(options) {
   const inFlight = new Map();
   let activeSocket;
   let reconnects = 0;
+  // Set when a replica asks this agent to move before it is replaced; the close handler reads it.
+  let askedToReconnect = false;
   let pendingRequests = 0;
   let runtimeVersion = 'unknown';
   let runtimeRestarts = 0;
@@ -444,6 +449,10 @@ export async function runAgent(options) {
     ws.on('message', raw => {
       let message;
       try { message = JSON.parse(raw.toString()); } catch { return; }
+      if (message?.type === 'reconnect') {
+        askedToReconnect = true;
+        return;
+      }
       if (message?.type === 'request') void respond(ws, message);
       if (message?.type === 'cancel' && message.id) {
         const controller = inFlight.get(message.id);
@@ -453,6 +462,16 @@ export async function runAgent(options) {
     ws.on('close', code => {
       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
+      // is not down, it is moving: reconnect at once and forget the backoff, so the person and the
+      // model see nothing at all.
+      if (code === 1013 || askedToReconnect) {
+        askedToReconnect = false;
+        reconnects = 0;
+        console.log('ReMCP relay is being redeployed; reconnecting now.');
+        setTimeout(connect, 150);
+        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.
@@ -469,7 +488,11 @@ export async function runAgent(options) {
         return;
       }
       reconnects += 1;
-      const delay = jitter(Math.min(RECONNECT_MAX_MS, RECONNECT_BASE_MS * 2 ** Math.min(reconnects, 5)));
+      // The first retry after an unexpected drop is quick on purpose: a deploy blip, a proxy restart or
+      // a dropped packet should cost a fraction of a second, not the two seconds the backoff starts at.
+      const delay = reconnects === 1
+        ? jitter(RECONNECT_FIRST_MS)
+        : jitter(Math.min(RECONNECT_MAX_MS, RECONNECT_BASE_MS * 2 ** Math.min(reconnects, 5)));
       setTimeout(connect, delay);
     });
     ws.on('error', error => console.error(`ReMCP relay: ${error.message}`));

package/src/cli.mjs

@@ -615,7 +615,7 @@ export async function main(argv = process.argv.slice(2)) {
         unrestricted: state,
         source: runtimeFile.unrestricted === true ? runtimeConfigFile : process.env.REMCP_RUNTIME_UNRESTRICTED === '1' ? 'REMCP_RUNTIME_UNRESTRICTED' : 'default',
         meaning: state
-          ? 'Every path and every command is allowed. Commands run as the user the agent runs as; run the agent as root (sudo remcp install --system) if you want root.'
+          ? 'Every path and every command is allowed. Commands run as the user the agent runs as, so sudo still needs your own sudoers rules; nothing here grants root by itself.'
           : 'The runtime confines file access to its allowed roots and applies its command guardrails.',
       }, null, 2));
       return;