@remcp/remcp 0.1.3 → 0.2.4

package/src/db.mjs

@@ -1,102 +0,0 @@
-import { mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-import { config } from './config.mjs';
-import { now } from './util.mjs';
-
-mkdirSync(config.dataDir, { recursive: true });
-export const db = new DatabaseSync(join(config.dataDir, 'remcp.sqlite'));
-db.exec(`PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;`);
-db.exec(`
-CREATE TABLE IF NOT EXISTS users (
-  uid TEXT PRIMARY KEY, email TEXT, name TEXT, email_verified INTEGER NOT NULL DEFAULT 0, created_at INTEGER NOT NULL, last_login_at INTEGER NOT NULL
-);
-CREATE TABLE IF NOT EXISTS pair_codes (
-  code_hash TEXT PRIMARY KEY, uid TEXT NOT NULL REFERENCES users(uid) ON DELETE CASCADE,
-  expires_at INTEGER NOT NULL, used_at INTEGER
-);
-CREATE TABLE IF NOT EXISTS devices (
-  id TEXT PRIMARY KEY, uid TEXT NOT NULL REFERENCES users(uid) ON DELETE CASCADE,
-  name TEXT NOT NULL, token_hash TEXT NOT NULL UNIQUE, hostname TEXT, platform TEXT, arch TEXT,
-  created_at INTEGER NOT NULL, last_seen_at INTEGER, revoked_at INTEGER
-);
-CREATE INDEX IF NOT EXISTS devices_uid_idx ON devices(uid);
-CREATE TABLE IF NOT EXISTS oauth_clients (
-  client_id TEXT PRIMARY KEY, client_name TEXT, redirect_uris TEXT NOT NULL, created_at INTEGER NOT NULL
-);
-CREATE TABLE IF NOT EXISTS oauth_codes (
-  code_hash TEXT PRIMARY KEY, client_id TEXT NOT NULL, uid TEXT NOT NULL,
-  redirect_uri TEXT NOT NULL, code_challenge TEXT NOT NULL, scope TEXT NOT NULL,
-  expires_at INTEGER NOT NULL, used_at INTEGER
-);
-CREATE TABLE IF NOT EXISTS oauth_refresh_tokens (
-  token_hash TEXT PRIMARY KEY, client_id TEXT NOT NULL, uid TEXT NOT NULL,
-  scope TEXT NOT NULL, expires_at INTEGER NOT NULL, revoked_at INTEGER
-);
-`);
-try { db.exec('ALTER TABLE users ADD COLUMN email_verified INTEGER NOT NULL DEFAULT 0'); } catch {}
-
-export const getUser = uid => db.prepare('SELECT * FROM users WHERE uid=?').get(uid);
-
-export function upsertUser({ uid, email = '', name = '', emailVerified = false }) {
-  const t = now();
-  db.prepare(`INSERT INTO users(uid,email,name,email_verified,created_at,last_login_at) VALUES(?,?,?,?,?,?)
-    ON CONFLICT(uid) DO UPDATE SET email=excluded.email,name=excluded.name,email_verified=excluded.email_verified,last_login_at=excluded.last_login_at`)
-    .run(uid, email, name, emailVerified ? 1 : 0, t, t);
-  return db.prepare('SELECT * FROM users WHERE uid=?').get(uid);
-}
-
-export function createPairCode(uid, codeHash, expiresAt) {
-  db.prepare('DELETE FROM pair_codes WHERE expires_at < ? OR used_at IS NOT NULL').run(now());
-  db.prepare('INSERT INTO pair_codes(code_hash,uid,expires_at) VALUES(?,?,?)').run(codeHash, uid, expiresAt);
-}
-
-export function consumePairCode(codeHash) {
-  db.exec('BEGIN IMMEDIATE');
-  try {
-    const row = db.prepare('SELECT * FROM pair_codes WHERE code_hash=? AND used_at IS NULL AND expires_at>?').get(codeHash, now());
-    if (row) db.prepare('UPDATE pair_codes SET used_at=? WHERE code_hash=?').run(now(), codeHash);
-    db.exec('COMMIT');
-    return row;
-  } catch (error) { db.exec('ROLLBACK'); throw error; }
-}
-
-export function createDevice(device) {
-  db.prepare(`INSERT INTO devices(id,uid,name,token_hash,hostname,platform,arch,created_at,last_seen_at)
-    VALUES(?,?,?,?,?,?,?,?,?)`).run(device.id, device.uid, device.name, device.tokenHash, device.hostname || '', device.platform || '', device.arch || '', now(), now());
-  return getDevice(device.id);
-}
-export const getDevice = id => db.prepare('SELECT * FROM devices WHERE id=?').get(id);
-export const getDeviceByTokenHash = hash => db.prepare('SELECT * FROM devices WHERE token_hash=? AND revoked_at IS NULL').get(hash);
-export const listDevices = uid => db.prepare('SELECT id,name,hostname,platform,arch,created_at,last_seen_at,revoked_at FROM devices WHERE uid=? ORDER BY created_at DESC').all(uid);
-export function touchDevice(id, meta = {}) {
-  db.prepare(`UPDATE devices SET name=COALESCE(?,name),hostname=COALESCE(?,hostname),platform=COALESCE(?,platform),arch=COALESCE(?,arch),last_seen_at=? WHERE id=?`)
-    .run(meta.name ?? null, meta.hostname ?? null, meta.platform ?? null, meta.arch ?? null, now(), id);
-}
-export function revokeDevice(uid, id) { return db.prepare('UPDATE devices SET revoked_at=? WHERE uid=? AND id=?').run(now(), uid, id); }
-
-export function saveOauthClient({ clientId, clientName = 'MCP client', redirectUris }) {
-  db.prepare('INSERT OR REPLACE INTO oauth_clients(client_id,client_name,redirect_uris,created_at) VALUES(?,?,?,?)')
-    .run(clientId, clientName, JSON.stringify(redirectUris), now());
-}
-export const getOauthClient = clientId => db.prepare('SELECT * FROM oauth_clients WHERE client_id=?').get(clientId);
-
-export function createOauthCode(row) {
-  db.prepare(`INSERT INTO oauth_codes(code_hash,client_id,uid,redirect_uri,code_challenge,scope,expires_at) VALUES(?,?,?,?,?,?,?)`)
-    .run(row.codeHash, row.clientId, row.uid, row.redirectUri, row.codeChallenge, row.scope, row.expiresAt);
-}
-export function consumeOauthCode(codeHash) {
-  db.exec('BEGIN IMMEDIATE');
-  try {
-    const row = db.prepare('SELECT * FROM oauth_codes WHERE code_hash=? AND used_at IS NULL AND expires_at>?').get(codeHash, now());
-    if (row) db.prepare('UPDATE oauth_codes SET used_at=? WHERE code_hash=?').run(now(), codeHash);
-    db.exec('COMMIT');
-    return row;
-  } catch (error) { db.exec('ROLLBACK'); throw error; }
-}
-export function saveRefreshToken(row) {
-  db.prepare('INSERT INTO oauth_refresh_tokens(token_hash,client_id,uid,scope,expires_at) VALUES(?,?,?,?,?)')
-    .run(row.tokenHash, row.clientId, row.uid, row.scope, row.expiresAt);
-}
-export const getRefreshToken = hash => db.prepare('SELECT * FROM oauth_refresh_tokens WHERE token_hash=? AND revoked_at IS NULL AND expires_at>?').get(hash, now());
-export const revokeRefreshToken = hash => db.prepare('UPDATE oauth_refresh_tokens SET revoked_at=? WHERE token_hash=?').run(now(), hash);

package/src/mcp.mjs

@@ -1,95 +0,0 @@
-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 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.',
-  write_pdf: 'Create a PDF or apply supported page edits to a PDF on the selected paired device.',
-  create_directory: 'Create a directory, including missing parent directories, on the selected paired device.',
-  list_directory: 'List files and directories at a path on the selected paired device.',
-  move_file: 'Move or rename a file or directory on the selected paired device.',
-  start_search: 'Start a local filename or content search session on the selected paired device.',
-  get_more_search_results: 'Read additional results from an existing local search session on the selected paired device.',
-  stop_search: 'Stop an active local search session on the selected paired device.',
-  list_searches: 'List active local search sessions on the selected paired device.',
-  get_file_info: 'Read file or directory metadata from the selected paired device.',
-  edit_block: 'Apply an exact targeted text or supported document edit on the selected paired device.',
-  start_process: 'Start a command or interactive process on the selected paired device. The command may change local or external state.',
-  read_process_output: 'Read buffered output from a running process on the selected paired device.',
-  interact_with_process: 'Send input to a running process on the selected paired device. Input may change local or external state.',
-  force_terminate: 'Force-stop a terminal session on the selected paired device.',
-  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 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';
-  schema.properties ||= {};
-  schema.properties.device = {
-    type: 'string',
-    description: 'ReMCP device id returned by list_devices. Required for every device operation.',
-  };
-  schema.required = [...new Set([...(schema.required || []), 'device'])];
-  const upstream = tool.annotations || {};
-  return {
-    name: tool.name,
-    title: upstream.title || tool.name,
-    description: publicDescription(tool),
-    inputSchema: schema,
-    annotations: {
-      title: upstream.title || tool.name,
-      readOnlyHint: tool.name === 'start_search' ? false : upstream.readOnlyHint === true,
-      destructiveHint: destructive.has(tool.name),
-      idempotentHint: upstream.idempotentHint === true,
-      openWorldHint: openWorld.has(tool.name) || tool.name === 'read_file' || upstream.openWorldHint === true,
-    },
-  };
-}
-
-const excludedPublicTools = new Set(['get_usage_stats','get_recent_tool_calls']);
-const catalog = rawCatalog.filter(tool => !excludedPublicTools.has(tool.name)).map(publicTool);
-const listDevicesTool = {
-  name: 'list_devices',
-  title: 'List ReMCP devices',
-  description: 'List computers paired to the signed-in ReMCP account and show whether each one is online.',
-  inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-  annotations: { title: 'List ReMCP devices', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-};
-
-export function createMcpServer(uid, relay) {
-  const server = new Server({ name: 'remcp', version: VERSION }, { capabilities: { tools: {} } });
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [listDevicesTool, ...catalog] }));
-  server.setRequestHandler(CallToolRequestSchema, async request => {
-    const name = request.params.name;
-    if (name === 'list_devices') {
-      return { content: [{ type: 'text', text: JSON.stringify({ devices: relay.devicesFor(uid) }, null, 2) }] };
-    }
-    if (!catalog.some(tool => tool.name === name)) throw new Error(`Unknown tool: ${name}`);
-    const args = { ...(request.params.arguments || {}) };
-    const device = String(args.device || '');
-    if (!device) throw new Error('device is required');
-    delete args.device;
-    return relay.rpc(uid, device, 'tools/call', { name, arguments: args });
-  });
-
-  return server;
-}
-
-export const publicToolCatalog = [listDevicesTool, ...catalog];

package/src/oauth.mjs

@@ -1,164 +0,0 @@
-import crypto from 'node:crypto';
-import express from 'express';
-import { rateLimit } from 'express-rate-limit';
-import { config } from './config.mjs';
-import { verifyFirebaseToken, signMcpAccessToken, verifyMcpAccessToken } from './auth.mjs';
-import { createOauthCode, consumeOauthCode, getOauthClient, getRefreshToken, getUser, revokeRefreshToken, saveOauthClient, saveRefreshToken, upsertUser } from './db.mjs';
-import { bearer, normalizeScope, now, randomId, randomToken, sha256, validRedirectUri } from './util.mjs';
-
-const CODE_TTL_MS = 5 * 60 * 1000;
-const router = express.Router();
-const oauthLimiter = rateLimit({ windowMs: 60_000, limit: 60, standardHeaders: 'draft-8', legacyHeaders: false });
-const tokenLimiter = rateLimit({ windowMs: 60_000, limit: 30, standardHeaders: 'draft-8', legacyHeaders: false });
-const endpoint = path => `${config.publicUrl}${path}`;
-
-function metadata() {
-  return {
-    issuer: config.publicUrl,
-    authorization_endpoint: endpoint('/oauth/authorize'),
-    token_endpoint: endpoint('/oauth/token'),
-    registration_endpoint: endpoint('/oauth/register'),
-    userinfo_endpoint: endpoint('/oauth/userinfo'),
-    revocation_endpoint: endpoint('/oauth/revoke'),
-    response_types_supported: ['code'],
-    grant_types_supported: ['authorization_code', 'refresh_token'],
-    token_endpoint_auth_methods_supported: ['none'],
-    code_challenge_methods_supported: ['S256'],
-    scopes_supported: ['openid', 'email', 'remcp:control', 'offline_access'],
-  };
-}
-
-function protectedResource() {
-  return {
-    resource: endpoint('/mcp'),
-    authorization_servers: [config.publicUrl],
-    bearer_methods_supported: ['header'],
-    scopes_supported: ['openid', 'email', 'remcp:control', 'offline_access'],
-    resource_documentation: config.publicUrl,
-    resource_policy_uri: endpoint('/privacy'),
-    resource_tos_uri: endpoint('/terms'),
-  };
-}
-
-router.get('/.well-known/oauth-authorization-server', (_req, res) => res.json(metadata()));
-router.get('/oauth/.well-known/oauth-authorization-server', (_req, res) => res.json(metadata()));
-router.get('/.well-known/oauth-protected-resource', (_req, res) => res.json(protectedResource()));
-router.get('/.well-known/oauth-protected-resource/mcp', (_req, res) => res.json(protectedResource()));
-
-router.post('/oauth/register', oauthLimiter, (req, res) => {
-  const redirectUris = Array.isArray(req.body?.redirect_uris) ? req.body.redirect_uris.map(String) : [];
-  if (!redirectUris.length || redirectUris.some(uri => !validRedirectUri(uri))) {
-    return res.status(400).json({ error: 'invalid_redirect_uri' });
-  }
-  if (req.body?.token_endpoint_auth_method && req.body.token_endpoint_auth_method !== 'none') {
-    return res.status(400).json({ error: 'invalid_client_metadata', error_description: 'ReMCP requires PKCE public clients (token_endpoint_auth_method=none).' });
-  }
-  const clientId = `remcp_${randomToken(18)}`;
-  saveOauthClient({ clientId, clientName: String(req.body?.client_name || 'MCP client').slice(0, 160), redirectUris });
-  res.status(201).json({
-    client_id: clientId,
-    client_name: String(req.body?.client_name || 'MCP client').slice(0, 160),
-    redirect_uris: redirectUris,
-    token_endpoint_auth_method: 'none',
-    grant_types: ['authorization_code', 'refresh_token'],
-    response_types: ['code'],
-  });
-});
-
-function validateAuthorize(values) {
-  const client = getOauthClient(String(values.client_id || ''));
-  if (!client) throw new Error('unknown_client');
-  const redirectUri = String(values.redirect_uri || '');
-  const allowed = JSON.parse(client.redirect_uris);
-  if (!allowed.includes(redirectUri)) throw new Error('invalid_redirect_uri');
-  if (values.response_type !== 'code') throw new Error('unsupported_response_type');
-  if (values.code_challenge_method !== 'S256' || !values.code_challenge) throw new Error('pkce_s256_required');
-  if (values.resource && values.resource !== endpoint('/mcp')) throw new Error('invalid_resource');
-  return { client, redirectUri };
-}
-
-router.get('/oauth/authorize', (req, res, next) => {
-  try { validateAuthorize(req.query); res.sendFile('authorize.html', { root: new URL('../public', import.meta.url).pathname }); }
-  catch (error) { res.status(400).send(`OAuth request rejected: ${error.message}`); }
-});
-
-router.post('/oauth/authorize/complete', oauthLimiter, async (req, res) => {
-  try {
-    const { redirectUri } = validateAuthorize(req.body || {});
-    const user = await verifyFirebaseToken(String(req.body?.id_token || ''));
-    upsertUser(user);
-    const rawCode = randomToken(32);
-    createOauthCode({
-      codeHash: sha256(rawCode), clientId: String(req.body.client_id), uid: user.uid,
-      redirectUri, codeChallenge: String(req.body.code_challenge),
-      scope: normalizeScope(req.body.scope), expiresAt: now() + CODE_TTL_MS,
-    });
-    const callback = new URL(redirectUri);
-    callback.searchParams.set('code', rawCode);
-    if (req.body.state) callback.searchParams.set('state', String(req.body.state));
-    callback.searchParams.set('iss', config.publicUrl);
-    res.json({ redirect_to: callback.toString() });
-  } catch (error) {
-    res.status(400).json({ error: 'access_denied', error_description: error.message });
-  }
-});
-
-function noStore(res) { res.setHeader('Cache-Control', 'no-store'); res.setHeader('Pragma', 'no-cache'); }
-function pkce(verifier) { return crypto.createHash('sha256').update(verifier).digest('base64url'); }
-
-router.post('/oauth/token', tokenLimiter, async (req, res) => {
-  noStore(res);
-  try {
-    const grant = String(req.body?.grant_type || '');
-    if (grant === 'authorization_code') {
-      const row = consumeOauthCode(sha256(String(req.body.code || '')));
-      if (!row) throw new Error('invalid_or_expired_code');
-      if (row.client_id !== String(req.body.client_id || '') || row.redirect_uri !== String(req.body.redirect_uri || '')) throw new Error('client_or_redirect_mismatch');
-      if (pkce(String(req.body.code_verifier || '')) !== row.code_challenge) throw new Error('pkce_verification_failed');
-      const accessToken = await signMcpAccessToken({ uid: row.uid, clientId: row.client_id, scope: row.scope });
-      const refreshToken = randomToken(48);
-      saveRefreshToken({ tokenHash: sha256(refreshToken), clientId: row.client_id, uid: row.uid, scope: row.scope, expiresAt: now() + config.refreshTtlSeconds * 1000 });
-      return res.json({ access_token: accessToken, token_type: 'Bearer', expires_in: config.accessTtlSeconds, refresh_token: refreshToken, scope: row.scope });
-    }
-    if (grant === 'refresh_token') {
-      const oldHash = sha256(String(req.body.refresh_token || ''));
-      const row = getRefreshToken(oldHash);
-      if (!row || row.client_id !== String(req.body.client_id || '')) throw new Error('invalid_refresh_token');
-      revokeRefreshToken(oldHash);
-      const scope = normalizeScope(req.body.scope || row.scope);
-      const accessToken = await signMcpAccessToken({ uid: row.uid, clientId: row.client_id, scope });
-      const refreshToken = randomToken(48);
-      saveRefreshToken({ tokenHash: sha256(refreshToken), clientId: row.client_id, uid: row.uid, scope, expiresAt: now() + config.refreshTtlSeconds * 1000 });
-      return res.json({ access_token: accessToken, token_type: 'Bearer', expires_in: config.accessTtlSeconds, refresh_token: refreshToken, scope });
-    }
-    res.status(400).json({ error: 'unsupported_grant_type' });
-  } catch (error) {
-    res.status(400).json({ error: 'invalid_grant', error_description: error.message });
-  }
-});
-
-
-router.get('/oauth/userinfo', oauthLimiter, async (req, res) => {
-  noStore(res);
-  try {
-    const token = bearer(req);
-    if (!token) throw new Error('missing_token');
-    const auth = await verifyMcpAccessToken(token);
-    const scopes = new Set(auth.scope.split(/\s+/).filter(Boolean));
-    if (!scopes.has('openid') || !scopes.has('email')) throw new Error('insufficient_scope');
-    const user = getUser(auth.uid);
-    if (!user?.email || user.email_verified !== 1) throw new Error('verified_email_required');
-    res.json({ sub: auth.uid, email: user.email, email_verified: true, ...(user.name ? { name: user.name } : {}) });
-  } catch (error) {
-    res.setHeader('WWW-Authenticate', 'Bearer error="invalid_token"');
-    res.status(401).json({ error: 'invalid_token', error_description: error.message });
-  }
-});
-
-router.post('/oauth/revoke', oauthLimiter, (req, res) => {
-  const token = String(req.body?.token || '');
-  if (token) revokeRefreshToken(sha256(token));
-  res.status(200).end();
-});
-
-export const oauthRouter = router;

package/src/relay.mjs

@@ -1,97 +0,0 @@
-import { WebSocketServer } from 'ws';
-import { config } from './config.mjs';
-import { getDeviceByTokenHash, listDevices, touchDevice } from './db.mjs';
-import { sha256 } from './util.mjs';
-import { REVIEW_SANDBOX_ID, reviewSandboxCall, reviewSandboxDevice } from './review-sandbox.mjs';
-
-export function createRelay(httpServer) {
-  const wss = new WebSocketServer({ noServer: true });
-  const agents = new Map();
-  const pending = new Map();
-  let seq = 0;
-
-  httpServer.on('upgrade', (req, socket, head) => {
-    const url = new URL(req.url || '/', 'http://localhost');
-    if (url.pathname !== '/agent') return socket.destroy();
-    const raw = req.headers.authorization || '';
-    const token = raw.startsWith('Bearer ') ? raw.slice(7).trim() : url.searchParams.get('token') || '';
-    const device = token ? getDeviceByTokenHash(sha256(token)) : undefined;
-    if (!device) {
-      socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
-      return socket.destroy();
-    }
-    req.remcpDevice = device;
-    wss.handleUpgrade(req, socket, head, ws => wss.emit('connection', ws, req));
-  });
-
-  wss.on('connection', (ws, req) => {
-    const device = req.remcpDevice;
-    const previous = agents.get(device.id);
-    if (previous && previous.ws !== ws) previous.ws.close(1012, 'replaced');
-    const agent = { ws, id: device.id, uid: device.uid, name: device.name, hostname: device.hostname, platform: device.platform, arch: device.arch, connectedAt: new Date().toISOString(), alive: true };
-    agents.set(device.id, agent);
-    touchDevice(device.id);
-
-    ws.on('pong', () => { agent.alive = true; touchDevice(device.id); });
-    ws.on('message', raw => {
-      let message;
-      try { message = JSON.parse(raw.toString()); } catch { return; }
-      if (message?.type === 'hello') {
-        agent.name = String(message.deviceName || agent.name);
-        agent.hostname = String(message.hostname || agent.hostname || '');
-        agent.platform = String(message.platform || agent.platform || '');
-        agent.arch = String(message.arch || agent.arch || '');
-        touchDevice(device.id, { name: agent.name, hostname: agent.hostname, platform: agent.platform, arch: agent.arch });
-        return;
-      }
-      if (message?.type === 'response' && message.id) {
-        const waiter = pending.get(message.id);
-        if (!waiter) return;
-        clearTimeout(waiter.timer); pending.delete(message.id);
-        if (message.error) waiter.reject(new Error(message.error.message || 'Agent error'));
-        else waiter.resolve(message.result);
-      }
-    });
-    ws.on('close', () => {
-      if (agents.get(device.id)?.ws === ws) agents.delete(device.id);
-      for (const [id, waiter] of pending) if (waiter.deviceId === device.id) {
-        clearTimeout(waiter.timer); pending.delete(id); waiter.reject(new Error(`Device disconnected: ${device.id}`));
-      }
-    });
-    ws.on('error', () => {});
-  });
-
-  const heartbeat = setInterval(() => {
-    for (const agent of agents.values()) {
-      if (!agent.alive) { agent.ws.terminate(); continue; }
-      agent.alive = false; agent.ws.ping();
-    }
-  }, 30000);
-  heartbeat.unref();
-
-  function rpc(uid, deviceId, method, params = {}) {
-    if (deviceId === REVIEW_SANDBOX_ID) {
-      if (method !== 'tools/call') throw new Error(`Unsupported Review Sandbox relay method: ${method}`);
-      return Promise.resolve(reviewSandboxCall(uid, params.name, params.arguments || {}));
-    }
-    const agent = agents.get(deviceId);
-    if (!agent || agent.uid !== uid || agent.ws.readyState !== 1) throw new Error(`Device is offline or unavailable: ${deviceId}`);
-    return new Promise((resolve, reject) => {
-      const id = `${Date.now()}-${++seq}`;
-      const timer = setTimeout(() => { pending.delete(id); reject(new Error(`Device request timed out: ${deviceId}`)); }, config.rpcTimeoutMs);
-      pending.set(id, { resolve, reject, timer, deviceId });
-      agent.ws.send(JSON.stringify({ type: 'request', id, method, params }));
-    });
-  }
-
-  function devicesFor(uid) {
-    const paired = listDevices(uid).map(device => ({
-      ...device,
-      online: agents.get(device.id)?.uid === uid,
-      connectedAt: agents.get(device.id)?.connectedAt || null,
-    }));
-    return [reviewSandboxDevice(), ...paired];
-  }
-
-  return { rpc, devicesFor, onlineCount: () => agents.size };
-}

package/src/review-sandbox.mjs

@@ -1,96 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync, appendFileSync, readdirSync, statSync } from 'node:fs';
-import { resolve, relative, dirname, basename } from 'node:path';
-import { sha256 } from './util.mjs';
-
-export const REVIEW_SANDBOX_ID = 'review-sandbox';
-
-function text(value, isError = false) {
-  return { content: [{ type: 'text', text: String(value) }], ...(isError ? { isError: true } : {}) };
-}
-
-function rootFor(uid) {
-  const dataDir = process.env.DATA_DIR || './data';
-  const root = resolve(dataDir, 'review-sandboxes', sha256(uid).slice(0, 32), 'workspace');
-  mkdirSync(root, { recursive: true });
-  const readme = resolve(root, 'README.txt');
-  try { statSync(readme); } catch {
-    writeFileSync(readme, 'ReMCP Review Sandbox\n\nThis isolated workspace is available for submission testing.\n', { mode: 0o600 });
-  }
-  return root;
-}
-
-function safePath(uid, input = '/workspace') {
-  const root = rootFor(uid);
-  let candidate = String(input || '').trim().replace(/\\/g, '/');
-  if (candidate === '/workspace' || candidate === 'workspace' || candidate === '/') candidate = '';
-  candidate = candidate.replace(/^\/workspace\/?/, '').replace(/^\/+/, '');
-  const target = resolve(root, candidate);
-  const rel = relative(root, target);
-  if (rel.startsWith('..') || rel === '..') throw new Error('Path must stay inside /workspace');
-  return { root, target, display: `/workspace${rel ? `/${rel.replaceAll('\\', '/')}` : ''}` };
-}
-
-export function reviewSandboxDevice() {
-  return { id: REVIEW_SANDBOX_ID, name: 'ReMCP Review Sandbox', hostname: 'isolated-review-workspace', platform: 'sandbox', arch: 'virtual', online: true, connectedAt: null, sandbox: true };
-}
-function listDirectory(uid, args) {
-  const { target, display } = safePath(uid, args.path);
-  const entries = readdirSync(target, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
-  const lines = entries.map(entry => `${entry.isDirectory() ? '[DIR]' : '[FILE]'} ${entry.name}`);
-  return text(`${display}\n${lines.join('\n') || '(empty)'}`);
-}
-
-function readFile(uid, args) {
-  if (args.isUrl) return text('The review sandbox does not fetch URLs. Pair a real device to use URL reads.', true);
-  const { target, display } = safePath(uid, args.path);
-  const body = readFileSync(target, 'utf8');
-  const lines = body.split(/\r?\n/);
-  const offset = Math.max(0, Number(args.offset || 0));
-  const length = Math.max(1, Math.min(1000, Number(args.length || 1000)));
-  return text(`${display}\n${lines.slice(offset, offset + length).join('\n')}`);
-}
-
-function writeFile(uid, args) {
-  const { target, display } = safePath(uid, args.path);
-  mkdirSync(dirname(target), { recursive: true });
-  if (args.mode === 'append') appendFileSync(target, String(args.content), { mode: 0o600 });
-  else writeFileSync(target, String(args.content), { mode: 0o600 });
-  return text(`Wrote ${Buffer.byteLength(String(args.content))} bytes to ${display}.`);
-}
-
-function createDirectory(uid, args) {
-  const { target, display } = safePath(uid, args.path);
-  mkdirSync(target, { recursive: true });
-  return text(`Directory ready: ${display}`);
-}
-function fileInfo(uid, args) {
-  const { target, display } = safePath(uid, args.path);
-  const info = statSync(target);
-  return text(JSON.stringify({ path: display, type: info.isDirectory() ? 'directory' : 'file', size: info.size, modifiedAt: info.mtime.toISOString() }, null, 2));
-}
-
-function startProcess(uid, args) {
-  const root = rootFor(uid);
-  const command = String(args.command || '').trim();
-  if (command === 'pwd') return text('/workspace');
-  if (/^ls(?:\s+-[alh]+)?$/.test(command)) return listDirectory(uid, { path: '/workspace' });
-  const cat = command.match(/^cat\s+(.+)$/);
-  if (cat) return readFile(uid, { path: cat[1].replace(/^['"]|['"]$/g, '') });
-  const echo = command.match(/^echo(?:\s+)(.*)$/s);
-  if (echo) return text(echo[1].replace(/^['"]|['"]$/g, ''));
-  return text(`Review Sandbox only permits pwd, ls, cat, and echo. Pair a real device to run other commands. Workspace: ${root}`, true);
-}
-
-export function reviewSandboxCall(uid, name, args = {}) {
-  try {
-    if (name === 'list_directory') return listDirectory(uid, args);
-    if (name === 'read_file') return readFile(uid, args);
-    if (name === 'write_file') return writeFile(uid, args);
-    if (name === 'create_directory') return createDirectory(uid, args);
-    if (name === 'get_file_info') return fileInfo(uid, args);
-    if (name === 'start_process') return startProcess(uid, args);
-    return text(`${name} is not enabled in the isolated Review Sandbox. Pair a real device to use this tool.`, true);
-  } catch (error) {
-    return text(error instanceof Error ? error.message : String(error), true);
-  }
-}