dsh-device-fleet 0.1.0-dev.3 → 0.1.0-dev.31

package/src/host/ui-web.js

@@ -0,0 +1,139 @@
+// Read/action HTTP surface for the Fleet console: device overview, room list and
+// detail, room user actions, pairing actions, and approval history.
+const MAX_BODY_BYTES = 128 * 1024
+
+function json(res, status, value) {
+  res.statusCode = status
+  res.setHeader('content-type', 'application/json; charset=utf-8')
+  res.setHeader('cache-control', 'no-store')
+  res.end(JSON.stringify(value))
+}
+
+async function readJsonBody(req) {
+  const chunks = []
+  let size = 0
+  for await (const chunk of req) {
+    size += chunk.length
+    if (size > MAX_BODY_BYTES) throw Object.assign(new Error('request body is too large'), { code: 'body-too-large' })
+    chunks.push(chunk)
+  }
+  if (chunks.length === 0) return {}
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+  } catch {
+    throw Object.assign(new Error('request body must be JSON'), { code: 'bad-json' })
+  }
+}
+
+function statusFor(error) {
+  if (error?.code === 'unknown-room') return 404
+  return ['bad-request', 'bad-json', 'body-too-large', 'readonly', 'unknown-member', 'unknown-task'].includes(error?.code)
+    ? 400
+    : 500
+}
+
+function actionRoute(webServer, path, method, run) {
+  return webServer.register({
+    kind: 'exact',
+    path,
+    handler: async (req, res) => {
+      if (req.method !== method) return json(res, 405, { error: 'method not allowed' })
+      try {
+        const body = method === 'POST' ? await readJsonBody(req) : {}
+        json(res, 200, (await run(body, req)) ?? { ok: true })
+      } catch (error) {
+        json(res, statusFor(error), { error: String(error?.message ?? error), code: error?.code ?? 'error' })
+      }
+    },
+  })
+}
+
+/**
+ * @param {object} options
+ * @param {object} options.webServer ctx.webServer
+ * @param {object} options.inbox ApprovalInbox
+ * @param {object} options.rooms RoomService
+ * @param {() => object} options.getOverview
+ * @param {object} [options.actions] UI actions (room send/task/close, pairing)
+ */
+export function registerUiRoutes({ webServer, inbox, rooms, getOverview, actions = null, logger = null }) {
+  if (!webServer?.register || !rooms) return () => {}
+  const disposers = []
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/overview', 'GET', async () => ({
+      ...getOverview(),
+      approvals: inbox?.list?.() ?? [],
+      approvalHistory: inbox?.history?.() ?? [],
+    })),
+  )
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/rooms', 'GET', async () => ({ rooms: rooms.list() })),
+  )
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/room', 'GET', async (_body, req) => {
+      let roomId = ''
+      try {
+        roomId = new URL(req.url ?? '/', 'http://local').searchParams.get('id') ?? ''
+      } catch {
+        roomId = ''
+      }
+      if (roomId === '') throw Object.assign(new Error('room id is required'), { code: 'bad-request' })
+      return { room: rooms.detail(roomId, { limit: 100 }) }
+    }),
+  )
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/room/send', 'POST', async (body) => {
+      if (!actions?.sendRoomMessage) throw Object.assign(new Error('room actions are unavailable'), { code: 'unsupported' })
+      return { ok: true, result: await actions.sendRoomMessage(body ?? {}) }
+    }),
+  )
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/room/task', 'POST', async (body) => {
+      if (!actions?.roomTask) throw Object.assign(new Error('room actions are unavailable'), { code: 'unsupported' })
+      return { ok: true, result: await actions.roomTask(body ?? {}) }
+    }),
+  )
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/room/close', 'POST', async (body) => {
+      if (!actions?.closeRoom) throw Object.assign(new Error('room actions are unavailable'), { code: 'unsupported' })
+      return { ok: true, result: await actions.closeRoom(body ?? {}) }
+    }),
+  )
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/room/member/remove', 'POST', async (body) => {
+      if (!actions?.removeMember) throw Object.assign(new Error('room actions are unavailable'), { code: 'unsupported' })
+      return { ok: true, result: await actions.removeMember(body ?? {}) }
+    }),
+  )
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/room/upgrade', 'POST', async (body) => {
+      if (!actions?.upgradeRoom) throw Object.assign(new Error('room actions are unavailable'), { code: 'unsupported' })
+      return { ok: true, room: await actions.upgradeRoom(body ?? {}) }
+    }),
+  )
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/room/focus', 'POST', async (body) => {
+      if (!actions?.setRoomFocus) throw Object.assign(new Error('room actions are unavailable'), { code: 'unsupported' })
+      return { ok: true, result: actions.setRoomFocus(body ?? {}) }
+    }),
+  )
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/pair/invite', 'POST', async () => {
+      if (!actions?.createInvite) throw Object.assign(new Error('pairing actions are unavailable'), { code: 'unsupported' })
+      return { ok: true, code: await actions.createInvite() }
+    }),
+  )
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/pair/connect', 'POST', async (body) => {
+      if (!actions?.connectAddress) throw Object.assign(new Error('pairing actions are unavailable'), { code: 'unsupported' })
+      return { ok: true, result: await actions.connectAddress(body ?? {}) }
+    }),
+  )
+  disposers.push(
+    actionRoute(webServer, '/device-fleet/approvals/history', 'GET', async () => ({ history: inbox?.history?.() ?? [] })),
+  )
+  if (logger) logger.debug?.('[device-fleet] UI action routes registered')
+  return () => {
+    for (const dispose of disposers) dispose()
+  }
+}

package/src/net/fleet-node.js

@@ -281,6 +281,14 @@ export class FleetNode extends EventEmitter {
       if (current === channel) this.channels.delete(channel.peer.deviceId)
       this.rejectPendingForChannel(channel, Object.assign(new Error('peer connection closed'), { code: 'peer-offline' }))
       this.emit('peer-disconnected', { deviceId: channel.peer?.deviceId, via })
+      // Recover automatically: the peer may have restarted or moved; retry the
+      // known addresses instead of waiting for the next process start.
+      if (!this.closed && this.channels.size === 0 && this.peerHints.length > 0) {
+        clearTimeout(this.hintTimer)
+        this.hintTimer = null
+        this.hintAttempt = 0
+        this.scheduleHintConnects()
+      }
     })
   }
 
@@ -481,6 +489,28 @@ export class FleetNode extends EventEmitter {
     return [...this.channels.keys()]
   }
 
+  /** Apply live network changes without recreating the node or its identity. */
+  async reconfigure({ name, direct, discovery, relay } = {}) {
+    if (this.closed) return
+    if (typeof name === 'string' && name !== '') this.name = name
+    const networkChanged = direct !== undefined || discovery !== undefined || relay !== undefined
+    if (!networkChanged) return
+    const wasStarted = this.started
+    await this.close()
+    this.closed = false
+    this.started = false
+    this.hintAttempt = 0
+    this.discovered.clear()
+    if (direct !== undefined) this.directConfig = direct
+    if (discovery !== undefined) this.discoveryConfig = discovery
+    if (relay !== undefined) this.relayConfig = relay
+    this.directServer = null
+    this.discovery = null
+    this.relayClient = null
+    this.directAddress = null
+    if (wasStarted) await this.start()
+  }
+
   async close() {
     this.closed = true
     clearTimeout(this.hintTimer)