@remcp/runtime 0.2.24 → 0.2.26

package/README.md

@@ -1,6 +1,6 @@
 # ReMCP local runtime
 
-`@remcp/runtime` is the local device runtime for [ReMCP](https://remcp.delio24.com). It is an MCP
+`@remcp/runtime` is the local device runtime for [ReMCP](https://remcp.site). It is an MCP
 server that runs on a computer you paired with ReMCP and executes the file, image, search, terminal,
 and process tools that the hosted ReMCP MCP endpoint exposes to ChatGPT and Codex.
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "description": "First-party ReMCP local device runtime: file, search, terminal and process tools over MCP for computers paired with ReMCP.",
   "type": "module",
   "license": "MIT",
-  "homepage": "https://remcp.delio24.com",
+  "homepage": "https://remcp.site",
   "author": "Anton Baider",
   "bin": {
     "remcp-runtime": "src/index.mjs"

package/src/permissions.mjs

@@ -9,6 +9,7 @@ import path from 'node:path';
 //     System Settings → Privacy & Security → Full Disk Access → + → the binary that runs the tools
 // These helpers turn those errnos into that instruction. They never widen access — they explain it.
 const MACOS_HOME_FOLDERS = Object.freeze(['Desktop', 'Documents', 'Downloads']);
+const WINDOWS_HOME_FOLDERS = Object.freeze([['Desktop'], ['Documents'], ['Downloads'], ['OneDrive', 'Desktop'], ['OneDrive', 'Documents']]);
 const PERMISSION_CODES = new Set(['EACCES', 'EPERM']);
 
 // The protected location a path belongs to ("~/Desktop", "iCloud Drive", "an external volume"), or
@@ -34,6 +35,20 @@ export function macosProtectedLocation(target, { platform = process.platform, ho
   return null;
 }
 
+// Windows 11 ships the same idea as TCC under a different name: Controlled folder access (Windows
+// Security → Virus & threat protection → Ransomware protection) blocks Desktop, Documents and
+// Downloads for every application that is not on its allow list, and the process sees EPERM/EACCES.
+export function windowsProtectedLocation(target, { platform = process.platform, home = os.homedir() } = {}) {
+  if (platform !== 'win32') return null;
+  const value = typeof target === 'string' ? target.trim() : '';
+  if (!value || !home) return null;
+  const relative = path.win32.relative(path.win32.resolve(home), path.win32.resolve(value));
+  if (!relative || relative.startsWith('..') || path.win32.isAbsolute(relative)) return null;
+  const parts = relative.split(path.win32.sep);
+  const match = WINDOWS_HOME_FOLDERS.find(entry => entry.every((segment, index) => (parts[index] || '').toLowerCase() === segment.toLowerCase()));
+  return match ? `%USERPROFILE%\\${match.join('\\')}` : null;
+}
+
 // What the person should do about this failure, or null when the error is not a filesystem permission
 // problem this module has better words for.
 export function filesystemErrorExplanation(error, options = {}) {
@@ -49,14 +64,22 @@ export function filesystemErrorExplanation(error, options = {}) {
   const where = typeof target === 'string' && target.trim() ? target.trim() : 'that path';
   if (code === 'ENOSPC') return 'The disk is full (ENOSPC). Free some space or write to another volume.';
   if (code === 'EROFS') return `${where} is on a read-only file system (EROFS). Write somewhere else, or remount it read-write.`;
+  if (code === 'EBUSY') return `${where} is in use by another program (EBUSY). Close whatever holds it and try again.`;
   if (!PERMISSION_CODES.has(code)) return null;
   const protectedLocation = macosProtectedLocation(target, { platform, home });
   if (protectedLocation) {
     return `macOS protects ${protectedLocation} (${code}), and ReMCP runs as a background service, which cannot show the permission prompt. Grant it by hand: System Settings → Privacy & Security → Full Disk Access → + → ${execPath}, then restart the agent with \`remcp start\`. A folder outside Desktop, Documents, Downloads and iCloud Drive needs no new permission.`;
   }
+  const windowsLocation = windowsProtectedLocation(target, { platform, home });
+  if (windowsLocation) {
+    return `Windows Controlled folder access is blocking ${windowsLocation} (${code}). Add the binary that runs the tools (${execPath}) under Windows Security → Virus & threat protection → Ransomware protection → Allow an app through Controlled folder access, then restart the agent with \`remcp start\`. A folder outside Desktop, Documents, Downloads and OneDrive needs no new permission.`;
+  }
   if (platform === 'darwin') {
     return `macOS denied access to ${where} (${code}). Check the ownership and permissions of that folder, or add ${execPath} to System Settings → Privacy & Security → Full Disk Access and restart the agent with \`remcp start\`.`;
   }
+  if (platform === 'win32') {
+    return `Windows denied access to ${where} (${code}). Check whether the file is read-only, open in another program, or inside a Controlled folder access area, then allow ${execPath} through Windows Security (Controlled folder access) and restart the agent with \`remcp start\`.`;
+  }
   return `The operating system denied access to ${where} (${code}). Check that this user owns the folder and its parents, or choose another path.`;
 }
 

package/src/tools/files.mjs

@@ -14,9 +14,10 @@ import { countEvent, recordEvent } from '../telemetry.mjs';
 import { clampInteger, decodeText, displayPath, fail, globToRegExp, image, looksBinary, multi, pageLines, resolveSafePath, splitLines, text } from '../util.mjs';
 
 const MAX_INLINE_FILE_BYTES = 20 * 1024 * 1024;
-// An image travels base64-encoded, which costs a third more bytes, and the MCP stdio client drops
-// the connection above 10 MB. 4 MiB of image is ~5.4 MiB on the wire, which leaves room for the
-// summary text and the frame overhead; anything larger goes through read_binary in chunks instead.
+// An image travels base64-encoded, which costs a third more bytes. The agent's stdio transport holds
+// 24 MiB and the relay's WebSocket frames hold 32 MiB, so 8 MiB of image is ~11 MiB on the wire with
+// room to spare; anything larger goes through read_binary in chunks instead. Binary chunks are 4 MiB
+// for the same reason: four times fewer round trips for the same file.
 const MAX_IMAGE_BYTES = 4 * 1024 * 1024;
 const MAX_BINARY_CHUNK_BYTES = 1024 * 1024;
 const IMAGE_TYPES = new Map([
@@ -921,6 +922,26 @@ const SCREENSHOT_COMMANDS = [
   { command: 'screencapture', args: file => ['-x', file] },
 ];
 
+// What to tell the person when no capture worked. The general "install a screenshot tool" line was
+// wrong on a Mac, where `screencapture` ships with the system and fails only because TCC has not
+// granted Screen Recording — the exact failure behind "the screenshot returned an error" reports.
+function screenshotAdvice(attempts, { platform = process.platform, env = process.env, execPath = process.execPath } = {}) {
+  if (platform === 'darwin') {
+    return `macOS refused the screen capture (${attempts.join('; ') || 'no capture command ran'}). Grant Screen Recording to the binary that runs the tools — System Settings → Privacy & Security → Screen Recording → + → ${execPath} — then restart the agent with \`remcp start\`. macOS requires it for screencapture even when the file itself is writable.`;
+  }
+  if (platform === 'win32') {
+    return `Windows refused the screen capture (${attempts.join('; ') || 'no capture command ran'}). Screen capture needs an interactive desktop session: a machine where nobody is signed in, or a locked session, cannot be captured. Sign in on that computer and try again.`;
+  }
+  const wayland = /wayland/i.test(String(env.XDG_SESSION_TYPE || '')) || Boolean(env.WAYLAND_DISPLAY);
+  if (!env.DISPLAY && !wayland) {
+    return `This computer has no graphical session (no DISPLAY and no Wayland display), so there is nothing to capture — servers and containers usually have none.`;
+  }
+  if (wayland) {
+    return `Could not capture the screen on Wayland (${attempts.join('; ') || 'no capture command ran'}). Install \`grim\` (Wayland's capture tool) — X11 tools such as scrot or ImageMagick import cannot read a Wayland session.`;
+  }
+  return `Could not capture the screen. Install one of grim, gnome-screenshot, spectacle, scrot, or ImageMagick import (tried: ${attempts.join('; ') || 'none available'}).`;
+}
+
 function windowsScreenshotScript(file) {
   return [
     'Add-Type -AssemblyName System.Windows.Forms,System.Drawing',
@@ -949,19 +970,21 @@ export async function takeScreenshotTool(args) {
     }
   }
   if (!await pathExists(file)) {
-    fail(`Could not capture the screen. Install one of grim, gnome-screenshot, spectacle, scrot, or ImageMagick import (tried: ${attempts.join('; ') || 'none available'}).`);
+    fail(screenshotAdvice(attempts));
   }
   const info = await stat(file);
-  if (info.size > MAX_IMAGE_BYTES) {
-    await rm(file, { force: true });
-    fail(`Screenshot is ${info.size} bytes, above the ${MAX_IMAGE_BYTES}-byte inline limit`);
-  }
-  const buffer = await readFile(file);
-  if (args.keep !== true) await rm(file, { force: true });
-  return multi([
-    { type: 'text', text: `Screenshot of ${os.hostname()} (${info.size} bytes)${args.keep === true ? ` saved at ${displayPath(file)}` : ''}` },
-    image(buffer.toString('base64'), 'image/png'),
-  ]);
+  if (info.size <= MAX_IMAGE_BYTES) {
+    const buffer = await readFile(file);
+    if (args.keep !== true) await rm(file, { force: true });
+    return multi([
+      { type: 'text', text: `Screenshot of ${os.hostname()} (${info.size} bytes)${args.keep === true ? ` saved at ${displayPath(file)}` : ''}` },
+      image(buffer.toString('base64'), 'image/png'),
+    ]);
+  }
+  // A big screen is not an error: the PNG stays on the computer and the model is told how to fetch it
+  // in chunks, which is the same path every other large file takes. Failing here used to lose the
+  // screenshot entirely.
+  return text(`Screenshot of ${os.hostname()} captured: ${info.size} bytes, above the ${MAX_IMAGE_BYTES}-byte inline limit, so it is saved at ${displayPath(file)} instead of being returned as an image. Fetch it with read_binary using chunks of up to ${MAX_BINARY_CHUNK_BYTES} bytes (offset_bytes and length_bytes), or ask for a smaller region.`);
 }
 
 export const fileToolHandlers = {