@remcp/remcp 0.1.0 → 0.1.1

package/src/agent.mjs

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'node:url';
 import WebSocket from 'ws';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { VERSION } from './version.mjs';
 
 function desktopCommanderEntry() {
   try { return fileURLToPath(import.meta.resolve('@wonderwhy-er/desktop-commander')); } catch {}
@@ -31,10 +32,10 @@ export async function runAgent(options) {
   let stopping = false;
   let activeSocket;
 
-  const mcp = new Client({ name: 'remcp-agent', version: '0.1.0' });
+  const mcp = new Client({ name: 'remcp-agent', version: VERSION });
   const transport = new StdioClientTransport({ command: process.execPath, args: [desktopCommanderEntry()] });
   await mcp.connect(transport);
-  console.log('Local Desktop Commander MCP ready');
+  console.log('Local device runtime ready');
 
   async function respond(ws, message) {
     try {
@@ -54,7 +55,7 @@ export async function runAgent(options) {
     const ws = new WebSocket(agentUrl, { headers: { Authorization: `Bearer ${deviceToken}` } });
     activeSocket = ws;
     ws.on('open', () => {
-      ws.send(JSON.stringify({ type: 'hello', deviceId, deviceName, hostname: os.hostname(), platform: process.platform, arch: process.arch, agentVersion: '0.1.0' }));
+      ws.send(JSON.stringify({ type: 'hello', deviceId, deviceName, hostname: os.hostname(), platform: process.platform, arch: process.arch, agentVersion: VERSION }));
       console.log(`Connected to ${agentUrl} as ${deviceName} (${deviceId})`);
     });
     ws.on('message', raw => {

package/src/cli.mjs

@@ -2,11 +2,15 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
+import { spawnSync } from 'node:child_process';
 import { runAgent } from './agent.mjs';
+import { LOCAL_RUNTIME_NAME, LOCAL_RUNTIME_SPEC, PACKAGE_NAME, VERSION } from './version.mjs';
 
 const home = os.homedir();
 const configDir = process.env.REMCP_CONFIG_DIR || path.join(home, '.config', 'remcp');
 const configFile = path.join(configDir, 'config.json');
+const serviceFile = path.join(home, '.config', 'systemd', 'user', 'remcp-agent.service');
+const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 
 function parse(argv) {
   const [command = 'help', ...rest] = argv;
@@ -18,73 +22,141 @@ function parse(argv) {
   }
   return { command, flags };
 }
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, { stdio: 'inherit', ...options });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`${command} failed with exit code ${result.status}`);
+  return result;
+}
+
+function output(command, args) {
+  const result = spawnSync(command, args, { encoding: 'utf8' });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`${command} failed with exit code ${result.status}`);
+  return String(result.stdout || '').trim();
+}
+
 function loadConfig() {
-  if (!fs.existsSync(configFile)) throw new Error(`ReMCP is not paired. Run: remcp connect --server https://host --code CODE`);
+  if (!fs.existsSync(configFile)) throw new Error(`ReMCP is not paired. Run: npx --yes ${PACKAGE_NAME}@latest connect --server https://remcp.delio24.com --code CODE --install`);
   return JSON.parse(fs.readFileSync(configFile, 'utf8'));
 }
+
 function saveConfig(value) {
   fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
   fs.writeFileSync(configFile, JSON.stringify(value, null, 2) + '\n', { mode: 0o600 });
   fs.chmodSync(configFile, 0o600);
 }
-function unitPath() { return path.join(home, '.config', 'systemd', 'user', 'remcp-agent.service'); }
-function installLinuxService() {
-  const unit = `[Unit]\nDescription=ReMCP device agent\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nExecStart=${process.execPath} ${process.argv[1]} start\nRestart=always\nRestartSec=3\nNoNewPrivileges=true\n\n[Install]\nWantedBy=default.target\n`;
-  fs.mkdirSync(path.dirname(unitPath()), { recursive: true });
-  fs.writeFileSync(unitPath(), unit);
-  const { spawnSync } = requireSpawn();
+
+function globalPrefix() {
+  return output(npmCommand, ['prefix', '--global']);
+}
+
+function globalCliPath() {
+  const prefix = globalPrefix();
+  return process.platform === 'win32' ? path.join(prefix, 'remcp.cmd') : path.join(prefix, 'bin', 'remcp');
+}
+
+function npmGlobalInstall(packageSpec) {
+  run(npmCommand, ['install', '--global', packageSpec, LOCAL_RUNTIME_SPEC, '--no-audit', '--no-fund', '--loglevel=error']);
+}
+
+function quoteSystemd(value) {
+  return `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+}
+
+function installLinuxService(cliPath = globalCliPath()) {
+  const unit = `[Unit]\nDescription=ReMCP device agent\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nExecStart=${quoteSystemd(cliPath)} start\nRestart=always\nRestartSec=3\nNoNewPrivileges=true\n\n[Install]\nWantedBy=default.target\n`;
+  fs.mkdirSync(path.dirname(serviceFile), { recursive: true });
+  fs.writeFileSync(serviceFile, unit);
+  run('systemctl', ['--user', 'daemon-reload']);
+  run('systemctl', ['--user', 'enable', '--now', 'remcp-agent.service']);
+}
+
+function installPersistentAgent() {
+  if (process.platform !== 'linux') throw new Error('Automatic background service installation currently supports Linux');
+  console.log(`Installing ${PACKAGE_NAME}@${VERSION} and the local device runtime…`);
+  npmGlobalInstall(`${PACKAGE_NAME}@${VERSION}`);
+  installLinuxService(globalCliPath());
+  console.log('ReMCP is installed as a user service. Future updates: remcp update');
+}
+
+function restartLinuxServiceIfInstalled() {
+  if (process.platform !== 'linux' || !fs.existsSync(serviceFile)) return;
+  run('systemctl', ['--user', 'daemon-reload']);
+  run('systemctl', ['--user', 'restart', 'remcp-agent.service']);
+}
+
+function uninstallLinuxService() {
+  if (process.platform !== 'linux') return;
+  spawnSync('systemctl', ['--user', 'disable', '--now', 'remcp-agent.service'], { stdio: 'inherit' });
+  try { fs.unlinkSync(serviceFile); } catch {}
   spawnSync('systemctl', ['--user', 'daemon-reload'], { stdio: 'inherit' });
-  spawnSync('systemctl', ['--user', 'enable', '--now', 'remcp-agent.service'], { stdio: 'inherit' });
 }
-function requireSpawn() {
-  return { spawnSync: (command, args, opts) => {
-    const result = requireChild().spawnSync(command, args, opts);
-    if (result.status !== 0) throw new Error(`${command} failed`);
-    return result;
-  }};
+
+function printHelp() {
+  console.log(`ReMCP ${VERSION}\n\nCommands:\n  npx --yes ${PACKAGE_NAME}@latest connect --server https://remcp.delio24.com --code ABC12345 --install\n  remcp start\n  remcp status\n  remcp doctor\n  remcp update\n  remcp install\n  remcp uninstall\n  remcp uninstall --purge\n  remcp --version`);
 }
-let childModule;
-function requireChild() { if (!childModule) throw new Error('child_process not initialized'); return childModule; }
 
 export async function main(argv = process.argv.slice(2)) {
-  childModule = await import('node:child_process');
   const { command, flags } = parse(argv);
+
+  if (command === '--version' || command === '-v' || command === 'version') {
+    console.log(VERSION);
+    return;
+  }
+
   if (command === 'connect') {
     const server = String(flags.server || '').replace(/\/$/, '');
     const code = String(flags.code || '').toUpperCase();
     if (!server || !code) throw new Error('--server and --code are required');
     const response = await fetch(`${server}/api/pair/claim`, {
-      method: 'POST', headers: { 'content-type': 'application/json' },
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
       body: JSON.stringify({ code, name: String(flags.name || os.hostname()), hostname: os.hostname(), platform: process.platform, arch: process.arch }),
     });
     if (!response.ok) throw new Error(`Pairing failed (${response.status}): ${await response.text()}`);
     const paired = await response.json();
     saveConfig({ serverUrl: server, deviceId: paired.deviceId, deviceToken: paired.deviceToken, deviceName: String(flags.name || os.hostname()) });
     console.log(`Paired ${os.hostname()} with ${server}`);
-    if (flags.install) {
-      if (process.platform === 'linux') installLinuxService();
-      else console.log('Automatic service installation currently supports Linux. Run `remcp start` or install a launch service for this user.');
-    }
+    if (flags.install) installPersistentAgent();
     return;
   }
-  if (command === 'start') { await runAgent(loadConfig()); return; }
+
+  if (command === 'start') {
+    await runAgent(loadConfig());
+    return;
+  }
+
   if (command === 'status' || command === 'doctor') {
     const cfg = loadConfig();
-    const health = await fetch(`${cfg.serverUrl}/health`).then(r => r.json());
-    console.log(JSON.stringify({ configured: true, deviceId: cfg.deviceId, deviceName: cfg.deviceName, server: cfg.serverUrl, serverHealth: health }, null, 2));
+    const health = await fetch(`${cfg.serverUrl}/health?fresh=${Date.now()}`, { cache: 'no-store' }).then(r => r.json());
+    console.log(JSON.stringify({ configured: true, cliVersion: VERSION, deviceId: cfg.deviceId, deviceName: cfg.deviceName, server: cfg.serverUrl, serverHealth: health }, null, 2));
     return;
   }
+
   if (command === 'install') {
-    if (process.platform !== 'linux') throw new Error('Automatic service installation currently supports Linux');
-    loadConfig(); installLinuxService(); return;
+    loadConfig();
+    installPersistentAgent();
+    return;
   }
+
+  if (command === 'update') {
+    console.log(`Updating ${PACKAGE_NAME} to the latest published version…`);
+    npmGlobalInstall(`${PACKAGE_NAME}@latest`);
+    restartLinuxServiceIfInstalled();
+    console.log('ReMCP updated. Run `remcp --version` or `remcp status` to verify.');
+    return;
+  }
+
   if (command === 'uninstall') {
-    if (process.platform === 'linux') {
-      childModule.spawnSync('systemctl', ['--user','disable','--now','remcp-agent.service'], { stdio: 'inherit' });
-      try { fs.unlinkSync(unitPath()); } catch {}
-      childModule.spawnSync('systemctl', ['--user','daemon-reload'], { stdio: 'inherit' });
+    uninstallLinuxService();
+    if (flags.purge) {
+      console.log('Removing global ReMCP packages…');
+      run(npmCommand, ['uninstall', '--global', PACKAGE_NAME, LOCAL_RUNTIME_NAME, '--no-audit', '--no-fund', '--loglevel=error']);
     }
     return;
   }
-  console.log(`ReMCP 0.1.0\n\nCommands:\n  remcp connect --server https://remcp.delio24.com --code ABC12345 --install\n  remcp start\n  remcp status\n  remcp install\n  remcp uninstall`);
+
+  printHelp();
 }

package/src/config.mjs

@@ -22,7 +22,7 @@ function loadSigningSecret() {
   return generated;
 }
 const tokenSecret = loadSigningSecret();
-const installSpec = (process.env.REMCP_INSTALL_SPEC || '@remcp/remcp').trim();
+const installSpec = (process.env.REMCP_INSTALL_SPEC || '@remcp/remcp@latest').trim();
 if (!/^[A-Za-z0-9@._:/#-]+$/.test(installSpec)) throw new Error('REMCP_INSTALL_SPEC contains unsupported characters');
 
 export const config = Object.freeze({

package/src/mcp.mjs

@@ -1,13 +1,14 @@
 import { readFileSync } from 'node:fs';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { VERSION } from './version.mjs';
 
 const rawCatalog = JSON.parse(readFileSync(new URL('./tool-catalog.json', import.meta.url), 'utf8'));
 const destructive = new Set(['set_config_value','write_file','write_pdf','move_file','edit_block','start_process','interact_with_process','force_terminate','kill_process']);
 const openWorld = new Set(['start_process','interact_with_process']);
 const descriptions = {
-  get_config: 'Read the local Desktop Commander configuration for the selected paired device.',
-  set_config_value: 'Change one supported Desktop Commander configuration value on the selected paired device.',
+  get_config: 'Read the local device runtime configuration for the selected paired device.',
+  set_config_value: 'Change one supported local device runtime configuration value on the selected paired device.',
   read_file: 'Read a local file or a user-supplied URL from the selected paired device.',
   read_multiple_files: 'Read multiple local files from the selected paired device in one call.',
   write_file: 'Create, replace, or append to a file on the selected paired device.',
@@ -28,10 +29,14 @@ const descriptions = {
   list_sessions: 'List active terminal sessions on the selected paired device.',
   list_processes: 'List running operating-system processes on the selected paired device.',
   kill_process: 'Terminate a process by PID on the selected paired device.',
-  get_usage_stats: 'Read local Desktop Commander usage statistics from the selected paired device.',
-  get_recent_tool_calls: 'Read recent local Desktop Commander tool-call history from the selected paired device.',
+  get_usage_stats: 'Read local device runtime usage statistics from the selected paired device.',
+  get_recent_tool_calls: 'Read recent local device runtime tool-call history from the selected paired device.',
 };
 
+function publicDescription(tool) {
+  return String(descriptions[tool.name] || tool.description || '').replace(/\s+/g, ' ').trim();
+}
+
 function publicTool(tool) {
   const schema = structuredClone(tool.inputSchema || { type: 'object', properties: {} });
   schema.type = 'object';
@@ -45,7 +50,7 @@ function publicTool(tool) {
   return {
     name: tool.name,
     title: upstream.title || tool.name,
-    description: descriptions[tool.name] || tool.description,
+    description: publicDescription(tool),
     inputSchema: schema,
     annotations: {
       title: upstream.title || tool.name,
@@ -68,7 +73,7 @@ const listDevicesTool = {
 };
 
 export function createMcpServer(uid, relay) {
-  const server = new Server({ name: 'remcp', version: '0.1.0' }, { capabilities: { tools: {} } });
+  const server = new Server({ name: 'remcp', version: VERSION }, { capabilities: { tools: {} } });
 
   server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [listDevicesTool, ...catalog] }));
   server.setRequestHandler(CallToolRequestSchema, async request => {

package/src/server.mjs

@@ -13,6 +13,7 @@ import { oauthRouter } from './oauth.mjs';
 import { createRelay } from './relay.mjs';
 import { createMcpServer } from './mcp.mjs';
 import { now, randomId, randomToken, sha256 } from './util.mjs';
+import { VERSION } from './version.mjs';
 
 const app = express();
 app.set('trust proxy', 1);
@@ -22,15 +23,15 @@ app.use(helmet({
   contentSecurityPolicy: {
     directives: {
       defaultSrc: ["'self'"],
-      scriptSrc: ["'self'", 'https://www.gstatic.com'],
-      connectSrc: ["'self'", 'https://identitytoolkit.googleapis.com', 'https://securetoken.googleapis.com', 'https://www.googleapis.com'],
+      scriptSrc: ["'self'", 'https://www.gstatic.com', 'https://apis.google.com', 'https://www.google.com'],
+      connectSrc: ["'self'", 'https://identitytoolkit.googleapis.com', 'https://securetoken.googleapis.com', 'https://www.googleapis.com', 'https://apis.google.com', 'https://accounts.google.com'],
       imgSrc: ["'self'", 'data:'],
       styleSrc: ["'self'"],
       fontSrc: ["'none'"],
-      frameSrc: [firebaseFrame, 'https://accounts.google.com'],
+      frameSrc: [firebaseFrame, 'https://accounts.google.com', 'https://apis.google.com'],
       objectSrc: ["'none'"],
       baseUri: ["'none'"],
-      formAction: ["'self'"],
+      formAction: ["'self'", 'https://accounts.google.com'],
       frameAncestors: ["'none'"],
     },
   },
@@ -57,7 +58,7 @@ const relay = createRelay(httpServer);
 const sessions = new Map();
 const publicDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../public');
 
-app.get('/health', (_req, res) => res.json({ ok: true, service: 'remcp', version: '0.1.0', connectedDevices: relay.onlineCount() }));
+app.get('/health', (_req, res) => res.json({ ok: true, service: 'remcp', version: VERSION, connectedDevices: relay.onlineCount() }));
 app.get(config.domainVerificationPath, (_req, res) => {
   if (!config.domainVerificationToken) return res.status(404).type('text/plain').send('Not configured');
   res.type('text/plain').send(config.domainVerificationToken);