dsh-remote-control-plugin 0.3.5 → 0.4.0

package/host/udp-channel.js

@@ -0,0 +1,176 @@
+import dgram from 'node:dgram'
+import { randomBytes } from 'node:crypto'
+import { buildBindingRequest, parseBindingResponse } from './nat.js'
+
+/**
+ * Minimal reliable datagram channel over UDP, for the punched P2P lane.
+ *
+ * A message is JSON, split into 1200-byte fragments. Each fragment carries
+ * (type, messageId, seq, total); the sender retransmits the whole message on an
+ * interval until the receiver acknowledges it, and the receiver reassembles
+ * fragments and delivers only complete messages. Responses reference the
+ * request's message id via `replyTo`, so a caller can correlate them without a
+ * connection.
+ *
+ * This is a handshake-free, single-peer-ish channel: it is deliberately small
+ * and is not a general transport. Ordering across concurrent messages is not
+ * guaranteed; callers that need it must serialize.
+ */
+
+const MAGIC = Buffer.from('DSHUDP01', 'utf8')
+const TYPE_DATA = 0
+const TYPE_ACK = 1
+const HEADER = 8 + 1 + 4 + 2 + 2
+const MAX_PAYLOAD = 1200
+
+function pack(type, messageId, seq, total, payload) {
+  const buffer = Buffer.alloc(HEADER + payload.length)
+  MAGIC.copy(buffer, 0)
+  buffer.writeUInt8(type, 8)
+  buffer.writeUInt32BE(messageId >>> 0, 9)
+  buffer.writeUInt16BE(seq, 13)
+  buffer.writeUInt16BE(total, 15)
+  payload.copy(buffer, HEADER)
+  return buffer
+}
+
+function unpack(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < HEADER) return undefined
+  if (!buffer.subarray(0, MAGIC.length).equals(MAGIC)) return undefined
+  return {
+    type: buffer.readUInt8(8),
+    messageId: buffer.readUInt32BE(9),
+    seq: buffer.readUInt16BE(13),
+    total: buffer.readUInt16BE(15),
+    payload: buffer.subarray(HEADER),
+  }
+}
+
+export async function createUdpChannel({ handler, intervalMs = 300, timeoutMs = 5000, bindPort = 0 } = {}) {
+  const socket = dgram.createSocket('udp4')
+  await new Promise((resolve, reject) => {
+    socket.once('error', reject)
+    socket.bind(bindPort, resolve)
+  })
+  const port = socket.address().port
+  let nextId = 0
+  const deliveries = new Map() // messageId -> resolve(ok) on ack
+  const responses = new Map() // requestId -> resolve(message)
+  const inbound = new Map() // key -> { parts, total, remote }
+
+  function transmit(remote, message) {
+    const messageId = nextId++
+    const text = Buffer.from(JSON.stringify(message), 'utf8')
+    const total = Math.max(1, Math.ceil(text.length / MAX_PAYLOAD))
+    const chunks = []
+    for (let index = 0; index < total; index += 1) {
+      chunks.push(text.subarray(index * MAX_PAYLOAD, (index + 1) * MAX_PAYLOAD))
+    }
+    const send = () => {
+      chunks.forEach((chunk, seq) => {
+        try { socket.send(pack(TYPE_DATA, messageId, seq, total, chunk), remote.port, remote.address) } catch { /* unreachable */ }
+      })
+    }
+    send()
+    const timer = setInterval(send, intervalMs)
+    timer.unref?.()
+    return new Promise((resolve) => {
+      const deadline = setTimeout(() => { clearInterval(timer); deliveries.delete(messageId); resolve(false) }, timeoutMs)
+      deliveries.set(messageId, () => { clearInterval(timer); clearTimeout(deadline); deliveries.delete(messageId); resolve(true) })
+    })
+  }
+
+  async function request(remote, message) {
+    const responsePromise = new Promise((resolve) => {
+      const requestId = nextId
+      responses.set(requestId, resolve)
+      setTimeout(() => {
+        if (!responses.has(requestId)) return
+        responses.delete(requestId)
+        resolve(undefined)
+      }, timeoutMs).unref?.()
+    })
+    const delivered = await transmit(remote, message)
+    if (!delivered) return { ok: false, error: 'timeout' }
+    const reply = await responsePromise
+    if (!reply) return { ok: false, error: 'no-reply' }
+    return { ok: true, message: reply }
+  }
+
+  /** Fire-and-forget datagram; used for streaming frames where a reply is wrong. */
+  function notify(remote, message) {
+    const messageId = nextId++
+    const text = Buffer.from(JSON.stringify(message), 'utf8')
+    const total = Math.max(1, Math.ceil(text.length / MAX_PAYLOAD))
+    for (let seq = 0; seq < total; seq += 1) {
+      const chunk = text.subarray(seq * MAX_PAYLOAD, (seq + 1) * MAX_PAYLOAD)
+      try { socket.send(pack(TYPE_DATA, messageId, seq, total, chunk), remote.port, remote.address) } catch { /* unreachable */ }
+    }
+  }
+
+  socket.on('message', async (buffer, rinfo) => {
+    const frame = unpack(buffer)
+    if (!frame) return
+    if (frame.type === TYPE_ACK) {
+      deliveries.get(frame.messageId)?.()
+      return
+    }
+    if (frame.type !== TYPE_DATA) return
+    const key = `${frame.messageId}:${rinfo.address}:${rinfo.port}`
+    let entry = inbound.get(key)
+    if (!entry) {
+      entry = { parts: new Array(frame.total), total: frame.total, remote: rinfo }
+      inbound.set(key, entry)
+    }
+    entry.parts[frame.seq] = frame.payload
+    if (entry.parts.filter(Boolean).length < entry.total) return
+    inbound.delete(key)
+    const message = JSON.parse(Buffer.concat(entry.parts).toString('utf8'))
+    try { socket.send(pack(TYPE_ACK, frame.messageId, 0, 0, Buffer.alloc(0)), rinfo.port, rinfo.address) } catch { /* ignore */ }
+    if (typeof message.replyTo === 'number') {
+      const resolve = responses.get(message.replyTo)
+      if (resolve) { responses.delete(message.replyTo); resolve(message) }
+      return
+    }
+    if (typeof handler !== 'function') return
+    try {
+      const reply = await handler(message, rinfo)
+      transmit(rinfo, { ...(reply ?? {}), replyTo: frame.messageId })
+    } catch { /* handler failure drops the request */ }
+  })
+
+  /** Discover this socket's public mapping with STUN, from this very socket. */
+  function stun({ host = 'stun.l.google.com', port = 19302, timeoutMs = 1500 } = {}) {
+    return new Promise((resolve) => {
+      const transactionId = randomBytes(12)
+      const request = buildBindingRequest(transactionId)
+      let settled = false
+      const finish = (value) => {
+        if (settled) return
+        settled = true
+        socket.removeListener('message', onMessage)
+        clearTimeout(timer)
+        resolve(value)
+      }
+      const onMessage = (buffer) => {
+        if (buffer.length >= 20 && buffer.readUInt32BE(4) === 0x2112a442 && buffer.subarray(8, 20).equals(transactionId)) {
+          finish(parseBindingResponse(buffer))
+        }
+      }
+      socket.on('message', onMessage)
+      const timer = setTimeout(() => finish(undefined), timeoutMs)
+      timer.unref?.()
+      try { socket.send(request, 0, request.length, port, host) } catch { finish(undefined) }
+    })
+  }
+
+  return {
+    port,
+    request,
+    notify,
+    stun,
+    close: () => new Promise((resolve) => { try { socket.close(resolve) } catch { resolve() } }),
+  }
+}
+
+export { pack, unpack, TYPE_DATA, TYPE_ACK }

package/host/uploads.js

@@ -0,0 +1,170 @@
+import { randomUUID } from 'node:crypto'
+
+/**
+ * Peer file uploads.
+ *
+ * A remote device never writes a path: it streams base64 chunks to this Host,
+ * and `commit` stores the assembled bytes through the attachment service, the
+ * same store the browser UI uses. State is per-upload, in memory, and bound to
+ * one session; nothing survives a commit except the attachment itself.
+ *
+ * Chunk size stays below the relay's per-message limit: 1 MiB of bytes becomes
+ * ~1.37 MiB of base64, comfortably inside the 2 MB message cap.
+ */
+
+const IMAGE_TYPES = new Set(['image/png', 'image/jpeg', 'image/webp', 'image/gif'])
+const DEFAULT_TYPES = [
+  ...IMAGE_TYPES,
+  'application/pdf',
+  'text/plain',
+  'text/markdown',
+  'application/json',
+  'application/zip',
+  'application/octet-stream',
+]
+
+export function createUploadManager({ getAttachments, limits = {}, log = console } = {}) {
+  const config = {
+    maxFileBytes: limits.maxFileBytes ?? 25 * 1024 * 1024,
+    chunkBytes: limits.chunkBytes ?? 1024 * 1024,
+    sessionQuotaBytes: limits.sessionQuotaBytes ?? 100 * 1024 * 1024,
+    ttlMs: limits.ttlMs ?? 10 * 60 * 1000,
+    allowedTypes: new Set(limits.allowedTypes ?? DEFAULT_TYPES),
+  }
+
+  const uploads = new Map()
+  const usage = new Map() // sessionId -> committed bytes
+
+  const reaper = setInterval(() => {
+    const now = Date.now()
+    for (const [uploadId, upload] of uploads) {
+      if (now - upload.at > config.ttlMs) uploads.delete(uploadId)
+    }
+  }, 60_000)
+  reaper.unref?.()
+
+  const fail = (status, error, message) => ({ status, error, message })
+
+  function sanitizeName(name) {
+    const base = String(name ?? 'file').split(/[\\/]/).pop() || 'file'
+    return base.replace(/[\u0000-\u001f<>:"|?*]/g, '_').trim().slice(0, 120) || 'file'
+  }
+
+  function init(body) {
+    const sessionId = typeof body?.sessionId === 'string' ? body.sessionId : ''
+    if (!sessionId) return fail(400, 'missing-session', 'An upload must name its session.')
+    const size = Number(body?.size)
+    if (!Number.isInteger(size) || size <= 0) return fail(400, 'bad-size', 'size must be a positive integer.')
+    if (size > config.maxFileBytes) {
+      return fail(413, 'too-large', `Files are limited to ${Math.floor(config.maxFileBytes / (1024 * 1024))} MB.`)
+    }
+    const mediaType = typeof body?.mediaType === 'string' ? body.mediaType : 'application/octet-stream'
+    if (!config.allowedTypes.has(mediaType)) return fail(415, 'bad-type', `Unsupported media type: ${mediaType}`)
+    const used = usage.get(sessionId) ?? 0
+    if (used + size > config.sessionQuotaBytes) {
+      return fail(507, 'quota', 'This session has reached its upload quota.')
+    }
+
+    const uploadId = randomUUID()
+    uploads.set(uploadId, {
+      uploadId,
+      sessionId,
+      name: sanitizeName(body?.name),
+      mediaType,
+      size,
+      chunkBytes: config.chunkBytes,
+      chunks: new Map(),
+      at: Date.now(),
+    })
+    return { status: 200, uploadId, chunkSize: config.chunkBytes, maxFileBytes: config.maxFileBytes }
+  }
+
+  function chunk(body) {
+    const upload = uploads.get(String(body?.uploadId ?? ''))
+    if (!upload) return fail(404, 'unknown-upload', 'This upload is unknown or expired.')
+    const index = Number(body?.index)
+    if (!Number.isInteger(index) || index < 0) return fail(400, 'bad-index', 'index must be a non-negative integer.')
+    const encoded = typeof body?.data === 'string' ? body.data : ''
+    if (!encoded) return fail(400, 'empty-chunk', 'Chunk data is required.')
+    let bytes
+    try {
+      bytes = Buffer.from(encoded, 'base64')
+    } catch {
+      return fail(400, 'bad-encoding', 'Chunk data must be base64.')
+    }
+    if (bytes.length > upload.chunkBytes) return fail(413, 'chunk-too-large', 'Chunk exceeds the negotiated size.')
+
+    const previous = upload.chunks.get(index)?.length ?? 0
+    const total = [...upload.chunks.values()].reduce((sum, value) => sum + value.length, 0)
+    if (total - previous + bytes.length > upload.size) {
+      return fail(413, 'exceeds-declared', 'Chunks exceed the declared file size.')
+    }
+
+    upload.chunks.set(index, bytes)
+    upload.at = Date.now()
+    const receivedBytes = [...upload.chunks.values()].reduce((sum, value) => sum + value.length, 0)
+    return { status: 200, received: upload.chunks.size, receivedBytes }
+  }
+
+  function status(body) {
+    const upload = uploads.get(String(body?.uploadId ?? ''))
+    if (!upload) return fail(404, 'unknown-upload', 'This upload is unknown or expired.')
+    return {
+      status: 200,
+      uploadId: upload.uploadId,
+      size: upload.size,
+      chunkSize: upload.chunkBytes,
+      received: [...upload.chunks.keys()].sort((a, b) => a - b),
+      receivedBytes: [...upload.chunks.values()].reduce((sum, value) => sum + value.length, 0),
+    }
+  }
+
+  async function commit(body) {
+    const upload = uploads.get(String(body?.uploadId ?? ''))
+    if (!upload) return fail(404, 'unknown-upload', 'This upload is unknown or expired.')
+    const receivedBytes = [...upload.chunks.values()].reduce((sum, value) => sum + value.length, 0)
+    if (receivedBytes !== upload.size) {
+      return { ...fail(409, 'incomplete', 'Not every chunk arrived.'), receivedBytes, size: upload.size }
+    }
+    const attachments = getAttachments?.()
+    if (!attachments) return fail(503, 'attachments-unavailable', 'This Host has no attachment store.')
+
+    const data = Buffer.concat([...upload.chunks.keys()].sort((a, b) => a - b).map((index) => upload.chunks.get(index)))
+    let attachment
+    let kind
+    try {
+      if (IMAGE_TYPES.has(upload.mediaType)) {
+        attachment = await attachments.saveImage({ data, mediaType: upload.mediaType, name: upload.name })
+        kind = 'image'
+      } else {
+        attachment = await attachments.saveFile({ data, name: upload.name })
+        kind = 'file'
+      }
+    } catch (error) {
+      log.warn?.(`[remote-control] upload commit failed: ${error?.message || error}`)
+      return fail(422, 'store-rejected', `The attachment store refused the file: ${error?.message || error}`)
+    }
+
+    uploads.delete(upload.uploadId)
+    usage.set(upload.sessionId, (usage.get(upload.sessionId) ?? 0) + upload.size)
+    return { status: 200, kind, attachment, sessionId: upload.sessionId, bytes: upload.size }
+  }
+
+  function cancel(body) {
+    const uploadId = String(body?.uploadId ?? '')
+    if (!uploads.has(uploadId)) return fail(404, 'unknown-upload', 'This upload is unknown or expired.')
+    uploads.delete(uploadId)
+    return { status: 200, ok: true }
+  }
+
+  return {
+    init,
+    chunk,
+    status,
+    commit,
+    cancel,
+    limits: config,
+    stats: () => ({ uploads: uploads.size }),
+    close: () => clearInterval(reaper),
+  }
+}