livedesk 0.1.0 → 0.1.1

package/hub/src/server.js

@@ -0,0 +1,724 @@
+#!/usr/bin/env node
+
+import cors from 'cors';
+import express from 'express';
+import crypto from 'node:crypto';
+import { createServer } from 'node:http';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { WebSocketServer } from 'ws';
+import { createRemoteHub } from './remote-hub.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const webDistCandidates = [
+  process.env.LIVEDESK_WEB_DIST,
+  resolve(__dirname, '..', 'web', 'dist'),
+  resolve(__dirname, '..', '..', '..', 'apps', 'web', 'dist')
+].filter(Boolean);
+const webDistPath = webDistCandidates.find(candidate => existsSync(resolve(candidate, 'index.html'))) || webDistCandidates[webDistCandidates.length - 1];
+const webIndexPath = resolve(webDistPath, 'index.html');
+const packageInfo = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf8'));
+const httpHost = process.env.LIVEDESK_HUB_HTTP_HOST || '0.0.0.0';
+const httpPort = Number(process.env.LIVEDESK_HUB_HTTP_PORT || process.env.PORT || 5179);
+const frameClients = new Set();
+const inputClients = new Set();
+const audioClients = new Set();
+let frameClientSeq = 0;
+let inputClientSeq = 0;
+let audioClientSeq = 0;
+
+const remoteHub = createRemoteHub({
+  managerPackage: '@livedesk/hub',
+  managerVersion: packageInfo.version,
+  env: {
+    ...process.env,
+    MINDEXEC_MANAGER_PACKAGE: '@livedesk/hub',
+    MINDEXEC_MANAGER_VERSION: packageInfo.version
+  },
+  logEvent: (_scope, message) => console.log(`[LiveDesk Hub] ${message}`),
+  logWarn: (_scope, message) => console.warn(`[LiveDesk Hub] ${message}`),
+  emitFrame: broadcastRemoteBinaryFrame,
+  emitAudio: broadcastRemoteBinaryAudio
+});
+
+const app = express();
+const httpServer = createServer(app);
+const frameWss = new WebSocketServer({ noServer: true });
+const inputWss = new WebSocketServer({ noServer: true });
+const audioWss = new WebSocketServer({ noServer: true });
+
+app.use((req, res, next) => {
+  if (req.headers.origin) {
+    res.setHeader('Access-Control-Allow-Private-Network', 'true');
+    res.setHeader('Vary', 'Origin, Access-Control-Request-Headers, Access-Control-Request-Private-Network');
+  }
+  next();
+});
+
+app.use(cors({
+  origin: true,
+  credentials: false,
+  methods: ['GET', 'POST', 'DELETE', 'OPTIONS'],
+  allowedHeaders: ['Content-Type']
+}));
+app.use(express.json({ limit: '32mb' }));
+
+const MAX_FILE_TRANSFER_FILES = 24;
+const MAX_FILE_TRANSFER_BYTES = 24 * 1024 * 1024;
+
+function noStore(res) {
+  res.setHeader('Cache-Control', 'no-store');
+}
+
+function clampNumber(value, min, max, fallback) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) {
+    return fallback;
+  }
+  return Math.max(min, Math.min(max, Math.round(number)));
+}
+
+function normalizeDeviceIds(value) {
+  const raw = Array.isArray(value)
+    ? value
+    : String(value || '').split(',');
+  const ids = [];
+  const seen = new Set();
+  for (const entry of raw) {
+    const id = String(entry || '').trim();
+    if (!id || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    ids.push(id);
+    if (ids.length >= 240) {
+      break;
+    }
+  }
+  return ids;
+}
+
+function normalizeTransferFiles(value) {
+  const rawFiles = Array.isArray(value) ? value : [];
+  const files = [];
+  let totalBytes = 0;
+  for (const entry of rawFiles.slice(0, MAX_FILE_TRANSFER_FILES)) {
+    const dataBase64 = String(entry?.dataBase64 || '').replace(/^data:[^,]*,/i, '').trim();
+    const name = String(entry?.name || '').replace(/[\r\n\t\0]/g, ' ').trim().slice(0, 240);
+    const relativePath = String(entry?.relativePath || name).replace(/[\r\n\t\0]/g, ' ').trim().slice(0, 600);
+    const size = Number(entry?.size);
+    const byteLength = Number.isFinite(size) && size >= 0
+      ? Math.floor(size)
+      : Math.floor(dataBase64.length * 3 / 4);
+    if (!name || !dataBase64 || byteLength < 0) {
+      continue;
+    }
+    totalBytes += byteLength;
+    if (totalBytes > MAX_FILE_TRANSFER_BYTES) {
+      return { ok: false, error: 'file-transfer-too-large', files: [], totalBytes };
+    }
+    files.push({
+      name,
+      relativePath,
+      size: byteLength,
+      mimeType: String(entry?.type || entry?.mimeType || '').slice(0, 160),
+      lastModified: Number(entry?.lastModified || 0) || 0,
+      dataBase64
+    });
+  }
+  if (files.length === 0) {
+    return { ok: false, error: 'no-files', files: [], totalBytes: 0 };
+  }
+  return { ok: true, files, totalBytes };
+}
+
+function normalizeLiveOptions(payload = {}) {
+  const mode = String(payload.frameMode || payload.mode || 'remote-fast').trim() || 'remote-fast';
+  return {
+    fps: clampNumber(payload.fps, 1, 24, 12),
+    maxWidth: clampNumber(payload.maxWidth, 320, 2560, 960),
+    maxHeight: clampNumber(payload.maxHeight, 180, 1440, 540),
+    quality: clampNumber(payload.quality, 20, 95, 60),
+    mode,
+    frameMode: mode
+  };
+}
+
+function sendJson(ws, payload) {
+  if (!ws || ws.readyState !== 1) {
+    return false;
+  }
+  ws.send(JSON.stringify(payload));
+  return true;
+}
+
+function updateFrameSubscription(ws, payload = {}) {
+  const deviceIds = normalizeDeviceIds(payload.deviceIds ?? payload.devices ?? payload.deviceId);
+  ws.liveDeskDeviceIds = new Set(deviceIds);
+  ws.liveDeskAutoStart = /^(1|true|yes|on|live)$/i.test(String(payload.autoStartLive ?? payload.startLive ?? ''));
+  ws.liveDeskLiveOptions = normalizeLiveOptions(payload);
+  sendJson(ws, {
+    type: 'RemoteFrameSubscription',
+    timestamp: new Date().toISOString(),
+    deviceIds,
+    autoStartLive: ws.liveDeskAutoStart
+  });
+
+  if (ws.liveDeskAutoStart && deviceIds.length > 0) {
+    const lookup = new Map(remoteHub.listDevices({ includeDataUrl: false }).map(device => [device.deviceId, device]));
+    const started = [];
+    const skipped = [];
+    for (const deviceId of deviceIds.slice(0, 80)) {
+      const device = lookup.get(deviceId);
+      const liveCapable = device?.liveStreamEnabled === true
+        || device?.liveStreamCapable === true
+        || device?.capabilities?.liveStream === true
+        || device?.capabilities?.stream === true
+        || device?.capabilities?.screenStream === true;
+      if (!device?.connected || !liveCapable) {
+        skipped.push({ deviceId, reason: device?.connected ? 'live-unavailable' : 'not-connected' });
+        continue;
+      }
+      const result = remoteHub.startLiveStream(deviceId, {
+        ...ws.liveDeskLiveOptions,
+        streamId: `livedesk-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
+      });
+      if (result?.ok) {
+        started.push({ deviceId, streamId: result.streamId, fps: result.fps });
+      } else {
+        skipped.push({ deviceId, reason: result?.error || 'start-failed' });
+      }
+    }
+    sendJson(ws, {
+      type: 'RemoteFrameLiveAutoStart',
+      timestamp: new Date().toISOString(),
+      started,
+      skipped: skipped.slice(0, 24)
+    });
+  }
+}
+
+function updateAudioSubscription(ws, payload = {}) {
+  const deviceIds = normalizeDeviceIds(payload.deviceIds ?? payload.devices ?? payload.deviceId);
+  ws.liveDeskAudioDeviceIds = new Set(deviceIds);
+  sendJson(ws, {
+    type: 'RemoteAudioSubscription',
+    timestamp: new Date().toISOString(),
+    deviceIds
+  });
+}
+
+function buildRemoteFrameBinaryPacket(frameEvent) {
+  const payload = frameEvent?.payload;
+  if (!Buffer.isBuffer(payload) || payload.length === 0) {
+    return null;
+  }
+  const frame = frameEvent.frame || {};
+  const metadata = {
+    type: 'remote.frame.binary',
+    kind: frameEvent.kind || 'live',
+    deviceId: frameEvent.deviceId || frame.deviceId || '',
+    frameSeq: Number(frame.frameSeq || 0) || 0,
+    streamId: frame.streamId || '',
+    width: Number(frame.width || 0) || 0,
+    height: Number(frame.height || 0) || 0,
+    mimeType: frameEvent.mimeType || frame.mimeType || frame.format || 'image/jpeg',
+    mode: frame.mode || '',
+    frameMode: frame.frameMode || frame.mode || '',
+    frameProfile: frame.frameProfile || '',
+    encoding: frame.encoding || '',
+    codec: frame.codec || '',
+    compression: frame.compression || frame.mimeType || frame.format || '',
+    fps: Number(frame.fps || 0) || 0,
+    capturedAt: frame.capturedAt || '',
+    receivedAt: frame.receivedAt || '',
+    byteLength: Number(frameEvent.byteLength || payload.length) || payload.length,
+    contentHash: frame.contentHash || '',
+    captureMs: Number(frame.captureMs || 0) || 0,
+    sameContentStreak: Number(frame.sameContentStreak || 0) || 0
+  };
+  const metaBuffer = Buffer.from(JSON.stringify(metadata), 'utf8');
+  const header = Buffer.allocUnsafe(4);
+  header.writeUInt32BE(metaBuffer.length, 0);
+  return Buffer.concat([header, metaBuffer, payload], 4 + metaBuffer.length + payload.length);
+}
+
+function buildRemoteAudioBinaryPacket(audioEvent) {
+  const payload = audioEvent?.payload;
+  if (!Buffer.isBuffer(payload) || payload.length === 0) {
+    return null;
+  }
+  const frame = audioEvent.frame || {};
+  const metadata = {
+    type: 'remote.audio.binary',
+    deviceId: audioEvent.deviceId || frame.deviceId || '',
+    frameSeq: Number(frame.frameSeq || 0) || 0,
+    streamId: frame.streamId || '',
+    mimeType: audioEvent.mimeType || frame.mimeType || frame.format || 'audio/webm;codecs=opus',
+    sampleRate: Number(frame.sampleRate || 0) || 48000,
+    channels: Number(frame.channels || 0) || 2,
+    capturedAt: frame.capturedAt || '',
+    receivedAt: frame.receivedAt || '',
+    byteLength: Number(audioEvent.byteLength || payload.length) || payload.length
+  };
+  const metaBuffer = Buffer.from(JSON.stringify(metadata), 'utf8');
+  const header = Buffer.allocUnsafe(4);
+  header.writeUInt32BE(metaBuffer.length, 0);
+  return Buffer.concat([header, metaBuffer, payload], 4 + metaBuffer.length + payload.length);
+}
+
+function broadcastRemoteBinaryFrame(frameEvent) {
+  const deviceId = String(frameEvent?.deviceId || frameEvent?.frame?.deviceId || '').trim();
+  if (!deviceId || frameClients.size === 0) {
+    return;
+  }
+  const packet = buildRemoteFrameBinaryPacket(frameEvent);
+  if (!packet) {
+    return;
+  }
+  for (const client of frameClients) {
+    if (client.readyState !== client.OPEN) {
+      continue;
+    }
+    if (client.liveDeskDeviceIds?.size > 0 && !client.liveDeskDeviceIds.has(deviceId)) {
+      continue;
+    }
+    if (client.bufferedAmount > 8 * 1024 * 1024) {
+      continue;
+    }
+    client.send(packet, { binary: true });
+  }
+}
+
+function broadcastRemoteBinaryAudio(audioEvent) {
+  const deviceId = String(audioEvent?.deviceId || audioEvent?.frame?.deviceId || '').trim();
+  if (!deviceId || audioClients.size === 0) {
+    return;
+  }
+  const packet = buildRemoteAudioBinaryPacket(audioEvent);
+  if (!packet) {
+    return;
+  }
+  for (const client of audioClients) {
+    if (client.readyState !== client.OPEN) {
+      continue;
+    }
+    if (client.liveDeskAudioDeviceIds?.size > 0 && !client.liveDeskAudioDeviceIds.has(deviceId)) {
+      continue;
+    }
+    if (client.bufferedAmount > 2 * 1024 * 1024) {
+      continue;
+    }
+    client.send(packet, { binary: true });
+  }
+}
+
+function wantsBinaryFrame(req) {
+  return /^(1|true|yes|on|binary|raw)$/i.test(String(req.query?.binary ?? req.query?.raw ?? ''))
+    || /image\//i.test(String(req.headers.accept || ''));
+}
+
+function sendFrameBinary(req, res, kind) {
+  const payload = remoteHub.getFramePayload(req.params.deviceId, kind, {
+    token: req.query?.token,
+    frameSeq: req.query?.seq,
+    requireToken: false
+  });
+  if (!payload) {
+    res.status(404).json({ ok: false, error: 'frame-payload-not-available' });
+    return;
+  }
+  noStore(res);
+  res.setHeader('Content-Type', payload.mimeType);
+  res.setHeader('Content-Length', String(payload.byteLength));
+  res.send(payload.payload);
+}
+
+function isCapabilityEnabled(device, key) {
+  const value = device?.capabilities?.[key];
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  return /^(1|true|yes|on)$/i.test(String(value || '').trim());
+}
+
+app.get('/api/health', (_req, res) => {
+  noStore(res);
+  res.json({ ok: true, product: 'LiveDesk', timestamp: new Date().toISOString() });
+});
+
+app.get('/api/remote/status', (_req, res) => {
+  noStore(res);
+  res.json({
+    ...remoteHub.getStatus({ includeSecrets: true }),
+    product: 'LiveDesk',
+    agentPackage: '@livedesk/client'
+  });
+});
+
+app.get('/api/remote/devices', (req, res) => {
+  noStore(res);
+  const includeDataUrl = /^(1|true|yes|on|data|base64)$/i.test(String(req.query?.includeDataUrl ?? ''));
+  const devices = remoteHub.listDevices({ includeDataUrl });
+  res.json({
+    total: devices.length,
+    pagination: 'none',
+    latestTaskBatch: remoteHub.getLatestTaskBatch(),
+    recentTaskBatches: remoteHub.listTaskBatches(),
+    devices
+  });
+});
+
+app.post('/api/remote/frames', (req, res) => {
+  noStore(res);
+  res.json({
+    ok: true,
+    frames: remoteHub.listDeviceFrames({
+      deviceIds: normalizeDeviceIds(req.body?.deviceIds),
+      includeThumbnail: req.body?.includeThumbnail !== false,
+      includeLive: req.body?.includeLive !== false
+    })
+  });
+});
+
+app.post('/api/remote/host-target', async (req, res) => {
+  noStore(res);
+  try {
+    res.json(await remoteHub.setHostTarget({
+      enabled: req.body?.enabled !== false,
+      nodeId: req.body?.nodeId,
+      leaseMs: req.body?.leaseMs,
+      takeover: req.body?.takeover === true
+    }));
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err instanceof Error ? err.message : String(err) });
+  }
+});
+
+app.delete('/api/remote/host-target', async (req, res) => {
+  noStore(res);
+  try {
+    res.json(await remoteHub.setHostTarget({
+      enabled: false,
+      nodeId: req.body?.nodeId
+    }));
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err instanceof Error ? err.message : String(err) });
+  }
+});
+
+app.post('/api/remote/synthetic/seed', (req, res) => {
+  noStore(res);
+  res.json(remoteHub.seedSyntheticFleet({
+    count: req.body?.count,
+    connectedRatio: req.body?.connectedRatio,
+    thumbnailRatio: req.body?.thumbnailRatio,
+    aiAssistRatio: req.body?.aiAssistRatio,
+    liveCount: req.body?.liveCount,
+    replace: req.body?.replace
+  }));
+});
+
+app.delete('/api/remote/synthetic', (_req, res) => {
+  noStore(res);
+  res.json(remoteHub.clearSyntheticFleet());
+});
+
+app.post('/api/remote/devices/:deviceId/disconnect', (req, res) => {
+  noStore(res);
+  res.json({ ok: remoteHub.disconnectDevice(req.params.deviceId, 'manager-request') });
+});
+
+app.post('/api/remote/devices/:deviceId/ping', (req, res) => {
+  noStore(res);
+  res.json(remoteHub.sendCommand(req.params.deviceId, {
+    command: 'ping',
+    payload: { requestedAt: new Date().toISOString() }
+  }));
+});
+
+app.post('/api/remote/devices/:deviceId/input', (req, res) => {
+  noStore(res);
+  res.json(remoteHub.sendInputControl(req.params.deviceId, req.body || {}));
+});
+
+app.post('/api/remote/files/transfer', (req, res) => {
+  noStore(res);
+  const deviceIds = normalizeDeviceIds(req.body?.deviceIds);
+  if (deviceIds.length === 0) {
+    res.status(400).json({ ok: false, error: 'no-target-devices' });
+    return;
+  }
+  const normalized = normalizeTransferFiles(req.body?.files);
+  if (!normalized.ok) {
+    res.status(400).json({ ok: false, error: normalized.error, totalBytes: normalized.totalBytes || 0 });
+    return;
+  }
+  const transferId = String(req.body?.transferId || crypto.randomUUID()).replace(/[^a-zA-Z0-9_.:-]/g, '-').slice(0, 128);
+  const remoteDirectory = String(req.body?.remoteDirectory || '').replace(/[\0\r\n\t]/g, ' ').trim().slice(0, 600);
+  const queuedAt = new Date().toISOString();
+  const results = deviceIds.map(deviceId => ({
+    deviceId,
+    ...remoteHub.sendCommand(deviceId, {
+      command: 'file.transfer',
+      payload: {
+        transferId,
+        remoteDirectory,
+        files: normalized.files,
+        totalBytes: normalized.totalBytes,
+        requestedAt: queuedAt
+      }
+    })
+  }));
+  const queued = results.filter(result => result.ok).length;
+  res.json({
+    ok: queued > 0,
+    transferId,
+    queued,
+    total: deviceIds.length,
+    totalBytes: normalized.totalBytes,
+    files: normalized.files.length,
+    results,
+    error: queued > 0 ? undefined : 'no-transfer-queued'
+  });
+});
+
+app.post('/api/remote/devices/:deviceId/tasks', (req, res) => {
+  noStore(res);
+  res.json(remoteHub.requestAgentTask(req.params.deviceId, {
+    instruction: req.body?.instruction,
+    title: req.body?.title,
+    taskId: req.body?.taskId,
+    commandId: req.body?.commandId,
+    approvalLevel: req.body?.approvalLevel,
+    model: req.body?.model
+  }));
+});
+
+app.post('/api/remote/tasks', (req, res) => {
+  noStore(res);
+  const requestedIds = normalizeDeviceIds(req.body?.deviceIds);
+  const approvalLevel = req.body?.approvalLevel === 'ai-assist' ? 'ai-assist' : 'task-only';
+  const devices = remoteHub.listDevices({ includeDataUrl: false });
+  const targetIds = requestedIds.length > 0
+    ? requestedIds
+    : devices
+      .filter(device => device.connected)
+      .filter(device => approvalLevel !== 'ai-assist' || isCapabilityEnabled(device, 'aiAssist'))
+      .map(device => device.deviceId);
+  const result = remoteHub.requestAgentTaskBatch([...new Set(targetIds)].slice(0, 500), {
+    instruction: req.body?.instruction,
+    title: req.body?.title,
+    approvalLevel,
+    model: req.body?.model,
+    batchId: req.body?.batchId
+  });
+  res.json({
+    ...result,
+    ok: result.ok === true,
+    total: targetIds.length,
+    queued: result.queued || 0,
+    approvalLevel,
+    error: result.ok ? undefined : (targetIds.length === 0 ? 'no-target-devices' : (result.error || 'no-task-queued'))
+  });
+});
+
+app.get('/api/remote/devices/:deviceId/thumbnail', (req, res) => {
+  noStore(res);
+  if (wantsBinaryFrame(req)) {
+    sendFrameBinary(req, res, 'thumbnail');
+    return;
+  }
+  const thumbnail = remoteHub.getDeviceThumbnail(req.params.deviceId, {
+    includeDataUrl: /^(1|true|yes|on|data|base64)$/i.test(String(req.query?.includeDataUrl ?? ''))
+  });
+  if (!thumbnail) {
+    res.status(404).json({ ok: false, error: 'thumbnail-not-available' });
+    return;
+  }
+  res.json({ ok: true, thumbnail });
+});
+
+app.post('/api/remote/devices/:deviceId/thumbnail/request', (req, res) => {
+  noStore(res);
+  res.json(remoteHub.requestThumbnail(req.params.deviceId, req.body || {}));
+});
+
+app.get('/api/remote/devices/:deviceId/live/frame', (req, res) => {
+  noStore(res);
+  if (wantsBinaryFrame(req)) {
+    sendFrameBinary(req, res, 'live');
+    return;
+  }
+  const frame = remoteHub.getDeviceLiveFrame(req.params.deviceId, {
+    includeDataUrl: /^(1|true|yes|on|data|base64)$/i.test(String(req.query?.includeDataUrl ?? ''))
+  });
+  if (!frame) {
+    res.status(404).json({ ok: false, error: 'live-frame-not-available' });
+    return;
+  }
+  res.json({ ok: true, frame });
+});
+
+app.post('/api/remote/devices/:deviceId/live/start', (req, res) => {
+  noStore(res);
+  res.json(remoteHub.startLiveStream(req.params.deviceId, req.body || {}));
+});
+
+app.post('/api/remote/devices/:deviceId/live/stop', (req, res) => {
+  noStore(res);
+  res.json(remoteHub.stopLiveStream(req.params.deviceId, req.body || {}));
+});
+
+app.post('/api/remote/devices/:deviceId/audio/start', (req, res) => {
+  noStore(res);
+  res.json(remoteHub.startAudioStream(req.params.deviceId, req.body || {}));
+});
+
+app.post('/api/remote/devices/:deviceId/audio/stop', (req, res) => {
+  noStore(res);
+  res.json(remoteHub.stopAudioStream(req.params.deviceId, req.body || {}));
+});
+
+if (existsSync(webIndexPath)) {
+  app.use(express.static(webDistPath, {
+    etag: true,
+    index: false,
+    maxAge: '1h'
+  }));
+  app.get('*', (req, res, next) => {
+    if (req.path.startsWith('/api/')) {
+      next();
+      return;
+    }
+    res.sendFile(webIndexPath);
+  });
+}
+
+httpServer.on('upgrade', (req, socket, head) => {
+  try {
+    const parsed = new URL(req.url || '/', `http://${req.headers.host || '127.0.0.1'}`);
+    if (parsed.pathname === '/api/remote/frames/ws') {
+      frameWss.handleUpgrade(req, socket, head, ws => frameWss.emit('connection', ws, req));
+      return;
+    }
+    if (parsed.pathname === '/api/remote/input/ws') {
+      inputWss.handleUpgrade(req, socket, head, ws => inputWss.emit('connection', ws, req));
+      return;
+    }
+    if (parsed.pathname === '/api/remote/audio/ws') {
+      audioWss.handleUpgrade(req, socket, head, ws => audioWss.emit('connection', ws, req));
+      return;
+    }
+    socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+    socket.destroy();
+  } catch {
+    socket.write('HTTP/1.1 400 Bad Request\r\n\r\n');
+    socket.destroy();
+  }
+});
+
+frameWss.on('connection', (ws, req) => {
+  frameClients.add(ws);
+  ws.liveDeskFrameClientId = `rfws-${++frameClientSeq}`;
+  try {
+    const parsed = new URL(req.url || '/', `http://${req.headers.host || '127.0.0.1'}`);
+    updateFrameSubscription(ws, { deviceIds: parsed.searchParams.get('devices') || '' });
+  } catch {
+    updateFrameSubscription(ws, {});
+  }
+  ws.on('message', data => {
+    try {
+      const payload = JSON.parse(Buffer.isBuffer(data) ? data.toString('utf8') : String(data || ''));
+      if (payload?.type === 'subscribe') {
+        updateFrameSubscription(ws, payload);
+      }
+    } catch {
+      sendJson(ws, { type: 'RemoteFrameSubscriptionError', error: 'invalid-message' });
+    }
+  });
+  ws.on('close', () => frameClients.delete(ws));
+  ws.on('error', () => frameClients.delete(ws));
+  sendJson(ws, {
+    type: 'RemoteFrameSocketReady',
+    protocol: 'livedesk.remote.frames.binary.v1',
+    clientId: ws.liveDeskFrameClientId,
+    timestamp: new Date().toISOString()
+  });
+});
+
+audioWss.on('connection', (ws, req) => {
+  audioClients.add(ws);
+  ws.liveDeskAudioClientId = `raws-${++audioClientSeq}`;
+  try {
+    const parsed = new URL(req.url || '/', `http://${req.headers.host || '127.0.0.1'}`);
+    updateAudioSubscription(ws, { deviceIds: parsed.searchParams.get('devices') || '' });
+  } catch {
+    updateAudioSubscription(ws, {});
+  }
+  ws.on('message', data => {
+    try {
+      const payload = JSON.parse(Buffer.isBuffer(data) ? data.toString('utf8') : String(data || ''));
+      if (payload?.type === 'subscribe') {
+        updateAudioSubscription(ws, payload);
+      }
+    } catch {
+      sendJson(ws, { type: 'RemoteAudioSubscriptionError', error: 'invalid-message' });
+    }
+  });
+  ws.on('close', () => audioClients.delete(ws));
+  ws.on('error', () => audioClients.delete(ws));
+  sendJson(ws, {
+    type: 'RemoteAudioSocketReady',
+    protocol: 'livedesk.remote.audio.binary.v1',
+    clientId: ws.liveDeskAudioClientId,
+    timestamp: new Date().toISOString()
+  });
+});
+
+inputWss.on('connection', ws => {
+  inputClients.add(ws);
+  ws.liveDeskInputClientId = `riws-${++inputClientSeq}`;
+  ws.on('message', data => {
+    let payload;
+    try {
+      payload = JSON.parse(Buffer.isBuffer(data) ? data.toString('utf8') : String(data || ''));
+    } catch {
+      sendJson(ws, { type: 'RemoteInputError', error: 'invalid-json' });
+      return;
+    }
+    const deviceId = String(payload?.deviceId || '').trim();
+    const input = payload?.input && typeof payload.input === 'object' ? payload.input : payload;
+    const result = remoteHub.sendInputControl(deviceId, input);
+    sendJson(ws, {
+      type: result?.ok ? 'RemoteInputQueued' : 'RemoteInputError',
+      requestId: payload?.requestId || '',
+      deviceId,
+      result,
+      timestamp: new Date().toISOString()
+    });
+  });
+  ws.on('close', () => inputClients.delete(ws));
+  ws.on('error', () => inputClients.delete(ws));
+  sendJson(ws, {
+    type: 'RemoteInputSocketReady',
+    protocol: 'livedesk.remote.input.json.v1',
+    clientId: ws.liveDeskInputClientId,
+    timestamp: new Date().toISOString()
+  });
+});
+
+await remoteHub.start();
+httpServer.listen(httpPort, httpHost, () => {
+  const status = remoteHub.getStatus({ includeSecrets: true });
+  console.log(`[LiveDesk Hub] HTTP API http://${httpHost}:${httpPort}`);
+  console.log(`[LiveDesk Hub] RemoteHub ${status.agentEndpoint} pair=${status.pairTokenPreview}`);
+});
+
+for (const signal of ['SIGINT', 'SIGTERM']) {
+  process.once(signal, async () => {
+    await remoteHub.close();
+    httpServer.close(() => process.exit(0));
+  });
+}