dsh-remote-control-plugin 0.0.0-stage → 0.3.0

package/host/relay-core.js

@@ -0,0 +1,189 @@
+import { randomBytes } from 'node:crypto'
+
+/**
+ * Rendezvous relay core.
+ *
+ * Mountable in two ways: standalone (`relay/server.js`) or inside a DSH Host
+ * (the Devices panel's "Create relay"), which is why it exposes `handle`
+ * instead of owning a socket. The protocol is plain HTTP long-poll so it works
+ * through any proxy and needs no dependency.
+ *
+ * Groups are keyed by sha256(workspaceKey), computed by the client, so the
+ * relay never sees the workspace key. Peer control stays end-to-end signed by
+ * the devices themselves; this process only routes.
+ */
+export function createRelay({ log = console } = {}) {
+  const devices = new Map() // deviceId -> record
+  const tokens = new Map() // token -> deviceId
+
+  const DEVICE_TTL_MS = 60_000
+  const MAX_QUEUE = 200
+  const MAX_BODY_BYTES = 2 * 1024 * 1024
+  const MAX_WAIT_SECONDS = 30
+
+  const reaper = setInterval(() => {
+    const now = Date.now()
+    for (const [deviceId, record] of devices) {
+      if (now - record.lastSeen <= DEVICE_TTL_MS) continue
+      devices.delete(deviceId)
+      tokens.delete(record.token)
+    }
+  }, 15_000)
+  reaper.unref?.()
+
+  async function handle(req, res) {
+    const url = new URL(req.url ?? '/', 'http://relay')
+    if (req.method === 'GET' && url.pathname === '/health') {
+      return send(res, 200, { ok: true, devices: devices.size })
+    }
+    if (req.method === 'POST' && url.pathname === '/v1/register') return register(req, res)
+    if (req.method === 'POST' && url.pathname === '/v1/heartbeat') return heartbeat(req, res)
+    if (req.method === 'POST' && url.pathname === '/v1/send') return forward(req, res)
+    if (req.method === 'GET' && url.pathname === '/v1/inbox') return inbox(url, res)
+    return send(res, 404, { error: 'not-found' })
+  }
+
+  async function register(req, res) {
+    const body = await readJson(req)
+    const groupId = typeof body?.groupId === 'string' ? body.groupId : ''
+    const deviceId = typeof body?.deviceId === 'string' ? body.deviceId : ''
+    if (!/^[0-9a-f]{32,64}$/.test(groupId)) return send(res, 400, { error: 'bad-group' })
+    if (!deviceId || deviceId.length > 128) return send(res, 400, { error: 'bad-device' })
+
+    let record = devices.get(deviceId)
+    if (record && record.groupId !== groupId) return send(res, 409, { error: 'device-in-use' })
+    if (!record) {
+      record = {
+        deviceId,
+        groupId,
+        token: randomBytes(24).toString('hex'),
+        name: typeof body?.name === 'string' ? body.name.slice(0, 80) : 'DSH device',
+        userId: typeof body?.userId === 'string' ? body.userId : null,
+        lastSeen: Date.now(),
+        queue: [],
+        waiters: new Set(),
+      }
+      devices.set(deviceId, record)
+      tokens.set(record.token, deviceId)
+    } else {
+      record.lastSeen = Date.now()
+      if (typeof body?.name === 'string') record.name = body.name.slice(0, 80)
+      if (typeof body?.userId === 'string') record.userId = body.userId
+    }
+    log.info?.(`[relay] register ${record.name} (${deviceId.slice(0, 12)})`)
+    return send(res, 200, { token: record.token, peers: peerList(record) })
+  }
+
+  async function heartbeat(req, res) {
+    const body = await readJson(req)
+    const record = authorize(body?.token)
+    if (!record) return send(res, 401, { error: 'unauthorized' })
+    record.lastSeen = Date.now()
+    return send(res, 200, { ok: true, peers: peerList(record) })
+  }
+
+  async function forward(req, res) {
+    const body = await readJson(req)
+    const from = authorize(body?.token)
+    if (!from) return send(res, 401, { error: 'unauthorized' })
+    const to = devices.get(String(body?.to || ''))
+    if (!to || to.groupId !== from.groupId) return send(res, 404, { error: 'unknown-peer' })
+    const message = body?.message
+    if (message === undefined || JSON.stringify(message).length > MAX_BODY_BYTES) {
+      return send(res, 413, { error: 'too-large' })
+    }
+    if (to.queue.length >= MAX_QUEUE) to.queue.shift()
+    to.queue.push({ from: from.deviceId, message, at: Date.now() })
+    wake(to)
+    return send(res, 200, { ok: true })
+  }
+
+  function inbox(url, res) {
+    const record = authorize(url.searchParams.get('token'))
+    if (!record) return send(res, 401, { error: 'unauthorized' })
+    record.lastSeen = Date.now()
+    if (record.queue.length > 0) return send(res, 200, { messages: drain(record), peers: peerList(record) })
+
+    const waitSeconds = Math.min(Number(url.searchParams.get('wait') || 25) || 25, MAX_WAIT_SECONDS)
+    let settled = false
+    const finish = () => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      record.waiters.delete(finish)
+      try { send(res, 200, { messages: drain(record), peers: peerList(record) }) } catch { /* client gone */ }
+    }
+    record.waiters.add(finish)
+    const timer = setTimeout(finish, waitSeconds * 1000)
+    res.on('close', () => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      record.waiters.delete(finish)
+    })
+  }
+
+  function drain(record) {
+    const messages = record.queue
+    record.queue = []
+    return messages
+  }
+
+  function wake(record) {
+    for (const waiter of [...record.waiters]) waiter()
+  }
+
+  function authorize(token) {
+    if (typeof token !== 'string' || !token) return undefined
+    const deviceId = tokens.get(token)
+    if (!deviceId) return undefined
+    const record = devices.get(deviceId)
+    if (!record) { tokens.delete(token); return undefined }
+    return record
+  }
+
+  function peerList(self) {
+    const now = Date.now()
+    const items = []
+    for (const record of devices.values()) {
+      if (record.groupId !== self.groupId || record.deviceId === self.deviceId) continue
+      if (now - record.lastSeen > DEVICE_TTL_MS) continue
+      items.push({ deviceId: record.deviceId, name: record.name, userId: record.userId, lastSeen: record.lastSeen })
+    }
+    return items
+  }
+
+  return {
+    handle,
+    stats: () => ({ devices: devices.size }),
+    close: () => clearInterval(reaper),
+  }
+}
+
+function send(res, status, value) {
+  if (res.writableEnded) return
+  const body = JSON.stringify(value)
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'content-length': Buffer.byteLength(body),
+    'cache-control': 'no-store',
+  })
+  res.end(body)
+}
+
+function readJson(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    let size = 0
+    req.on('data', (chunk) => {
+      size += chunk.length
+      if (size > 2 * 1024 * 1024) { reject(new Error('too large')); req.destroy(); return }
+      chunks.push(chunk)
+    })
+    req.on('end', () => {
+      if (chunks.length === 0) return resolve({})
+      try { resolve(JSON.parse(Buffer.concat(chunks).toString('utf8'))) } catch (error) { reject(error) }
+    })
+    req.on('error', reject)
+  })
+}

package/host/relay-link.js

@@ -0,0 +1,335 @@
+import { createHash } from 'node:crypto'
+import http from 'node:http'
+
+/**
+ * Outbound link to the remote-control relay.
+ *
+ * The relay is a rendezvous point, not a trust anchor: this link tunnels the
+ * same signed `/peer/*` HTTP calls the LAN transport uses, so the receiving
+ * Host still verifies the per-peer HMAC end to end. A compromised relay can
+ * drop or delay traffic, but cannot forge a control command.
+ *
+ * Messages:
+ *   http / http-response        unary call and its reply
+ *   stream-open / stream-status / stream-chunk / stream-end / stream-cancel
+ *                               SSE transcript relayed frame by frame
+ */
+export function createRelayLink({ url, key, deviceId, deviceName, userId, localPort, log }) {
+  const base = String(url).replace(/\/+$/, '')
+  const groupId = createHash('sha256').update(String(key)).digest('hex')
+  const peers = new Map()
+  const pending = new Map()
+  const streams = new Map()
+  const locals = new Map()
+
+  let token
+  let stopped = false
+  let heartbeatTimer
+  let sequence = 0
+
+  async function start() {
+    await register()
+    heartbeatTimer = setInterval(() => { heartbeat().catch(() => {}) }, 5000)
+    heartbeatTimer.unref?.()
+    inboxLoop().catch((error) => log.warn(`[remote-control] relay inbox stopped: ${error?.message || error}`))
+  }
+
+  function stop() {
+    stopped = true
+    clearInterval(heartbeatTimer)
+    for (const entry of pending.values()) entry.resolve({ status: 503, body: '{"error":"relay-stopped"}' })
+    pending.clear()
+    for (const entry of streams.values()) entry.onEnd()
+    streams.clear()
+    for (const request of locals.values()) { try { request.destroy() } catch { /* ignore */ } }
+    locals.clear()
+  }
+
+  async function register() {
+    const response = await fetch(`${base}/v1/register`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ groupId, deviceId, name: deviceName, userId }),
+    })
+    if (!response.ok) throw new Error(`relay register failed: ${response.status}`)
+    const data = await response.json()
+    token = data.token
+    applyPeers(data.peers)
+    log.info(`[remote-control] relay connected: ${base}`)
+  }
+
+  async function heartbeat() {
+    if (!token || stopped) return
+    try {
+      const response = await fetch(`${base}/v1/heartbeat`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ token }),
+      })
+      if (response.status === 401) { token = undefined; return }
+      if (!response.ok) return
+      const data = await response.json()
+      applyPeers(data.peers)
+    } catch { /* relay unreachable; next tick retries */ }
+  }
+
+  function applyPeers(list) {
+    if (!Array.isArray(list)) return
+    const seen = new Set()
+    for (const item of list) {
+      if (!item || typeof item.deviceId !== 'string') continue
+      seen.add(item.deviceId)
+      peers.set(item.deviceId, {
+        deviceId: item.deviceId,
+        name: typeof item.name === 'string' ? item.name : 'DSH device',
+        userId: typeof item.userId === 'string' ? item.userId : null,
+        lastSeen: Number(item.lastSeen) || Date.now(),
+      })
+    }
+    for (const deviceId of peers.keys()) if (!seen.has(deviceId)) peers.delete(deviceId)
+  }
+
+  async function inboxLoop() {
+    while (!stopped) {
+      if (!token) {
+        await delay(1500)
+        try { await register() } catch { /* retry */ }
+        continue
+      }
+      try {
+        const controller = new AbortController()
+        const timer = setTimeout(() => controller.abort(), 40000)
+        const response = await fetch(`${base}/v1/inbox?token=${encodeURIComponent(token)}&wait=25`, { signal: controller.signal })
+        clearTimeout(timer)
+        if (response.status === 401) { token = undefined; continue }
+        if (!response.ok) { await delay(1000); continue }
+        const data = await response.json()
+        if (data.peers) applyPeers(data.peers)
+        for (const item of data.messages ?? []) {
+          dispatch(item.from, item.message).catch((error) => {
+            log.warn(`[remote-control] relay dispatch failed: ${error?.message || error}`)
+          })
+        }
+      } catch {
+        if (stopped) return
+        await delay(1000)
+      }
+    }
+  }
+
+  async function dispatch(from, message) {
+    if (!message || typeof message !== 'object') return
+    switch (message.kind) {
+      case 'http': {
+        const result = await localRequest(message.method, message.path, message.headers, message.body)
+        await send(from, { kind: 'http-response', id: message.id, status: result.status, body: result.body })
+        return
+      }
+      case 'http-response': {
+        const entry = pending.get(message.id)
+        if (!entry) return
+        pending.delete(message.id)
+        entry.resolve({ status: message.status, body: message.body })
+        return
+      }
+      case 'stream-open':
+        openLocalStream(from, message)
+        return
+      case 'stream-status': {
+        const entry = streams.get(message.id)
+        entry?.onStatus?.(message.status)
+        return
+      }
+      case 'stream-chunk': {
+        streams.get(message.id)?.onChunk(message.chunk)
+        return
+      }
+      case 'stream-end': {
+        const entry = streams.get(message.id)
+        if (!entry) return
+        streams.delete(message.id)
+        entry.onEnd()
+        return
+      }
+      case 'stream-cancel': {
+        const request = locals.get(message.id)
+        if (!request) return
+        locals.delete(message.id)
+        try { request.destroy() } catch { /* ignore */ }
+        return
+      }
+      default:
+        return
+    }
+  }
+
+  function localRequest(method, pathname, headers, body) {
+    return new Promise((resolve) => {
+      const request = http.request({
+        host: '127.0.0.1',
+        port: localPort,
+        path: pathname,
+        method,
+        headers: { ...headers, host: `127.0.0.1:${localPort}` },
+      }, (response) => {
+        let data = ''
+        response.on('data', (chunk) => { data += chunk })
+        response.on('end', () => resolve({ status: response.statusCode ?? 502, body: data }))
+      })
+      request.on('error', (error) => resolve({
+        status: 502,
+        body: JSON.stringify({ error: 'local-unreachable', message: error?.message || String(error) }),
+      }))
+      if (body !== undefined && body !== null) request.write(body)
+      request.end()
+    })
+  }
+
+  function openLocalStream(from, message) {
+    const id = message.id
+    const request = http.request({
+      host: '127.0.0.1',
+      port: localPort,
+      path: message.path,
+      method: 'GET',
+      headers: { ...message.headers, host: `127.0.0.1:${localPort}` },
+    }, (response) => {
+      send(from, { kind: 'stream-status', id, status: response.statusCode ?? 502 }).catch(() => {})
+      if ((response.statusCode ?? 500) >= 400) {
+        response.resume()
+        locals.delete(id)
+        send(from, { kind: 'stream-end', id }).catch(() => {})
+        return
+      }
+      response.on('data', (chunk) => {
+        send(from, { kind: 'stream-chunk', id, chunk: chunk.toString('utf8') }).catch(() => {})
+      })
+      response.on('end', () => {
+        locals.delete(id)
+        send(from, { kind: 'stream-end', id }).catch(() => {})
+      })
+      response.on('error', () => {
+        locals.delete(id)
+        send(from, { kind: 'stream-end', id }).catch(() => {})
+      })
+    })
+    request.on('error', () => {
+      locals.delete(id)
+      send(from, { kind: 'stream-end', id }).catch(() => {})
+    })
+    locals.set(id, request)
+    request.end()
+  }
+
+  async function send(to, message) {
+    if (!token) throw new Error('relay not registered')
+    const response = await fetch(`${base}/v1/send`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ token, to, message }),
+    })
+    if (response.status === 401) { token = undefined; throw new Error('relay unauthorized') }
+    if (!response.ok) throw new Error(`relay send failed: ${response.status}`)
+  }
+
+  async function request(target, options) {
+    if (!token) return { status: 503, body: '{"error":"relay-offline"}' }
+    const id = nextId()
+    const reply = new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        pending.delete(id)
+        resolve({ status: 504, body: '{"error":"relay-timeout"}' })
+      }, 20000)
+      timer.unref?.()
+      pending.set(id, { resolve: (value) => { clearTimeout(timer); resolve(value) } })
+    })
+    await send(target, {
+      kind: 'http',
+      id,
+      method: options.method,
+      path: options.path,
+      headers: options.headers,
+      body: options.body,
+    })
+    return reply
+  }
+
+  function stream(target, options, res) {
+    const id = nextId()
+    let opened = false
+    const entry = {
+      onStatus(status) {
+        if (opened) return
+        opened = true
+        if (status >= 400) {
+          streams.delete(id)
+          try {
+            res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
+            res.end('{"error":"peer-refused"}')
+          } catch { /* ignore */ }
+          return
+        }
+        try {
+          res.writeHead(200, {
+            'content-type': 'text/event-stream; charset=utf-8',
+            'cache-control': 'no-store, no-transform',
+            connection: 'keep-alive',
+            'x-accel-buffering': 'no',
+          })
+        } catch { /* ignore */ }
+      },
+      onChunk(chunk) { try { res.write(chunk) } catch { /* ignore */ } },
+      onEnd() { try { res.end() } catch { /* ignore */ } },
+    }
+    streams.set(id, entry)
+    const timeout = setTimeout(() => {
+      if (opened) return
+      opened = true
+      streams.delete(id)
+      try {
+        res.writeHead(504, { 'content-type': 'application/json; charset=utf-8' })
+        res.end('{"error":"relay-timeout"}')
+      } catch { /* ignore */ }
+    }, 15000)
+    timeout.unref?.()
+
+    res.on('close', () => {
+      clearTimeout(timeout)
+      if (!streams.has(id)) return
+      streams.delete(id)
+      send(target, { kind: 'stream-cancel', id }).catch(() => {})
+    })
+
+    send(target, {
+      kind: 'stream-open',
+      id,
+      path: options.path,
+      headers: options.headers,
+    }).catch((error) => {
+      clearTimeout(timeout)
+      streams.delete(id)
+      if (!res.writableEnded) {
+        try { res.writeHead(502, { 'content-type': 'application/json; charset=utf-8' }); res.end(JSON.stringify({ error: error?.message || 'relay-send-failed' })) } catch { /* ignore */ }
+      }
+    })
+  }
+
+  function nextId() {
+    sequence += 1
+    return `${deviceId}-${Date.now().toString(36)}-${sequence}`
+  }
+
+  return {
+    start,
+    stop,
+    request,
+    stream,
+    peers: () => [...peers.values()],
+    url: () => base,
+    connected: () => Boolean(token),
+  }
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/icon.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Remote Control">
+  <defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#2f6bff"/>
+      <stop offset="1" stop-color="#7a3cff"/>
+    </linearGradient>
+  </defs>
+  <rect x="2" y="2" width="60" height="60" rx="16" fill="url(#bg)"/>
+  <rect x="20" y="12" width="24" height="40" rx="6" fill="none" stroke="#ffffff" stroke-width="3.2"/>
+  <line x1="28" y1="17" x2="36" y2="17" stroke="#ffffff" stroke-width="2.6" stroke-linecap="round"/>
+  <path d="M27 30l-4 5 4 5" fill="none" stroke="#dce6ff" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"/>
+  <line x1="35" y1="29" x2="35" y2="41" stroke="#ffffff" stroke-width="3" stroke-linecap="round"/>
+  <path d="M44 24c3 2.5 3 13.5 0 16" fill="none" stroke="#ffffff" stroke-width="2.6" stroke-linecap="round" opacity="0.9"/>
+  <path d="M49 19c5.5 4.5 5.5 21.5 0 26" fill="none" stroke="#ffffff" stroke-width="2.6" stroke-linecap="round" opacity="0.55"/>
+</svg>