dsh-device-fleet 0.0.0-stage → 0.1.0-dev.1

package/src/net/relay-client.js

@@ -0,0 +1,258 @@
+// Relay client: keeps a control connection to the self-hosted relay and opens
+// spliced data connections to other fleet devices.
+import { EventEmitter } from 'node:events'
+import net from 'node:net'
+import { randomUUID } from 'node:crypto'
+import { relayAuthToken } from './identity.js'
+
+const DEFAULT_CONNECT_TIMEOUT_MS = 15_000
+
+export class RelayClient extends EventEmitter {
+  /**
+   * @param {object} options
+   * @param {string} options.host relay host
+   * @param {number} options.port relay control port
+   * @param {number} options.dataPort relay data port
+   * @param {string} options.fleetId
+   * @param {string} options.deviceId
+   * @param {string} options.fleetKey
+   * @param {{initialDelayMs?: number, maxDelayMs?: number}} [options.reconnect]
+   */
+  constructor({ host, port, dataPort, fleetId, deviceId, fleetKey, reconnect = {} }) {
+    super()
+    this.host = host
+    this.port = port
+    this.dataPort = dataPort
+    this.fleetId = fleetId
+    this.deviceId = deviceId
+    this.fleetKey = fleetKey
+    this.reconnect = { initialDelayMs: 500, maxDelayMs: 10_000, ...reconnect }
+
+    this.socket = null
+    this.buffer = ''
+    this.online = false
+    this.closed = false
+    this.attempt = 0
+    this.reconnectTimer = null
+    this.waiters = new Set()
+    this.readyWaiters = new Map()
+    this.controllers = new Map()
+  }
+
+  /** Start connecting; resolves once registered (or rejects on timeout). */
+  async start(timeoutMs = 5_000) {
+    if (this.socket) return
+    this.connect()
+    await this.whenOnline(timeoutMs)
+  }
+
+  whenOnline(timeoutMs = 5_000) {
+    if (this.online) return Promise.resolve()
+    return new Promise((resolve, reject) => {
+      const waiter = { resolve, reject }
+      this.waiters.add(waiter)
+      const timer = setTimeout(() => {
+        this.waiters.delete(waiter)
+        reject(new Error('relay connection timed out'))
+      }, timeoutMs)
+      timer.unref?.()
+      waiter.timer = timer
+    })
+  }
+
+  connect() {
+    if (this.closed) return
+    const socket = net.connect({ host: this.host, port: this.port })
+    this.socket = socket
+    this.buffer = ''
+    socket.setNoDelay?.(true)
+    socket.once('connect', () => {
+      const ts = Date.now()
+      this.send({
+        t: 'register',
+        fleetId: this.fleetId,
+        deviceId: this.deviceId,
+        ts,
+        token: relayAuthToken({ fleetKey: this.fleetKey, fleetId: this.fleetId, deviceId: this.deviceId, ts }),
+      })
+    })
+    socket.on('data', (chunk) => this.onData(chunk))
+    socket.on('error', () => {})
+    socket.once('close', () => this.onClose(socket))
+  }
+
+  send(message) {
+    if (!this.socket || this.socket.destroyed || !this.socket.writable) return false
+    this.socket.write(JSON.stringify(message) + '\n')
+    return true
+  }
+
+  onData(chunk) {
+    this.buffer += chunk.toString('utf8')
+    let newline = this.buffer.indexOf('\n')
+    while (newline >= 0) {
+      const line = this.buffer.slice(0, newline)
+      this.buffer = this.buffer.slice(newline + 1)
+      if (line.trim() !== '') this.onMessage(line)
+      newline = this.buffer.indexOf('\n')
+    }
+  }
+
+  onMessage(line) {
+    let message
+    try {
+      message = JSON.parse(line)
+    } catch {
+      return
+    }
+    switch (message?.t) {
+      case 'register.ok': {
+        this.online = true
+        this.attempt = 0
+        for (const waiter of this.waiters) {
+          this.waiters.delete(waiter)
+          clearTimeout(waiter.timer)
+          waiter.resolve()
+        }
+        this.emit('online', { deviceId: this.deviceId })
+        return
+      }
+      case 'error': {
+        this.emit('relay-error', message)
+        if (message.code === 'unauthorized' || message.code === 'unknown-fleet' || message.code === 'replaced') {
+          this.closed = true
+          this.socket?.destroy()
+        }
+        return
+      }
+      case 'incoming': {
+        const { reqId, fromDeviceId } = message
+        const controller = {
+          reqId,
+          fromDeviceId,
+          decided: false,
+          accept: () => this.acceptIncoming(controller),
+          reject: () => {
+            controller.decided = true
+            this.controllers.delete(reqId)
+            this.send({ t: 'reject', reqId })
+          },
+        }
+        this.controllers.set(reqId, controller)
+        this.emit('incoming', controller)
+        return
+      }
+      case 'connect.pending':
+        return
+      case 'connect.ready': {
+        const waiter = this.readyWaiters.get(message.reqId)
+        if (!waiter) return
+        this.readyWaiters.delete(message.reqId)
+        clearTimeout(waiter.timer)
+        waiter.resolve({ dataPort: message.dataPort, token: message.token })
+        return
+      }
+      case 'connect.fail': {
+        const waiter = this.readyWaiters.get(message.reqId)
+        if (waiter) {
+          this.readyWaiters.delete(message.reqId)
+          clearTimeout(waiter.timer)
+          waiter.reject(Object.assign(new Error(`relay connect failed: ${message.reason}`), { code: message.reason }))
+        }
+        const connectWaiter = this.connectWaiters?.get(message.reqId)
+        if (connectWaiter) {
+          this.connectWaiters.delete(message.reqId)
+          clearTimeout(connectWaiter.timer)
+          connectWaiter.reject(Object.assign(new Error(`relay connect failed: ${message.reason}`), { code: message.reason }))
+        }
+        return
+      }
+      default:
+        return
+    }
+  }
+
+  waitReady(reqId, timeoutMs = 15_000) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.readyWaiters.delete(reqId)
+        reject(Object.assign(new Error('relay data path timed out'), { code: 'data-timeout' }))
+      }, timeoutMs)
+      timer.unref?.()
+      this.readyWaiters.set(reqId, { resolve, reject, timer })
+    })
+  }
+
+  async acceptIncoming(controller) {
+    if (controller.decided) throw new Error('incoming request already settled')
+    controller.decided = true
+    this.controllers.delete(controller.reqId)
+    const ready = this.waitReady(controller.reqId)
+    this.send({ t: 'accept', reqId: controller.reqId })
+    const { dataPort, token } = await ready
+    return this.openDataSocket(controller.reqId, token, dataPort)
+  }
+
+  async requestConnect(targetDeviceId, timeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
+    if (!this.online) await this.whenOnline(Math.min(timeoutMs, 5_000))
+    const reqId = randomUUID()
+    const ready = this.waitReady(reqId, timeoutMs)
+    this.send({ t: 'connect', reqId, targetDeviceId })
+    const { dataPort, token } = await ready
+    return this.openDataSocket(reqId, token, dataPort)
+  }
+
+  openDataSocket(reqId, token, dataPort = this.dataPort) {
+    return new Promise((resolve, reject) => {
+      const socket = net.connect({ host: this.host, port: dataPort })
+      const timer = setTimeout(() => {
+        socket.destroy()
+        reject(Object.assign(new Error('relay data connection timed out'), { code: 'data-timeout' }))
+      }, DEFAULT_CONNECT_TIMEOUT_MS)
+      timer.unref?.()
+      socket.setNoDelay?.(true)
+      socket.once('connect', () => {
+        clearTimeout(timer)
+        socket.write(
+          JSON.stringify({ fleetId: this.fleetId, deviceId: this.deviceId, reqId, token }) + '\n',
+        )
+        resolve(socket)
+      })
+      socket.once('error', (error) => {
+        clearTimeout(timer)
+        reject(error)
+      })
+    })
+  }
+
+  onClose(socket) {
+    if (this.socket !== socket) return
+    this.socket = null
+    const wasOnline = this.online
+    this.online = false
+    if (wasOnline) this.emit('offline')
+    for (const [reqId, waiter] of this.readyWaiters) {
+      this.readyWaiters.delete(reqId)
+      clearTimeout(waiter.timer)
+      waiter.reject(Object.assign(new Error('relay connection lost'), { code: 'relay-offline' }))
+    }
+    if (this.closed) return
+    const delay = Math.min(
+      this.reconnect.maxDelayMs,
+      this.reconnect.initialDelayMs * 2 ** Math.min(this.attempt++, 5),
+    )
+    this.reconnectTimer = setTimeout(() => this.connect(), delay)
+    this.reconnectTimer.unref?.()
+  }
+
+  close() {
+    this.closed = true
+    clearTimeout(this.reconnectTimer)
+    try {
+      this.socket?.destroy()
+    } catch {
+      /* ignore */
+    }
+    this.socket = null
+  }
+}

package/src/net/relay-server.js

@@ -0,0 +1,366 @@
+// Self-hosted relay for fleet devices behind NAT (v2).
+//
+// Control plane: TCP with newline-delimited JSON.
+//   register -> register.ok
+//   connect(reqId,target) -> connect.pending; target gets incoming(reqId,from)
+//   accept/reject on the target side -> connect.ready (both sides, with data token)
+// Data plane: a second TCP listener. Each side connects with a one-line header
+//   {fleetId, deviceId, reqId, token}\n
+// and the relay splices the two raw sockets together. Payload bytes are the
+// end-to-end encrypted frames from secure-channel.js, so the relay cannot read them.
+import { randomBytes } from 'node:crypto'
+import { EventEmitter } from 'node:events'
+import net from 'node:net'
+import { verifyRelayAuthToken } from './identity.js'
+
+const MAX_CONTROL_LINE = 64 * 1024
+const MAX_CLOCK_SKEW_MS = 120_000
+const ACCEPT_TIMEOUT_MS = 20_000
+const PAIR_TIMEOUT_MS = 20_000
+
+function randomToken() {
+  return randomBytes(24).toString('base64url')
+}
+
+function normalizeFleets(fleets) {
+  const map = new Map()
+  if (fleets instanceof Map) {
+    for (const [fleetId, key] of fleets) map.set(fleetId, key)
+    return map
+  }
+  for (const [fleetId, key] of Object.entries(fleets ?? {})) map.set(fleetId, key)
+  return map
+}
+
+function listen(server, port, host) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off('listening', onListening)
+      reject(error)
+    }
+    const onListening = () => {
+      server.off('error', onError)
+      const address = server.address()
+      resolve(address?.port ?? port)
+    }
+    server.once('error', onError)
+    server.once('listening', onListening)
+    server.listen(port, host)
+  })
+}
+
+/**
+ * @param {{host?: string, port?: number, dataHost?: string, dataPort?: number, fleets?: Record<string,string>|Map<string,string>}} [options]
+ */
+export function createRelayServer({
+  host = '127.0.0.1',
+  dataHost = host,
+  port = 0,
+  dataPort = 0,
+  fleets = {},
+} = {}) {
+  const fleetKeys = normalizeFleets(fleets)
+  if (fleetKeys.size === 0) throw new Error('relay needs at least one fleet key')
+  const relay = new EventEmitter()
+  /** @type {Map<string, {deviceId: string, fleetId: string, socket: net.Socket}>} */
+  const devices = new Map()
+  /** @type {Map<string, any>} */
+  const pending = new Map()
+  const state = { port: null, dataPort: null, closed: false }
+  const trackedSockets = new Set()
+
+  const send = (socket, message) => {
+    if (!socket || socket.destroyed || !socket.writable) return
+    try {
+      socket.write(JSON.stringify(message) + '\n')
+    } catch {
+      /* socket is going away */
+    }
+  }
+
+  const cleanupPending = (reqId, reason, notify = true) => {
+    const entry = pending.get(reqId)
+    if (!entry) return
+    pending.delete(reqId)
+    clearTimeout(entry.acceptTimer)
+    clearTimeout(entry.pairTimer)
+    for (const socket of Object.values(entry.sockets ?? {})) {
+      try {
+        socket.destroy()
+      } catch {
+        /* ignore */
+      }
+    }
+    if (!notify) return
+    const fromDevice = devices.get(entry.fromDeviceId)
+    const targetDevice = devices.get(entry.targetDeviceId)
+    send(fromDevice?.socket, { t: 'connect.fail', reqId, reason })
+    send(targetDevice?.socket, { t: 'connect.fail', reqId, reason })
+  }
+
+  const removeDevice = (deviceId, socket) => {
+    const record = devices.get(deviceId)
+    if (!record || record.socket !== socket) return
+    devices.delete(deviceId)
+    for (const [reqId, entry] of pending) {
+      if (entry.fromDeviceId === deviceId || entry.targetDeviceId === deviceId) {
+        cleanupPending(reqId, 'peer-offline')
+      }
+    }
+  }
+
+  const handleControlLine = (conn, line) => {
+    let message
+    try {
+      message = JSON.parse(line)
+    } catch {
+      send(conn.socket, { t: 'error', code: 'bad-json' })
+      return
+    }
+    switch (message?.t) {
+      case 'register': {
+        const { fleetId, deviceId, ts, token } = message
+        if (typeof fleetId !== 'string' || typeof deviceId !== 'string') {
+          send(conn.socket, { t: 'error', code: 'bad-register' })
+          return
+        }
+        const fleetKey = fleetKeys.get(fleetId)
+        if (!fleetKey) {
+          send(conn.socket, { t: 'error', code: 'unknown-fleet' })
+          conn.socket.destroy()
+          return
+        }
+        if (typeof ts !== 'number' || Math.abs(Date.now() - ts) > MAX_CLOCK_SKEW_MS) {
+          send(conn.socket, { t: 'error', code: 'stale-token' })
+          conn.socket.destroy()
+          return
+        }
+        if (!verifyRelayAuthToken(token, { fleetKey, fleetId, deviceId, ts })) {
+          send(conn.socket, { t: 'error', code: 'unauthorized' })
+          conn.socket.destroy()
+          return
+        }
+        const previous = devices.get(deviceId)
+        if (previous && previous.socket !== conn.socket) {
+          send(previous.socket, { t: 'error', code: 'replaced' })
+          previous.socket.destroy()
+        }
+        devices.set(deviceId, { deviceId, fleetId, socket: conn.socket })
+        conn.registered = { deviceId, fleetId }
+        send(conn.socket, { t: 'register.ok', deviceId, server: 'dsh-device-fleet-relay', v: 1 })
+        return
+      }
+      case 'ping': {
+        send(conn.socket, { t: 'pong' })
+        return
+      }
+      case 'connect': {
+        if (!conn.registered) {
+          send(conn.socket, { t: 'connect.fail', reqId: message.reqId, reason: 'not-registered' })
+          return
+        }
+        const { reqId, targetDeviceId } = message
+        if (typeof reqId !== 'string' || typeof targetDeviceId !== 'string') {
+          send(conn.socket, { t: 'connect.fail', reqId: message.reqId, reason: 'bad-request' })
+          return
+        }
+        const target = devices.get(targetDeviceId)
+        if (!target || target.fleetId !== conn.registered.fleetId || target.socket === conn.socket) {
+          send(conn.socket, { t: 'connect.fail', reqId, reason: 'offline' })
+          return
+        }
+        if (pending.has(reqId)) {
+          send(conn.socket, { t: 'connect.fail', reqId, reason: 'duplicate-request' })
+          return
+        }
+        const entry = {
+          reqId,
+          fleetId: conn.registered.fleetId,
+          fromDeviceId: conn.registered.deviceId,
+          targetDeviceId,
+          sockets: {},
+          tokens: null,
+          accepted: false,
+          acceptTimer: setTimeout(() => cleanupPending(reqId, 'accept-timeout'), ACCEPT_TIMEOUT_MS),
+          pairTimer: null,
+        }
+        entry.acceptTimer.unref?.()
+        pending.set(reqId, entry)
+        send(target.socket, { t: 'incoming', reqId, fromDeviceId: entry.fromDeviceId })
+        send(conn.socket, { t: 'connect.pending', reqId })
+        return
+      }
+      case 'accept': {
+        if (!conn.registered) return
+        const entry = pending.get(message.reqId)
+        if (!entry || entry.targetDeviceId !== conn.registered.deviceId) {
+          send(conn.socket, { t: 'error', code: 'unknown-request', reqId: message.reqId })
+          return
+        }
+        if (entry.accepted) return
+        entry.accepted = true
+        clearTimeout(entry.acceptTimer)
+        entry.tokens = { [entry.fromDeviceId]: randomToken(), [entry.targetDeviceId]: randomToken() }
+        entry.pairTimer = setTimeout(() => cleanupPending(entry.reqId, 'data-timeout'), PAIR_TIMEOUT_MS)
+        entry.pairTimer.unref?.()
+        const from = devices.get(entry.fromDeviceId)
+        const target = devices.get(entry.targetDeviceId)
+        send(from?.socket, { t: 'connect.ready', reqId: entry.reqId, dataPort: state.dataPort, token: entry.tokens[entry.fromDeviceId] })
+        send(target?.socket, { t: 'connect.ready', reqId: entry.reqId, dataPort: state.dataPort, token: entry.tokens[entry.targetDeviceId] })
+        return
+      }
+      case 'reject': {
+        const entry = pending.get(message.reqId)
+        if (!entry || entry.targetDeviceId !== conn.registered?.deviceId) return
+        cleanupPending(entry.reqId, 'rejected')
+        return
+      }
+      default:
+        send(conn.socket, { t: 'error', code: 'unknown-message' })
+    }
+  }
+
+  const onControlSocket = (socket) => {
+    trackedSockets.add(socket)
+    socket.setNoDelay?.(true)
+    const conn = { socket, registered: null, buffer: '' }
+    socket.on('data', (chunk) => {
+      conn.buffer += chunk.toString('utf8')
+      if (conn.buffer.length > MAX_CONTROL_LINE * 8) {
+        socket.destroy()
+        return
+      }
+      let newline = conn.buffer.indexOf('\n')
+      while (newline >= 0) {
+        const line = conn.buffer.slice(0, newline)
+        conn.buffer = conn.buffer.slice(newline + 1)
+        if (line.trim() !== '') handleControlLine(conn, line)
+        newline = conn.buffer.indexOf('\n')
+      }
+    })
+    socket.on('error', () => {})
+    socket.on('close', () => {
+      trackedSockets.delete(socket)
+      if (conn.registered) removeDevice(conn.registered.deviceId, socket)
+    })
+  }
+
+  const pairDataSockets = (reqId) => {
+    const entry = pending.get(reqId)
+    if (!entry) return
+    const entries = Object.entries(entry.sockets)
+    if (entries.length !== 2) return
+    pending.delete(reqId)
+    clearTimeout(entry.pairTimer)
+    clearTimeout(entry.acceptTimer)
+    const [[sideA, socketA], [sideB, socketB]] = entries
+    for (const socket of [socketA, socketB]) trackedSockets.delete(socket)
+    const destroyBoth = () => {
+      for (const socket of [socketA, socketB]) {
+        try {
+          socket.destroy()
+        } catch {
+          /* ignore */
+        }
+      }
+    }
+    socketA.on('error', destroyBoth)
+    socketB.on('error', destroyBoth)
+    socketA.on('close', () => socketB.destroy())
+    socketB.on('close', () => socketA.destroy())
+    socketA.pipe(socketB)
+    socketB.pipe(socketA)
+    socketA.resume()
+    socketB.resume()
+    relay.emit('spliced', {
+      reqId,
+      fleetId: entry.fleetId,
+      fromDeviceId: entry.fromDeviceId,
+      targetDeviceId: entry.targetDeviceId,
+      sides: [sideA, sideB],
+    })
+  }
+
+  const onDataSocket = (socket) => {
+    trackedSockets.add(socket)
+    socket.setNoDelay?.(true)
+    let headerBuffer = Buffer.alloc(0)
+    const onData = (chunk) => {
+      headerBuffer = Buffer.concat([headerBuffer, chunk])
+      const newline = headerBuffer.indexOf(0x0a)
+      if (newline < 0) {
+        if (headerBuffer.length > MAX_CONTROL_LINE) socket.destroy()
+        return
+      }
+      socket.off('data', onData)
+      let header
+      try {
+        header = JSON.parse(headerBuffer.subarray(0, newline).toString('utf8'))
+      } catch {
+        socket.destroy()
+        return
+      }
+      const leftover = headerBuffer.subarray(newline + 1)
+      const entry = pending.get(header?.reqId)
+      if (!entry || !entry.tokens) {
+        socket.destroy()
+        return
+      }
+      const side =
+        header.deviceId === entry.fromDeviceId ? entry.fromDeviceId : header.deviceId === entry.targetDeviceId ? entry.targetDeviceId : null
+      if (!side || header.fleetId !== entry.fleetId || header.token !== entry.tokens[side]) {
+        socket.destroy()
+        return
+      }
+      if (entry.sockets[side]) {
+        socket.destroy()
+        return
+      }
+      socket.pause()
+      entry.sockets[side] = socket
+      if (leftover.length > 0) socket.unshift(leftover)
+      pairDataSockets(entry.reqId)
+    }
+    socket.on('data', onData)
+    socket.once('close', () => {
+      trackedSockets.delete(socket)
+      for (const [reqId, entry] of pending) {
+        if (entry.sockets && Object.values(entry.sockets).includes(socket)) cleanupPending(reqId, 'data-closed')
+      }
+    })
+    socket.on('error', () => {})
+  }
+
+  const controlServer = net.createServer(onControlSocket)
+  const dataServer = net.createServer(onDataSocket)
+
+  const ready = (async () => {
+    state.dataPort = await listen(dataServer, dataPort, dataHost)
+    state.port = await listen(controlServer, port, host)
+    return { port: state.port, dataPort: state.dataPort }
+  })()
+  ready.catch(() => {})
+
+  return {
+    ready,
+    state,
+    on: relay.on.bind(relay),
+    once: relay.once.bind(relay),
+    close: async () => {
+      if (state.closed) return
+      state.closed = true
+      for (const [reqId] of pending) cleanupPending(reqId, 'server-closing', false)
+      for (const socket of trackedSockets) {
+        try {
+          socket.destroy()
+        } catch {
+          /* ignore */
+        }
+      }
+      await Promise.all([
+        new Promise((resolve) => (controlServer.listening ? controlServer.close(() => resolve()) : resolve())),
+        new Promise((resolve) => (dataServer.listening ? dataServer.close(() => resolve()) : resolve())),
+      ])
+    },
+  }
+}