@remcp/remcp 0.2.24 → 0.2.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/remcp",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "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",
@@ -18,7 +18,7 @@
     "README.md"
   ],
   "scripts": {
-    "check": "node --check bin/remcp.mjs && node --check src/cli.mjs && node --check src/agent.mjs && node --check src/runtime.mjs && node --check src/version.mjs && node --check src/npm.mjs && node --check src/macos-permissions.mjs",
+    "check": "node --check bin/remcp.mjs && node --check src/cli.mjs && node --check src/agent.mjs && node --check src/runtime.mjs && node --check src/version.mjs && node --check src/npm.mjs && node --check src/fs-access.mjs",
     "test": "node --test test/*.test.mjs"
   },
   "dependencies": {

package/src/cli.mjs

@@ -8,7 +8,7 @@ import { localRuntimeEntry, runAgent, supervisorRestart } from './agent.mjs';
 import { npmVersion, resolveNpm } from './npm.mjs';
 import { isRuntimeSpecFor, normalizeRuntime } from './runtime.mjs';
 import { PACKAGE_NAME, VERSION } from './version.mjs';
-import { probeMacosFolderAccess } from './macos-permissions.mjs';
+import { probeFilesystemAccess } from './fs-access.mjs';
 
 const home = os.homedir();
 const configDir = process.env.REMCP_CONFIG_DIR || path.join(home, '.config', 'remcp');
@@ -417,6 +417,16 @@ async function diagnoseLocalRuntime(cfg) {
 
 // Reads the version a freshly installed global package reports, so an update that installed
 // nothing (wrong prefix, npm cache, permissions) is reported instead of assumed successful.
+// The roots the runtime is allowed to work in, as the person configured them. An empty list means
+// "the whole file system", so the doctor probes the home directory instead of guessing a root.
+function runtimeAllowedRoots() {
+  try {
+    const configured = JSON.parse(fs.readFileSync(runtimeConfigFile, 'utf8')).allowedRoots;
+    if (Array.isArray(configured) && configured.length) return configured.map(root => String(root).replace(/^~/, os.homedir()));
+  } catch {}
+  return [os.homedir()];
+}
+
 function installedVersion(packageName) {
   const prefix = spawnSync(npm.command, [...npm.args, 'prefix', '--global'], { encoding: 'utf8' });
   if (prefix.error || prefix.status !== 0) return null;
@@ -480,6 +490,11 @@ export async function main(argv = process.argv.slice(2)) {
       deviceInitiated = true;
       paired = await pairWithDeviceCode(server, flags);
     }
+    if (paired.moved_from_another_account) {
+      console.log('This computer was paired to another ReMCP account. That device was revoked and this machine now belongs to the account you approved.');
+    } else if (paired.movedFromUid) {
+      console.log('This computer was paired to another ReMCP account. That device was revoked and this machine now belongs to the account you approved.');
+    }
     const config = {
       serverUrl: server,
       deviceId: paired.deviceId || paired.device_id,
@@ -576,11 +591,12 @@ export async function main(argv = process.argv.slice(2)) {
     // the runtime, so the failure is visible here instead of only as "runtime not running".
     if (command === 'doctor') {
       report.diagnosis = await diagnoseLocalRuntime(cfg);
-      // A Mac can pass every other check and still be unable to write to Desktop: macOS answers EACCES
-      // and the model only ever sees the errno. This is where the person can see it before ChatGPT
-      // does, with the grant that fixes it named for this exact binary.
-      const filesystem = await probeMacosFolderAccess();
-      if (filesystem.supported) report.diagnosis.filesystem = filesystem;
+      // A computer can pass every other check and still be unable to write where the tools work:
+      // macOS answers EACCES for Desktop until TCC is granted, Windows has Controlled folder access,
+      // Linux answers EACCES for a folder this user does not own. The probe writes and removes a
+      // temporary file in each allowed root, so the doctor reports what actually happens rather than
+      // what the permission bits claim, and names the fix for this platform and this binary.
+      report.diagnosis.filesystem = await probeFilesystemAccess({ roots: runtimeAllowedRoots() });
     }
     console.log(JSON.stringify(report, null, 2));
     if (command === 'doctor' && report.diagnosis.verdict !== 'ok') process.exitCode = 1;

package/src/fs-access.mjs

@@ -0,0 +1,88 @@
+import os from 'node:os';
+import path from 'node:path';
+import { readdir, rm, writeFile } from 'node:fs/promises';
+
+// macOS gates Desktop, Documents, Downloads and iCloud Drive behind TCC. A paired Mac can be online,
+// healthy and answering tools, and still fail every write into Desktop with `EACCES: permission
+// denied` — the failure people actually report, because the workspace and the model only ever see the
+// errno. `remcp doctor` is the one place that can look at the machine itself, so it reports which of
+// those folders this process may use.
+//
+// The probe is read-only on purpose: reading a directory is what TCC gates, so a directory that
+// cannot be listed is a directory that cannot be written either, and listing one cannot change it.
+export const MACOS_PROTECTED_FOLDERS = Object.freeze(['Desktop', 'Documents', 'Downloads']);
+
+export function macosPermissionHint(execPath = process.execPath) {
+  return `macOS is blocking one or more protected folders. Grant access by hand: System Settings → Privacy & Security → Full Disk Access → + → ${execPath}, then restart the agent with \`remcp start\`. Folders outside Desktop, Documents, Downloads and iCloud Drive need no new permission.`;
+}
+
+export function windowsPermissionHint(execPath = process.execPath) {
+  return `Windows is refusing the write. Allow it under Windows Security → Virus & threat protection → Ransomware protection → Allow an app through Controlled folder access (${execPath}), check the read-only attribute of the file, and restart the agent with \`remcp start\`.`;
+}
+
+export function linuxPermissionHint() {
+  return 'The write was denied by the file system. Check the owner and mode of the folder and its parents (chown/chmod), or choose a path this user owns; folders under /root or another account need root, which ReMCP deliberately does not use.';
+}
+
+export function filesystemAccessHint(platform = process.platform, execPath = process.execPath) {
+  if (platform === 'darwin') return macosPermissionHint(execPath);
+  if (platform === 'win32') return windowsPermissionHint(execPath);
+  return linuxPermissionHint();
+}
+
+// Can this process actually write where the runtime is allowed to work? The macOS folders above are
+// one answer; this is the other one, and it is the same question on every platform. A temporary file
+// is created and removed again, which is the only honest test — `access(W_OK)` reports what the
+// permission bits say, not what the sandbox, TCC or Controlled folder access will allow.
+export async function probeWritableRoots({ roots = [], create = writeFile, remove = rm, pid = process.pid } = {}) {
+  const results = [];
+  for (const root of roots) {
+    const probe = path.join(String(root), `.remcp-write-probe-${pid}`);
+    try {
+      await create(probe, '');
+      await remove(probe, { force: true });
+      results.push({ path: String(root), state: 'ok' });
+    } catch (error) {
+      const code = typeof error?.code === 'string' ? error.code : 'unknown';
+      results.push({ path: String(root), state: code === 'ENOENT' ? 'missing' : 'denied', code });
+    }
+  }
+  return results;
+}
+
+// One shape for `remcp doctor` on every platform: which places the tools may write to, and what to do
+// when one of them says no.
+export async function probeFilesystemAccess({ platform = process.platform, home = os.homedir(), roots = [], ...probeOptions } = {}) {
+  const folders = platform === 'darwin' ? (await probeMacosFolderAccess({ platform, home, ...probeOptions })).folders : [];
+  const writable = await probeWritableRoots({ roots: [...new Set(roots.filter(Boolean))], ...probeOptions });
+  const denied = [...folders.filter(folder => folder.state === 'denied').map(folder => folder.name), ...writable.filter(root => root.state === 'denied').map(root => root.path)];
+  const missing = platform === 'darwin' ? folders.filter(folder => folder.state === 'missing').map(folder => folder.name) : [];
+  return {
+    platform,
+    folders,
+    roots: writable,
+    ...(denied.length ? { denied, hint: filesystemAccessHint(platform) } : {}),
+    ...(missing.length ? { missing } : {}),
+  };
+}
+
+export async function probeMacosFolderAccess({ platform = process.platform, home = os.homedir(), list = readdir } = {}) {
+  if (platform !== 'darwin' || !home) return { supported: false, folders: [] };
+  const candidates = MACOS_PROTECTED_FOLDERS.map(name => ({ name, path: path.join(home, name) }));
+  // iCloud Drive only exists when it is switched on; a missing folder is not a permission problem.
+  candidates.push({ name: 'iCloud Drive', path: path.join(home, 'Library', 'Mobile Documents') });
+  const folders = [];
+  for (const candidate of candidates) {
+    try {
+      await list(candidate.path);
+      folders.push({ ...candidate, state: 'ok' });
+    } catch (error) {
+      const code = typeof error?.code === 'string' ? error.code : '';
+      if (code === 'ENOENT') folders.push({ ...candidate, state: 'missing' });
+      else if (code === 'EACCES' || code === 'EPERM') folders.push({ ...candidate, state: 'denied', code });
+      else folders.push({ ...candidate, state: 'error', code: code || 'unknown' });
+    }
+  }
+  const denied = folders.filter(folder => folder.state === 'denied');
+  return { supported: true, folders, ...(denied.length ? { denied: denied.map(folder => folder.name), hint: macosPermissionHint() } : {}) };
+}