@remcp/remcp 0.1.3 → 0.2.4

package/README.md

@@ -1,143 +1,71 @@
-# ReMCP
+# Device client
 
-ReMCP is an open-source remote MCP bridge for computers you control. A lightweight device agent connects **outbound** to a ReMCP relay, so ChatGPT, Codex, or another MCP client can work with local files, directories, searches, terminal sessions, and processes without exposing an inbound port on the computer.
-
-- Hosted service: <https://remcp.delio24.com>
-- MCP endpoint: `https://remcp.delio24.com/mcp`
-- npm: `@remcp/remcp`
-- License: MIT
-
-## Quick start
-
-Requires Node.js 22.5 or newer.
-
-1. Install the CLI:
+`@remcp/remcp` is the ReMCP device client. It pairs a computer with ReMCP, installs the first-party
+local runtime, and runs the outbound-only agent that serves your MCP client's tool calls.
 
 ```bash
 npm install --global @remcp/remcp@latest
-```
-
-2. Open <https://remcp.delio24.com/#connect>, sign in with Google or GitHub, and choose **Generate pairing command**. Run the exact generated command on the computer you want to pair.
-
-3. Verify:
-
-```bash
 remcp --version
 remcp status
 ```
 
-4. Add the MCP endpoint to your client:
-
-```text
-https://remcp.delio24.com/mcp
-```
-
-Authentication uses OAuth authorization code + PKCE with rotating refresh credentials.
-
-## Update
-
-```bash
-remcp update
-```
-
-`remcp update` refreshes the global CLI and compatible local runtime, then restarts the installed user service.
+Pairing commands are generated in the workspace at <https://remcp.delio24.com/app/connect>. The
+generated command runs `remcp connect --server … --code … --install`, which stores a per-device
+credential under `~/.config/remcp/`, installs the runtime from npm, and registers a user service
+(systemd on Linux, LaunchAgent on macOS, Scheduled Task on Windows).
 
-## CLI
+## Commands
 
 ```text
-remcp start             Run the device agent in the foreground
-remcp status            Show version, pairing and server health
-remcp doctor            Alias for status
-remcp update            Update ReMCP and restart the user service
-remcp install           Install or repair the user service
-remcp uninstall         Remove the user service
-remcp uninstall --purge Remove the service and global ReMCP packages
-remcp --version         Print the installed CLI version
-```
-
-## Architecture
-
-```text
-ChatGPT / Codex / MCP client
-           │
-           │ OAuth 2.1 + HTTPS
-           ▼
-     ReMCP relay /mcp
-           │
-           │ authenticated WSS (outbound from device)
-           ▼
-      paired computer
-           │
-           └── local file / search / terminal / process runtime
+remcp start                  Run the device agent in the foreground
+remcp status                 Show version, pairing, runtime, telemetry and server health as JSON
+remcp doctor                 Alias for status
+remcp update                 Update the client and runtime, then restart the user service
+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 --version
 ```
 
-The hosted relay stores account/device metadata, one-way hashes of reusable credentials, OAuth client metadata, and refresh-token hashes. Device credentials are independently revocable. MCP sessions are scoped to the authenticated ReMCP account.
+`remcp status` reports the runtime the device would install, whether the agent service is running,
+and the current usage-metrics state, so a support request can be answered with one paste.
 
-## OpenAI Plugin package
+## What runs on your computer
 
-The repository is prepared for the current OpenAI Plugins format:
+- the agent (`remcp start`), which holds the device credential and dials
+  `wss://remcp.delio24.com/agent`;
+- [`@remcp/runtime`](https://www.npmjs.com/package/@remcp/runtime), spawned by the agent as an MCP
+  stdio server. The runtime executes the tools, opens no network connection, and is supervised: if it
+  exits, the agent restarts it with backoff and reports the restart instead of failing silently.
 
-- `plugin.json` — portable Agent Plugins manifest;
-- `mcp.json` — production Streamable HTTP MCP configuration;
-- `skills/remcp-operator/SKILL.md` — bundled operator skill;
-- `assets/remcp-icon.png` — plugin icon;
-- `docs/OPENAI_PLUGIN.md` — submission and reviewer checklist;
-- `submission/openai-plugin-review.json` — generated tool annotations plus five positive and three negative review cases.
+Configuration lives in `~/.config/remcp/config.json` (client) and `~/.config/remcp/runtime.json`
+(runtime: allowed roots, blocked commands, output and write limits, and the usage-metrics switch).
+Run `npx @remcp/runtime --describe` to print the runtime's effective configuration.
 
-ReMCP has no plugin UI, so the public submission should not include UI screenshots. The remote MCP server uses a universal production URL and OAuth. See [`docs/OPENAI_PLUGIN.md`](docs/OPENAI_PLUGIN.md) before submitting.
+## Usage metrics
 
-## Security model
+Opt-out, self-hosted, and limited to tool names, timings, outcomes, error classes, and device health
+samples. No paths, no commands, no arguments, no output, no third-party endpoint, no install ping.
+Disable with `remcp telemetry off` or `REMCP_RUNTIME_DISABLE_TELEMETRY=1`; the switch applies to both
+the client and the runtime, and restarts the service so it takes effect immediately.
 
-- no inbound port is required on paired computers;
-- one revocable credential is issued per paired device;
-- reusable credentials are hashed server-side;
-- pairing codes are short-lived and single-use;
-- OAuth uses PKCE and rotating refresh credentials;
-- OAuth metadata advertises `openid` and `email`, with a UserInfo endpoint for verified-email workspace restrictions;
-- MCP tools carry explicit `readOnlyHint`, `openWorldHint`, and `destructiveHint` annotations;
-- the public review fixture is isolated per authenticated account and intentionally restricts terminal commands;
-- the supplied server container runs read-only with dropped Linux capabilities.
+## Security
 
-ReMCP tools should not be used to request or process passwords, MFA codes, API/private keys, payment-card data, protected health information, or government identifiers. See [`SECURITY.md`](SECURITY.md) and the hosted <https://remcp.delio24.com/security> page.
-
-## Self-hosting
-
-```bash
-git clone https://github.com/antonbaider/remcp.git
-cd remcp
-cp .env.example .env
-# Fill in your public URL and Firebase Web App configuration.
-docker compose up -d --build
-```
-
-Put a TLS reverse proxy in front of ReMCP and proxy WebSocket upgrades for `/agent`. The supplied Compose configuration binds the application to localhost by default. ReMCP verifies Firebase ID tokens using Google's public signing keys and does not require a Firebase Admin private key.
+- Outbound-only connection; the machine never listens.
+- One revocable credential per paired device, stored with restrictive permissions.
+- Runtime metadata from a custom server is only accepted with an explicit `--trust-runtime`.
+- Revoking a device in the workspace closes the connection; the agent then stops retrying and says so
+  instead of reconnecting forever.
 
 ## Development
 
 ```bash
-npm ci
+npm install
 npm run check
 npm test
-npm audit --omit=dev
-npm pack --dry-run
-```
-
-For server changes:
-
-```bash
-docker build -t remcp:test .
 ```
 
-See [`CONTRIBUTING.md`](CONTRIBUTING.md) for contribution and security rules.
-
-## Project docs
-
-- [`docs/OPENAI_PLUGIN.md`](docs/OPENAI_PLUGIN.md) — OpenAI Plugins submission
-- [`SECURITY.md`](SECURITY.md) — vulnerability reporting and operational security
-- [`CONTRIBUTING.md`](CONTRIBUTING.md) — development checks
-- [`CHANGELOG.md`](CHANGELOG.md) — release notes
-- [`THIRD_PARTY_NOTICES.md`](THIRD_PARTY_NOTICES.md) — third-party license notices
-
 ## License
 
-ReMCP is MIT licensed. Third-party notices for the local device runtime are preserved in `THIRD_PARTY_NOTICES.md`.
+MIT.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@remcp/remcp",
-  "version": "0.1.3",
-  "description": "Self-hosted remote MCP bridge for securely controlling your own computers from MCP clients.",
+  "version": "0.2.4",
+  "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",
   "homepage": "https://remcp.delio24.com",
@@ -14,37 +14,21 @@
   "files": [
     "bin",
     "src",
-    "public",
-    "plugin.json",
-    "mcp.json",
-    "assets",
-    "skills/remcp-operator",
     "LICENSE",
-    "THIRD_PARTY_NOTICES.md",
     "README.md"
   ],
   "scripts": {
-    "server": "node src/server.mjs",
-    "agent": "node src/agent.mjs",
-    "check": "node --check src/server.mjs && node --check src/agent.mjs && node --check src/cli.mjs",
-    "test": "node --test test/*.test.mjs",
-    "submission": "node scripts/generate-submission.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",
+    "test": "node --test test/*.test.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "express": "^5.2.1",
-    "express-rate-limit": "^8.7.0",
-    "helmet": "^8.3.0",
-    "jose": "^6.2.12",
     "ws": "^8.21.3"
   },
-  "overrides": {
-    "sharp": "0.35.4",
-    "uuid": "11.1.1"
-  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/antonbaider/remcp.git"
+    "url": "git+https://github.com/antonbaider/remcp.git",
+    "directory": "packages/client"
   },
   "bugs": {
     "url": "https://github.com/antonbaider/remcp/issues"
@@ -54,11 +38,13 @@
   },
   "keywords": [
     "mcp",
+    "model-context-protocol",
     "remote",
     "computer",
-    "filesystem",
-    "terminal",
+    "cli",
+    "agent",
     "chatgpt",
+    "codex",
     "self-hosted"
   ]
 }

package/src/agent.mjs

@@ -2,23 +2,59 @@ import os from 'node:os';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
-import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
 import WebSocket from 'ws';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { normalizeRuntime } from './runtime.mjs';
 import { VERSION } from './version.mjs';
 
-function desktopCommanderEntry() {
-  try { return fileURLToPath(import.meta.resolve('@wonderwhy-er/desktop-commander')); } catch {}
-  const configured = String(process.env.REMCP_DESKTOP_COMMANDER_ENTRY || '').trim();
-  const candidates = [
-    configured,
-    '/usr/lib/node_modules/@wonderwhy-er/desktop-commander/dist/index.js',
-    '/usr/local/lib/node_modules/@wonderwhy-er/desktop-commander/dist/index.js',
-    path.join(os.homedir(), '.hermes/node/lib/node_modules/@wonderwhy-er/desktop-commander/dist/index.js'),
-  ].filter(Boolean);
-  for (const candidate of candidates) if (existsSync(candidate)) return candidate;
-  throw new Error('@wonderwhy-er/desktop-commander is not installed');
+const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const METRICS_INTERVAL_MS = 60_000;
+const TELEMETRY_QUEUE_LIMIT = 500;
+const TELEMETRY_BATCH_LIMIT = 100;
+const TELEMETRY_SEND_INTERVAL_MS = 5_000;
+const RECONNECT_BASE_MS = 2_000;
+const RECONNECT_MAX_MS = 60_000;
+const RUNTIME_RESTART_BASE_MS = 1_000;
+const RUNTIME_RESTART_MAX_MS = 30_000;
+// Below the relay's RPC timeout so the model gets a real error instead of a client-side
+// timeout while the device keeps working invisibly.
+const CALL_TIMEOUT_MARGIN_MS = 10_000;
+
+function globalNodeModules() {
+  const result = spawnSync(npmCommand, ['root', '--global'], { encoding: 'utf8' });
+  if (result.error || result.status !== 0) throw new Error('Could not locate the global npm modules directory');
+  return String(result.stdout || '').trim();
+}
+
+function localRuntimeEntry(runtimeValue) {
+  const runtime = normalizeRuntime(runtimeValue);
+  const candidate = path.join(globalNodeModules(), ...runtime.packageName.split('/'), ...runtime.entry.split(/[\\/]+/));
+  if (!existsSync(candidate)) throw new Error('ReMCP local runtime is not installed. Run `remcp install`.');
+  return candidate;
+}
+
+function jitter(ms) {
+  return Math.round(ms * (0.75 + Math.random() * 0.5));
+}
+
+// Device health is sampled locally and is the only thing ReMCP stores about the machine
+// beyond its name, platform and last-seen time. No process list, no file names.
+function deviceMetrics(extra = {}) {
+  const load = os.loadavg?.()[0] ?? 0;
+  const totalMem = os.totalmem();
+  const freeMem = os.freemem();
+  return {
+    uptimeSeconds: Math.round(os.uptime()),
+    agentUptimeSeconds: Math.round(process.uptime()),
+    rssBytes: process.memoryUsage().rss,
+    load1: Number.isFinite(load) ? Number(load.toFixed(2)) : 0,
+    cpuCount: os.cpus?.().length ?? 0,
+    freeMemoryRatio: totalMem > 0 ? Number((freeMem / totalMem).toFixed(3)) : 0,
+    agentVersion: VERSION,
+    ...extra,
+  };
 }
 
 export async function runAgent(options) {
@@ -28,25 +64,137 @@ export async function runAgent(options) {
   const deviceName = String(options.deviceName || os.hostname());
   if (!serverUrl || !deviceToken || !deviceId) throw new Error('serverUrl, deviceToken and deviceId are required');
   const agentUrl = serverUrl.replace(/^http/, 'ws') + '/agent';
-  const reconnectMs = Number(options.reconnectMs || 3000);
+  const callTimeoutMs = Math.max(5_000, Number(options.rpcTimeoutMs || 120000) - CALL_TIMEOUT_MARGIN_MS);
+  const telemetryEnabled = options.telemetryEnabled !== false;
+  const persistState = typeof options.persistState === 'function' ? options.persistState : () => {};
   let stopping = false;
   let activeSocket;
+  let reconnects = 0;
+  let pendingRequests = 0;
+  let runtimeVersion = 'unknown';
+  let runtimeRestarts = 0;
+  let runtimeDown = false;
+  const telemetryQueue = [];
+  let telemetryTimer = null;
+  const runtimeEntry = localRuntimeEntry(options.runtime);
 
-  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 device runtime ready');
+  // --- local runtime supervision ------------------------------------------------------
+  // If the runtime dies (a bad shell, a broken pipe, an OOM) the agent used to stay
+  // "online" forever and every later call failed with an opaque "Not connected". Now the
+  // transport is watched and the runtime is restarted with backoff.
+  let mcp = null;
+  let transport = null;
+  let runtimeRestartDelay = RUNTIME_RESTART_BASE_MS;
+
+  function runtimeEnv() {
+    // The SDK's stdio transport does not inherit the environment by default; spreading
+    // process.env here is what gives the runtime its REMCP_RUNTIME_* configuration, PATH,
+    // HOME and the telemetry opt-out.
+    const env = { ...process.env };
+    if (!telemetryEnabled) env.REMCP_RUNTIME_DISABLE_TELEMETRY = '1';
+    return env;
+  }
+
+  async function startRuntime() {
+    if (stopping) return;
+    runtimeDown = false;
+    const client = new Client({ name: 'remcp-agent', version: VERSION });
+    const stdio = new StdioClientTransport({ command: process.execPath, args: [runtimeEntry], env: runtimeEnv() });
+    mcp = client;
+    transport = stdio;
+    client.fallbackNotificationHandler = async notification => {
+      if (!telemetryEnabled) return;
+      if (notification?.method !== 'notifications/remcp/telemetry') return;
+      const events = Array.isArray(notification.params?.events) ? notification.params.events : [];
+      if (!events.length) return;
+      if (notification.params?.runtimeVersion) runtimeVersion = String(notification.params.runtimeVersion);
+      for (const event of events) {
+        if (telemetryQueue.length >= TELEMETRY_QUEUE_LIMIT) telemetryQueue.shift();
+        telemetryQueue.push(event);
+      }
+    };
+    stdio.onclose = () => handleRuntimeExit('closed');
+    stdio.onerror = error => console.error(`ReMCP local runtime error: ${error instanceof Error ? error.message : String(error)}`);
+    try {
+      await client.connect(stdio);
+      runtimeVersion = client.getServerVersion()?.version || runtimeVersion;
+      runtimeRestarts += 1;
+      runtimeRestartDelay = RUNTIME_RESTART_BASE_MS;
+      console.log(`ReMCP local runtime ready (${runtimeVersion})`);
+      send({ type: 'metrics', metrics: deviceMetrics({ reconnects, pendingRequests, runtimeVersion, runtimeRestarts, runtimeDown: false }) });
+      if (runtimeRestarts > 1) queueEvent({ event: 'runtime_restart', at: Date.now(), count: runtimeRestarts, success: true });
+    } catch (error) {
+      console.error(`ReMCP local runtime failed to start: ${error instanceof Error ? error.message : String(error)}`);
+      handleRuntimeExit('failed');
+    }
+  }
+
+  function handleRuntimeExit(reason) {
+    if (stopping || runtimeDown) return;
+    runtimeDown = true;
+    const delay = jitter(runtimeRestartDelay);
+    runtimeRestartDelay = Math.min(RUNTIME_RESTART_MAX_MS, runtimeRestartDelay * 2);
+    console.error(`ReMCP local runtime ${reason}; restarting in ${delay}ms`);
+    queueEvent({ event: 'runtime_down', at: Date.now(), reason: reason.slice(0, 24) });
+    send({ type: 'metrics', metrics: deviceMetrics({ reconnects, pendingRequests, runtimeVersion, runtimeRestarts, runtimeDown: true }) });
+    setTimeout(() => { void startRuntime(); }, delay).unref?.();
+  }
+
+  // --- relay connection ---------------------------------------------------------------
+  function send(message) {
+    if (activeSocket?.readyState === 1) {
+      activeSocket.send(JSON.stringify(message));
+      return true;
+    }
+    return false;
+  }
+
+  function flushTelemetry() {
+    if (!telemetryEnabled || !telemetryQueue.length) return;
+    const batch = telemetryQueue.splice(0, TELEMETRY_BATCH_LIMIT);
+    if (!send({ type: 'telemetry', runtimeVersion, agentVersion: VERSION, events: batch })) telemetryQueue.unshift(...batch);
+  }
+
+  function queueEvent(event) {
+    if (!telemetryEnabled) return;
+    if (telemetryQueue.length >= TELEMETRY_QUEUE_LIMIT) telemetryQueue.shift();
+    telemetryQueue.push(event);
+  }
+
+  function reportInstallOnce() {
+    if (!telemetryEnabled || options.installReported === true) return;
+    if (send({
+      type: 'install',
+      agentVersion: VERSION,
+      runtimeVersion,
+      node: process.versions.node,
+      platform: process.platform,
+      arch: process.arch,
+      installSpec: String(options.installSpec || ''),
+    })) {
+      persistState({ installReported: true });
+      console.log('ReMCP reported this installation to your own workspace (disable with `remcp telemetry off`).');
+    }
+  }
 
   async function respond(ws, message) {
+    pendingRequests += 1;
     try {
       let result;
-      if (message.method === 'tools/list') result = await mcp.listTools();
-      else if (message.method === 'tools/call') result = await mcp.callTool(message.params);
-      else if (message.method === 'ping') result = { ok: true, hostname: os.hostname(), platform: process.platform, arch: process.arch, uptimeSeconds: Math.floor(os.uptime()) };
-      else throw new Error(`Unsupported relay method: ${message.method}`);
+      if (message.method === 'ping') {
+        result = { ok: true, hostname: os.hostname(), platform: process.platform, arch: process.arch, uptimeSeconds: Math.floor(os.uptime()), agentVersion: VERSION, runtimeVersion, runtimeRestarts };
+      } else if (!runtimeDown && mcp) {
+        if (message.method === 'tools/list') result = await mcp.listTools(undefined, { timeout: callTimeoutMs });
+        else if (message.method === 'tools/call') result = await mcp.callTool(message.params, undefined, { timeout: callTimeoutMs });
+        else throw new Error(`Unsupported relay method: ${message.method}`);
+      } else {
+        throw new Error('The ReMCP local runtime is restarting. Retry in a few seconds.');
+      }
       ws.send(JSON.stringify({ type: 'response', id: message.id, result }));
     } catch (error) {
       ws.send(JSON.stringify({ type: 'response', id: message.id, error: { message: error instanceof Error ? error.message : String(error) } }));
+    } finally {
+      pendingRequests = Math.max(0, pendingRequests - 1);
     }
   }
 
@@ -55,36 +203,67 @@ 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: VERSION }));
-      console.log(`Connected to ${agentUrl} as ${deviceName} (${deviceId})`);
+      reconnects = 0;
+      ws.send(JSON.stringify({
+        type: 'hello',
+        deviceId,
+        deviceName,
+        hostname: os.hostname(),
+        platform: process.platform,
+        arch: process.arch,
+        agentVersion: VERSION,
+        runtimeVersion,
+        telemetryEnabled,
+        reconnects,
+      }));
+      console.log(`Connected to ${serverUrl} as ${deviceName}`);
+      send({ type: 'metrics', metrics: deviceMetrics({ reconnects, pendingRequests, runtimeVersion, runtimeRestarts, runtimeDown }) });
+      reportInstallOnce();
+      flushTelemetry();
     });
     ws.on('message', raw => {
       let message;
       try { message = JSON.parse(raw.toString()); } catch { return; }
       if (message?.type === 'request') void respond(ws, message);
     });
-    ws.on('close', () => { if (!stopping) setTimeout(connect, reconnectMs); });
+    ws.on('close', code => {
+      if (stopping) return;
+      if (code === 1008) {
+        // The relay closes with 1008 when the device was revoked. Retrying forever would
+        // hide that from the person at the computer.
+        console.error('ReMCP access for this device was revoked. Pair the machine again from the ReMCP workspace: remcp connect --server <url> --code <code> --install');
+        return;
+      }
+      reconnects += 1;
+      const delay = 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}`));
   }
 
+  telemetryTimer = setInterval(() => {
+    if (activeSocket?.readyState === 1) {
+      send({ type: 'metrics', metrics: deviceMetrics({ reconnects, pendingRequests, runtimeVersion, runtimeRestarts, runtimeDown, queueDepth: telemetryQueue.length }) });
+      flushTelemetry();
+    }
+  }, METRICS_INTERVAL_MS);
+  telemetryTimer.unref?.();
+  const telemetryFlushTimer = setInterval(flushTelemetry, TELEMETRY_SEND_INTERVAL_MS);
+  telemetryFlushTimer.unref?.();
+
   async function stop() {
     if (stopping) return;
     stopping = true;
+    if (telemetryTimer) clearInterval(telemetryTimer);
+    clearInterval(telemetryFlushTimer);
     try { activeSocket?.close(); } catch {}
-    try { await mcp.close(); } catch {}
-    try { await transport.close(); } catch {}
+    try { await mcp?.close(); } catch {}
+    try { await transport?.close(); } catch {}
   }
+
   process.once('SIGINT', () => void stop().finally(() => process.exit(0)));
   process.once('SIGTERM', () => void stop().finally(() => process.exit(0)));
+  await startRuntime();
   connect();
-  return { stop };
-}
-
-if (import.meta.url === `file://${process.argv[1]}` && process.env.REMCP_SERVER_URL) {
-  await runAgent({
-    serverUrl: process.env.REMCP_SERVER_URL,
-    deviceToken: process.env.REMCP_DEVICE_TOKEN,
-    deviceId: process.env.REMCP_DEVICE_ID,
-    deviceName: process.env.REMCP_DEVICE_NAME,
-  });
+  return { stop, runtimeVersion: () => runtimeVersion, runtimeRestarts: () => runtimeRestarts, isRuntimeDown: () => runtimeDown };
 }