@remcp/remcp 0.1.3 → 0.1.4

package/skills/remcp-operator/SKILL.md

@@ -1,36 +0,0 @@
----
-name: remcp-operator
-description: Safely operate computers paired through ReMCP. Use when the user asks to inspect or change files, directories, local processes, terminal sessions, or ReMCP device state on one of their paired computers.
----
-
-# ReMCP Operator
-
-Use ReMCP only when the request actually needs a paired computer. Do not invoke ReMCP for general knowledge, writing, weather, web research, or conceptual questions that can be answered without the user's device.
-
-## Device selection
-
-1. Call `list_devices` before the first device operation unless a current ReMCP device id is already unambiguous in the conversation.
-2. Prefer an online device whose user-facing name or hostname matches the request.
-3. If more than one online device plausibly matches and choosing the wrong machine could change state, ask the user which device to use.
-
-## Read before write
-
-Inspect the smallest amount of device state needed to understand the request before changing it. Prefer `list_directory`, `get_file_info`, `read_file`, `list_processes`, or existing process output before a write or terminal mutation.
-## Changes
-
-- Use the narrowest tool that performs the requested change. Prefer `edit_block`, `write_file`, or `move_file` over a shell command when the dedicated tool expresses the action clearly.
-- Do not broaden a requested path, command, or target without a reason tied to the user's task.
-- Treat `set_config_value`, file replacement, process termination, and generic terminal commands as state-changing actions.
-- Generic terminal commands may also affect external services. Keep commands scoped to the user's stated goal and surface consequential effects before execution when they are not already clear from the request.
-
-## Verification
-
-After a change, use the cheapest relevant read to verify the result. Examples: re-read the edited range, list the destination directory after a move, or read process output after starting a command.
-
-## Long-running processes
-
-Use `start_process` once and then `read_process_output` or `interact_with_process` for the existing session. Avoid starting duplicate long-running processes just to obtain new output.
-
-## Out-of-scope requests
-
-Do not use ReMCP to access a computer the user has not paired or is not authorized to control. Do not ask for or process passwords, MFA codes, private keys, API keys, payment-card data, protected health information, government identifiers, or other restricted credentials/data through ReMCP tools. If a requested file or command would expose those categories, ask the user to use a safer local workflow instead.

package/src/auth.mjs

@@ -1,71 +0,0 @@
-import { createRemoteJWKSet, jwtVerify, SignJWT } from 'jose';
-import { config } from './config.mjs';
-import { bearer } from './util.mjs';
-import { upsertUser } from './db.mjs';
-
-const firebaseJwks = createRemoteJWKSet(new URL('https://www.googleapis.com/service_accounts/v1/jwk/securetoken@system.gserviceaccount.com'));
-const signingKey = new TextEncoder().encode(config.tokenSecret);
-
-export async function verifyFirebaseToken(token) {
-  const { payload } = await jwtVerify(token, firebaseJwks, {
-    issuer: `https://securetoken.google.com/${config.firebaseProjectId}`,
-    audience: config.firebaseProjectId,
-  });
-  if (!payload.sub) throw new Error('Firebase token has no subject');
-  const email = typeof payload.email === 'string' ? payload.email.toLowerCase() : '';
-  const uid = config.ownerEmail && email === config.ownerEmail ? `owner:${config.ownerEmail}` : payload.sub;
-  return {
-    uid,
-    firebaseUid: payload.sub,
-    email,
-    emailVerified: payload.email_verified === true,
-    name: typeof payload.name === 'string' ? payload.name : '',
-  };
-}
-
-export async function requireFirebase(req, res, next) {
-  try {
-    const token = bearer(req);
-    if (!token) return res.status(401).json({ error: 'firebase_auth_required' });
-    const user = await verifyFirebaseToken(token);
-    upsertUser(user);
-    req.user = user;
-    next();
-  } catch (error) {
-    res.status(401).json({ error: 'invalid_firebase_token', message: error.message });
-  }
-}
-
-export async function signMcpAccessToken({ uid, clientId, scope }) {
-  return new SignJWT({ scope, client_id: clientId, typ: 'remcp_access' })
-    .setProtectedHeader({ alg: 'HS256' })
-    .setIssuer(config.publicUrl)
-    .setAudience(`${config.publicUrl}/mcp`)
-    .setSubject(uid)
-    .setIssuedAt()
-    .setExpirationTime(`${config.accessTtlSeconds}s`)
-    .sign(signingKey);
-}
-
-export async function verifyMcpAccessToken(token) {
-  const { payload } = await jwtVerify(token, signingKey, {
-    issuer: config.publicUrl,
-    audience: `${config.publicUrl}/mcp`,
-  });
-  if (payload.typ !== 'remcp_access' || !payload.sub) throw new Error('Invalid ReMCP access token');
-  return { uid: payload.sub, scope: String(payload.scope || ''), clientId: String(payload.client_id || '') };
-}
-
-export async function requireMcpAuth(req, res, next) {
-  try {
-    const token = bearer(req);
-    if (!token) throw new Error('missing_token');
-    const auth = await verifyMcpAccessToken(token);
-    if (!auth.scope.split(/\s+/).includes('remcp:control')) throw new Error('missing_scope');
-    req.mcpAuth = auth;
-    next();
-  } catch {
-    res.setHeader('WWW-Authenticate', `Bearer resource_metadata="${config.publicUrl}/.well-known/oauth-protected-resource/mcp"`);
-    res.status(401).json({ error: 'unauthorized' });
-  }
-}

package/src/config.mjs

@@ -1,51 +0,0 @@
-import process from 'node:process';
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { randomBytes } from 'node:crypto';
-
-function required(name, fallback = '') {
-  const value = process.env[name] || fallback;
-  if (!value) throw new Error(`${name} is required`);
-  return value;
-}
-
-const publicUrl = required('PUBLIC_URL', 'http://127.0.0.1:8787').replace(/\/$/, '');
-const dataDir = process.env.DATA_DIR || './data';
-function loadSigningSecret() {
-  const configured = process.env.TOKEN_SECRET || '';
-  if (configured) { if (configured.length < 32) throw new Error('TOKEN_SECRET must be at least 32 characters'); return configured; }
-  mkdirSync(dataDir, { recursive: true });
-  const file = join(dataDir, 'token-secret');
-  try { return readFileSync(file, 'utf8').trim(); } catch {}
-  const generated = randomBytes(48).toString('base64url');
-  writeFileSync(file, generated + '\n', { mode: 0o600 });
-  return generated;
-}
-const tokenSecret = loadSigningSecret();
-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({
-  publicUrl,
-  port: Number(process.env.PORT || 8787),
-  dataDir,
-  tokenSecret,
-  installSpec,
-  firebaseProjectId: required('FIREBASE_PROJECT_ID', 'remcp-33037'),
-  ownerEmail: (process.env.OWNER_EMAIL || '').trim().toLowerCase(),
-  pairTtlSeconds: Number(process.env.PAIR_TTL_SECONDS || 600),
-  accessTtlSeconds: Number(process.env.ACCESS_TTL_SECONDS || 3600),
-  refreshTtlSeconds: Number(process.env.REFRESH_TTL_SECONDS || 2592000),
-  rpcTimeoutMs: Number(process.env.RPC_TIMEOUT_MS || 120000),
-  domainVerificationToken: (process.env.OPENAI_DOMAIN_VERIFICATION_TOKEN || '').trim(),
-  domainVerificationPath: (process.env.OPENAI_DOMAIN_VERIFICATION_PATH || '/.well-known/openai-apps-challenge').trim(),
-  firebase: {
-    apiKey: required('FIREBASE_API_KEY'),
-    authDomain: required('FIREBASE_AUTH_DOMAIN'),
-    projectId: required('FIREBASE_PROJECT_ID', 'remcp-33037'),
-    storageBucket: process.env.FIREBASE_STORAGE_BUCKET || '',
-    messagingSenderId: process.env.FIREBASE_MESSAGING_SENDER_ID || '',
-    appId: required('FIREBASE_APP_ID'),
-    measurementId: process.env.FIREBASE_MEASUREMENT_ID || '',
-  },
-});

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 };
-}