@remcp/remcp 0.2.43 → 0.2.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/remcp",
-  "version": "0.2.43",
+  "version": "0.2.44",
   "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/cli/config.mjs

@@ -7,21 +7,64 @@ import { normalizeRuntime } from '../runtime.mjs';
 
 import { configDir, configFile, machineIdFile, officialOrigin, runtimeConfigFile } from './env.mjs';
 
+export const CONFIG_SCHEMA_VERSION = 1;
+const legacyOfficialOrigins = new Set(['https://remcp.delio24.com']);
+
+function migrateConfig(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('ReMCP config must be a JSON object');
+  const declared = Number(value.configSchemaVersion || 0);
+  // A newer client may have added fields this client does not understand. Preserve that document
+  // byte-for-meaning and only use the known fields below; never downgrade its schema marker.
+  if (Number.isSafeInteger(declared) && declared > CONFIG_SCHEMA_VERSION) return { value: { ...value }, changed: false };
+
+  let next = { ...value };
+  let changed = false;
+  if (declared < 1) {
+    try {
+      const server = new URL(String(next.serverUrl || ''));
+      if (legacyOfficialOrigins.has(server.origin)) {
+        next.serverUrl = officialOrigin;
+        if (next.trustRuntime === undefined) next.trustRuntime = true;
+        changed = true;
+      }
+    } catch {}
+    if (next.configSchemaVersion !== CONFIG_SCHEMA_VERSION) {
+      next.configSchemaVersion = CONFIG_SCHEMA_VERSION;
+      changed = true;
+    }
+  }
+  return { value: next, changed };
+}
+
+function configForWrite(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('ReMCP config must be a JSON object');
+  const declared = Number(value.configSchemaVersion || 0);
+  return {
+    ...value,
+    configSchemaVersion: Number.isSafeInteger(declared) && declared > CONFIG_SCHEMA_VERSION
+      ? declared
+      : CONFIG_SCHEMA_VERSION,
+  };
+}
+
 export function loadConfig(required = true) {
   if (!fs.existsSync(configFile)) {
     if (!required) return undefined;
     throw new Error(`ReMCP is not paired. Generate a pairing command at ${officialOrigin}/app/connect`);
   }
-  const value = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+  const migrated = migrateConfig(JSON.parse(fs.readFileSync(configFile, 'utf8')));
+  const value = migrated.value;
   // A configuration that only carries preferences (for example after `remcp auto-update off`
   // before pairing) has no runtime yet; it must not fail as if it were corrupt.
   if (value.runtime !== undefined) value.runtime = normalizeRuntime(value.runtime);
+  if (migrated.changed) saveConfig(value);
   return value;
 }
 
 export function saveConfig(value) {
+  const persisted = configForWrite(value);
   fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
-  fs.writeFileSync(configFile, JSON.stringify(value, null, 2) + '\n', { mode: 0o600 });
+  fs.writeFileSync(configFile, JSON.stringify(persisted, null, 2) + '\n', { mode: 0o600 });
   fs.chmodSync(configFile, 0o600);
 }
 

package/src/cli/service.mjs

@@ -72,6 +72,22 @@ export function installWindowsService(cliPath = globalCliPath()) {
   run('schtasks.exe', ['/Run', '/TN', windowsTaskName]);
 }
 
+// `serviceInstalled` was added after background services already existed in the wild. Treat an
+// explicit false as the user's opt-out, an explicit true as the current marker, and only infer the
+// old intent from an OS service artifact when the marker is absent. This keeps legacy installs
+// repairable without resurrecting a service that a newer client explicitly disabled.
+export function persistentServiceExpected(config) {
+  if (config?.serviceInstalled === false) return false;
+  if (config?.serviceInstalled === true) return true;
+  const platform = servicePlatform();
+  if (platform === 'linux') return fs.existsSync(linuxServiceFile);
+  if (platform === 'darwin') return fs.existsSync(macServiceFile);
+  if (platform === 'win32') {
+    return spawnSync('schtasks.exe', ['/Query', '/TN', windowsTaskName], { stdio: 'ignore' }).status === 0;
+  }
+  return false;
+}
+
 export function configurePostInstallAccess() {
   const platform = servicePlatform();
   try {
@@ -136,7 +152,7 @@ export function installPersistentAgent(config) {
 // (a failed install, a cleaned LaunchAgents directory, a re-imaged user), the next update recreates
 // it instead of leaving a hand-over to a process nobody supervises.
 export function ensureServiceIfRecorded(config) {
-  if (config?.serviceInstalled !== true) return false;
+  if (!persistentServiceExpected(config)) return false;
   try {
     const cliPath = globalCliPath();
     const platform = servicePlatform();
@@ -169,6 +185,9 @@ export function ensureServiceIfRecorded(config) {
       // kickstart) and is what the Windows task already does on every update.
       installMacService(cliPath);
     } else if (platform === 'win32') installWindowsService(cliPath);
+    // Upgrade the legacy inferred state only after the supervisor repair succeeded. A failed repair
+    // must not turn a stale artifact into a permanent "managed service" declaration.
+    if (config?.serviceInstalled !== true) saveConfig({ ...config, serviceInstalled: true });
     return true;
   } catch (error) {
     console.error(`Could not ensure the background service: ${error instanceof Error ? error.message : String(error)}`);
@@ -176,7 +195,8 @@ export function ensureServiceIfRecorded(config) {
   }
 }
 
-export function restartPersistentServiceIfInstalled() {
+export function restartPersistentServiceIfInstalled(config) {
+  if (!persistentServiceExpected(config)) return null;
   const platform = servicePlatform();
   if (platform === 'linux' && fs.existsSync(linuxServiceFile)) {
     run('systemctl', ['--user', 'daemon-reload']);
@@ -184,7 +204,14 @@ export function restartPersistentServiceIfInstalled() {
     return 'remcp-agent.service';
   }
   if (platform === 'darwin' && fs.existsSync(macServiceFile)) {
-    run('launchctl', ['kickstart', '-k', `${macLaunchDomain()}/${macServiceLabel}`]);
+    try {
+      run('launchctl', ['kickstart', '-k', `${macLaunchDomain()}/${macServiceLabel}`]);
+    } catch {
+      // A plist can survive while launchd has no loaded job (older installs, logout/login cleanup,
+      // manual bootout, or a failed previous update). Re-register the job instead of surfacing the
+      // opaque launchctl 113 error. installMacService is idempotent and rewrites stale Node paths too.
+      installMacService(globalCliPath());
+    }
     return macServiceLabel;
   }
   if (platform === 'win32') {

package/src/cli/update.mjs

@@ -200,7 +200,7 @@ export async function updateCommand(flags) {
   // Only a validated spec is persisted, so a failed update cannot leave the install unable to start.
   if (targets.persistRuntime) saveConfig({ ...cfg, runtime: { ...cfg.runtime, packageSpec: targets.runtimeSpec } });
   const after = { cli: installedVersion(PACKAGE_NAME), runtime: installedVersion(cfg.runtime.packageName) };
-  const restarted = restartPersistentServiceIfInstalled();
+  const restarted = restartPersistentServiceIfInstalled(cfg);
   if (restarted) {
     console.log(`ReMCP updated and ${restarted} restarted (client ${before.cli} → ${after.cli ?? '?'}, runtime ${before.runtime ?? '?'} → ${after.runtime ?? '?'}).`);
     return;

package/src/cli.mjs

@@ -128,13 +128,13 @@ export async function main(argv = process.argv.slice(2)) {
     }
     if (action === 'on' || action === 'enable') {
       console.log(JSON.stringify(setTelemetry(true), null, 2));
-      restartPersistentServiceIfInstalled();
+      restartPersistentServiceIfInstalled(loadConfig(false));
       console.log('Usage metrics enabled and the agent restarted to apply it.');
       return;
     }
     if (action === 'off' || action === 'disable') {
       console.log(JSON.stringify(setTelemetry(false), null, 2));
-      restartPersistentServiceIfInstalled();
+      restartPersistentServiceIfInstalled(loadConfig(false));
       console.log('Usage metrics disabled and the agent restarted to apply it.');
       return;
     }
@@ -162,7 +162,7 @@ export async function main(argv = process.argv.slice(2)) {
     if (!['on', 'off', 'enable', 'disable'].includes(action)) throw new Error('Usage: remcp godmode [status|on|off]');
     const enabled = action === 'on' || action === 'enable';
     writeJsonFile(runtimeConfigFile, { ...readJsonFile(runtimeConfigFile), unrestricted: enabled });
-    const restarted = restartPersistentServiceIfInstalled();
+    const restarted = restartPersistentServiceIfInstalled(loadConfig(false));
     if (enabled) {
       console.error('Unrestricted mode is ON for this computer: every path and every command is allowed, including sudo. Anything the model is asked to do -- and anything a prompt injection asks it to do -- can now change this machine. Turn it off with `remcp godmode off` when you are done.');
     } else {
@@ -213,9 +213,12 @@ export async function main(argv = process.argv.slice(2)) {
   }
 
   if (command === 'uninstall') {
+    const cfg = loadConfig(false);
     uninstallPersistentService();
+    // Keep the pairing unless --purge was requested, but remember that the owner explicitly removed
+    // the supervisor. Future updates must not infer an old service artifact and recreate it.
+    if (cfg) saveConfig({ ...cfg, serviceInstalled: false });
     if (flags.purge) {
-      const cfg = loadConfig(false);
       const specs = [PACKAGE_NAME, ...(cfg?.runtime?.packageName ? [cfg.runtime.packageName] : [])];
       run(npm.command, [...npm.args, 'uninstall', '--global', ...specs, '--no-audit', '--no-fund', '--loglevel=error']);
     }