@livedesk/hub 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/hub",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "LiveDesk local Hub API and browser frame bridge",
   "type": "module",
   "main": "src/server.js",

package/src/live-stream-monitor-contract.js

@@ -0,0 +1,38 @@
+export const LIVE_STREAM_MONITOR_INDEX_MIN = 0;
+export const LIVE_STREAM_MONITOR_INDEX_MAX = 63;
+
+export function parseExactLiveStreamMonitorIndex(value) {
+    return typeof value === 'number'
+        && Number.isInteger(value)
+        && value >= LIVE_STREAM_MONITOR_INDEX_MIN
+        && value <= LIVE_STREAM_MONITOR_INDEX_MAX
+        ? value
+        : null;
+}
+
+export function isReusedLiveStreamFrameReady(result, activeStream, expectedBinding) {
+    const expectedMonitorIndex = parseExactLiveStreamMonitorIndex(expectedBinding?.monitorIndex);
+    const activeMonitorIndex = parseExactLiveStreamMonitorIndex(activeStream?.monitorIndex);
+    const latestFrame = activeStream?.latestFrame;
+    const frameMonitorIndex = parseExactLiveStreamMonitorIndex(latestFrame?.monitorIndex);
+    const expectedStreamId = String(expectedBinding?.streamId || '');
+    const expectedCommandId = String(expectedBinding?.commandId || '');
+    const expectedCaptureGeneration = Number(expectedBinding?.captureGeneration || 0);
+
+    return result?.reused === true
+        && result?.ready === true
+        && Number(activeStream?.framesReceived || 0) > 0
+        && !!expectedStreamId
+        && String(activeStream?.streamId || '') === expectedStreamId
+        && !!expectedCommandId
+        && String(activeStream?.commandId || '') === expectedCommandId
+        && Number.isInteger(expectedCaptureGeneration)
+        && expectedCaptureGeneration > 0
+        && Number(activeStream?.captureGeneration || 0) === expectedCaptureGeneration
+        && latestFrame?.currentGenerationVerified === true
+        && String(latestFrame?.commandId || '') === expectedCommandId
+        && Number(latestFrame?.captureGeneration || 0) === expectedCaptureGeneration
+        && expectedMonitorIndex !== null
+        && activeMonitorIndex === expectedMonitorIndex
+        && frameMonitorIndex === expectedMonitorIndex;
+}

package/src/remote-hub.js

@@ -2,6 +2,7 @@ import net from 'net';
 import os from 'os';
 import crypto from 'crypto';
 import { createHubRelayControl } from './transport/relay-hub-control.js';
+import { parseExactLiveStreamMonitorIndex } from './live-stream-monitor-contract.js';
 
 const DEFAULT_REMOTE_HUB_PORT = 5197;
 const DEFAULT_REMOTE_HUB_HOST = '0.0.0.0';
@@ -689,21 +690,39 @@ const SUPPORTED_AGENT_OPERATIONS = new Set([
     'logs.collect'
 ]);
 
-function normalizeAgentOperation(value) {
-    const operation = safeString(value, 80).toLowerCase();
-    return SUPPORTED_AGENT_OPERATIONS.has(operation) ? operation : '';
-}
-
-function normalizeRemoteInputEvent(value = {}) {
-    const input = value && typeof value === 'object' ? value : {};
-    const type = safeString(input.type || input.Type, 48);
+function normalizeAgentOperation(value) {
+    const operation = safeString(value, 80).toLowerCase();
+    return SUPPORTED_AGENT_OPERATIONS.has(operation) ? operation : '';
+}
+
+const REMOTE_INPUT_MONITOR_KEYS = Object.freeze([
+    'monitorIndex',
+    'MonitorIndex',
+    'screenIndex',
+    'ScreenIndex',
+    'displayIndex',
+    'DisplayIndex'
+]);
+
+function readRawRemoteInputMonitorIndex(input) {
+    for (const key of REMOTE_INPUT_MONITOR_KEYS) {
+        if (Object.prototype.hasOwnProperty.call(input, key)) {
+            return input[key];
+        }
+    }
+    return undefined;
+}
+
+function normalizeRemoteInputEvent(value = {}) {
+    const input = value && typeof value === 'object' ? value : {};
+    const type = safeString(input.type || input.Type, 48);
     const normalizedX = Number(input.normalizedX ?? input.NormalizedX);
     const normalizedY = Number(input.normalizedY ?? input.NormalizedY);
     const deltaX = Number(input.deltaX ?? input.DeltaX);
     const deltaY = Number(input.deltaY ?? input.DeltaY);
     const keyCode = Number(input.keyCode ?? input.KeyCode);
     const location = Number(input.location ?? input.Location);
-    const monitorIndex = Number(input.monitorIndex ?? input.MonitorIndex ?? input.screenIndex ?? input.ScreenIndex ?? input.displayIndex ?? input.DisplayIndex);
+    const monitorIndex = parseExactLiveStreamMonitorIndex(readRawRemoteInputMonitorIndex(input));
     const inputSeq = Number(input.inputSeq ?? input.InputSeq);
     const issuedAtEpochMs = Number(input.issuedAtEpochMs ?? input.IssuedAtEpochMs);
     const hubReceivedAtEpochMs = Number(input.hubReceivedAtEpochMs ?? input.HubReceivedAtEpochMs);
@@ -719,7 +738,7 @@ function normalizeRemoteInputEvent(value = {}) {
         type,
         // A missing monitor is not equivalent to the primary display. Control
         // input must prove the exact monitor owned by its capture generation.
-        monitorIndex: Number.isFinite(monitorIndex) ? normalizeMonitorIndex(monitorIndex) : null,
+        monitorIndex,
         normalizedX: Number.isFinite(normalizedX) ? Math.max(0, Math.min(1, normalizedX)) : undefined,
         normalizedY: Number.isFinite(normalizedY) ? Math.max(0, Math.min(1, normalizedY)) : undefined,
         button: safeString(input.button || input.Button, 24),
@@ -3983,6 +4002,34 @@ export function createRemoteHub(options = {}) {
             });
             return null;
         }
+        const pendingMonitorIndex = parseExactLiveStreamMonitorIndex(pending.monitorIndex);
+        const messageMonitorIndex = parseExactLiveStreamMonitorIndex(message.monitorIndex);
+        if (pendingMonitorIndex === null || messageMonitorIndex === null) {
+            emitRemoteEvent('RemoteLiveStreamOpenIgnored', device, {
+                reason: 'invalid-pending-monitor-metadata',
+                streamId: streamState.streamId,
+                commandId,
+                captureGeneration: messageCaptureGeneration,
+                pendingCaptureGeneration,
+                monitorIndex: messageMonitorIndex,
+                pendingMonitorIndex,
+                transport
+            });
+            return null;
+        }
+        if (messageMonitorIndex !== pendingMonitorIndex) {
+            emitRemoteEvent('RemoteLiveStreamOpenIgnored', device, {
+                reason: 'stale-pending-monitor',
+                streamId: streamState.streamId,
+                commandId,
+                captureGeneration: messageCaptureGeneration,
+                pendingCaptureGeneration,
+                monitorIndex: messageMonitorIndex,
+                pendingMonitorIndex,
+                transport
+            });
+            return null;
+        }
 
         const previousCommandId = safeString(streamState.commandId, 128);
         const transfer = buildRemoteFrameTransferDescriptorFromMessage(
@@ -4011,9 +4058,7 @@ export function createRemoteHub(options = {}) {
             height: Number.isFinite(Number(message.height)) ? Number(message.height) : Number(pending.height || 0),
             sourceWidth: Number.isFinite(Number(message.sourceWidth)) ? Number(message.sourceWidth) : Number(pending.sourceWidth || 0),
             sourceHeight: Number.isFinite(Number(message.sourceHeight)) ? Number(message.sourceHeight) : Number(pending.sourceHeight || 0),
-            monitorIndex: Number.isFinite(Number(message.monitorIndex))
-                ? normalizeMonitorIndex(message.monitorIndex)
-                : Number(pending.monitorIndex || 0),
+            monitorIndex: pendingMonitorIndex,
             monitorCount: Number.isFinite(Number(message.monitorCount))
                 ? clampNumber(message.monitorCount, 1, 64, 1)
                 : Number(pending.monitorCount || 1),
@@ -4106,6 +4151,37 @@ export function createRemoteHub(options = {}) {
             return true;
         }
 
+        const activeMonitorIndex = parseExactLiveStreamMonitorIndex(streamState.monitorIndex);
+        const messageMonitorIndex = parseExactLiveStreamMonitorIndex(message.monitorIndex);
+        if (activeMonitorIndex === null || messageMonitorIndex === null) {
+            emitRemoteEvent('RemoteLiveStreamOpenIgnored', device, {
+                reason: 'invalid-live-stream-monitor-metadata',
+                streamId,
+                commandId,
+                activeCommandId,
+                captureGeneration: Number(message.captureGeneration || 0),
+                activeCaptureGeneration: Number(streamState.captureGeneration || 0),
+                monitorIndex: messageMonitorIndex,
+                activeMonitorIndex,
+                transport
+            });
+            return false;
+        }
+        if (messageMonitorIndex !== activeMonitorIndex) {
+            emitRemoteEvent('RemoteLiveStreamOpenIgnored', device, {
+                reason: 'stale-live-stream-monitor',
+                streamId,
+                commandId,
+                activeCommandId,
+                captureGeneration: Number(message.captureGeneration || 0),
+                activeCaptureGeneration: Number(streamState.captureGeneration || 0),
+                monitorIndex: messageMonitorIndex,
+                activeMonitorIndex,
+                transport
+            });
+            return false;
+        }
+
         const transfer = buildRemoteFrameTransferDescriptorFromMessage(message, streamState.mode || DEFAULT_REMOTE_FRAME_MODE);
         const openedAt = safeString(message.openedAt, 80) || device.lastSeenAt || new Date().toISOString();
         const nextStreamState = {
@@ -4126,7 +4202,7 @@ export function createRemoteHub(options = {}) {
             height: Number.isFinite(Number(message.height)) ? Number(message.height) : Number(streamState.height || 0),
             sourceWidth: Number.isFinite(Number(message.sourceWidth)) ? Number(message.sourceWidth) : Number(streamState.sourceWidth || 0),
             sourceHeight: Number.isFinite(Number(message.sourceHeight)) ? Number(message.sourceHeight) : Number(streamState.sourceHeight || 0),
-            monitorIndex: Number.isFinite(Number(message.monitorIndex)) ? normalizeMonitorIndex(message.monitorIndex) : Number(streamState.monitorIndex || 0),
+            monitorIndex: activeMonitorIndex,
             monitorCount: Number.isFinite(Number(message.monitorCount)) ? clampNumber(message.monitorCount, 1, 64, 1) : Number(streamState.monitorCount || 1),
             streamPurpose: safeString(message.streamPurpose || streamState.streamPurpose, 24) || 'wall',
             captureGeneration: Number.isSafeInteger(Number(message.captureGeneration)) && Number(message.captureGeneration) > 0
@@ -4204,8 +4280,40 @@ export function createRemoteHub(options = {}) {
             });
             return false;
         }
-
-        const byteLength = normalizeFrameByteLength(framePayload, frameData);
+        const activeMonitorIndex = parseExactLiveStreamMonitorIndex(streamState.monitorIndex);
+        const frameMonitorIndex = parseExactLiveStreamMonitorIndex(message.monitorIndex);
+        if (activeMonitorIndex === null || frameMonitorIndex === null) {
+            device.counters.liveFramesDropped += 1;
+            emitRemoteEvent('RemoteFrameDropped', device, {
+                reason: 'invalid-live-stream-monitor-frame-metadata',
+                streamId,
+                commandId,
+                captureGeneration: frameCaptureGeneration,
+                activeCaptureGeneration,
+                monitorIndex: frameMonitorIndex,
+                activeMonitorIndex,
+                frameSeq: Number.isFinite(frameSeq) ? frameSeq : null,
+                transport
+            });
+            return false;
+        }
+        if (frameMonitorIndex !== activeMonitorIndex) {
+            device.counters.liveFramesDropped += 1;
+            emitRemoteEvent('RemoteFrameDropped', device, {
+                reason: 'stale-live-stream-monitor-frame',
+                streamId,
+                commandId,
+                captureGeneration: frameCaptureGeneration,
+                activeCaptureGeneration,
+                monitorIndex: frameMonitorIndex,
+                activeMonitorIndex,
+                frameSeq: Number.isFinite(frameSeq) ? frameSeq : null,
+                transport
+            });
+            return false;
+        }
+
+        const byteLength = normalizeFrameByteLength(framePayload, frameData);
         if ((!Buffer.isBuffer(framePayload) && !frameData)
             || byteLength > MAX_STREAM_BINARY_BYTES
             || !Number.isFinite(frameSeq)) {
@@ -4242,7 +4350,8 @@ export function createRemoteHub(options = {}) {
         const currentGenerationVerified = (!activeCommandId || commandId === activeCommandId)
             && (activeCaptureGeneration <= 0
                 || (frameCaptureGeneration > 0
-                    && frameCaptureGeneration === activeCaptureGeneration));
+                    && frameCaptureGeneration === activeCaptureGeneration))
+            && frameMonitorIndex === activeMonitorIndex;
         const readyFrameReceivedBeforeFrame = streamState.readyFrameReceived === true;
         const captureTimingAvailable = hasFrameCaptureTiming(message);
         const videoTransport = transport === 'udp-p2p'
@@ -4323,7 +4432,7 @@ export function createRemoteHub(options = {}) {
             udpIncompleteFrames: Number.isFinite(Number(message.udpIncompleteFrames)) ? Number(message.udpIncompleteFrames) : 0,
             hardwareEncoder: safeString(message.hardwareEncoder, 80),
             platformProfile: safeString(message.platformProfile, 80),
-            monitorIndex: Number.isFinite(Number(message.monitorIndex)) ? normalizeMonitorIndex(message.monitorIndex) : Number(streamState.monitorIndex || 0),
+            monitorIndex: activeMonitorIndex,
             monitorCount: Number.isFinite(Number(message.monitorCount)) ? clampNumber(message.monitorCount, 1, 64, 1) : Number(streamState.monitorCount || 1),
             transferProtocol: transfer.transferProtocol,
             transferProtocolVersion: transfer.transferProtocolVersion,
@@ -4402,7 +4511,6 @@ export function createRemoteHub(options = {}) {
         streamState.height = device.latestLiveFrame.height;
         streamState.sourceWidth = device.latestLiveFrame.sourceWidth;
         streamState.sourceHeight = device.latestLiveFrame.sourceHeight;
-        streamState.monitorIndex = device.latestLiveFrame.monitorIndex;
         streamState.monitorCount = device.latestLiveFrame.monitorCount;
         ensureDeviceLiveStreams(device).set(streamId, streamState);
         device.counters.liveFramesReceived += 1;
@@ -6457,8 +6565,12 @@ export function createRemoteHub(options = {}) {
         }
         const activeCaptureGeneration = Number(activeLiveStream.captureGeneration || 0);
         const frameCaptureGeneration = Number(latestFrame.captureGeneration || 0);
-        return activeCaptureGeneration <= 0
-            || (frameCaptureGeneration > 0 && frameCaptureGeneration === activeCaptureGeneration);
+        const activeMonitorIndex = parseExactLiveStreamMonitorIndex(activeLiveStream.monitorIndex);
+        const frameMonitorIndex = parseExactLiveStreamMonitorIndex(latestFrame.monitorIndex);
+        return activeMonitorIndex !== null
+            && frameMonitorIndex === activeMonitorIndex
+            && (activeCaptureGeneration <= 0
+                || (frameCaptureGeneration > 0 && frameCaptureGeneration === activeCaptureGeneration));
     }
 
     function getLiveStreamFreshWindowMs(activeLiveStream) {

package/src/server.js

@@ -7,8 +7,9 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, wri
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import os from 'node:os';
-import { WebSocketServer } from 'ws';
+import { WebSocketServer } from 'ws';
 import { createRemoteHub } from './remote-hub.js';
+import { isReusedLiveStreamFrameReady } from './live-stream-monitor-contract.js';
 import { buildMode4AtlasSessionKey, Mode4AtlasPool, planMode4AtlasInputTransitions } from './mode4-atlas-pool.js';
 import { resolveMode4AtlasTileSize } from './mode4-atlas-sizing.js';
 import { createHubFilesystem } from './filesystem/hub-filesystem.js';
@@ -1976,12 +1977,7 @@ function startFrameSubscriptionLive(ws, reason = 'subscribe', onlyDeviceId = '',
         readySent: false
       };
       const activeStream = device?.activeLiveStream;
-      const reusedFrameReady = result.reused === true
-        && result.ready === true
-        && Number(result.framesReceived ?? activeStream?.framesReceived ?? 0) > 0
-        && String(activeStream?.streamId || expectedBinding.streamId) === expectedBinding.streamId
-        && String(activeStream?.commandId || expectedBinding.commandId) === expectedBinding.commandId
-        && Number(activeStream?.captureGeneration || expectedBinding.captureGeneration) === expectedBinding.captureGeneration;
+      const reusedFrameReady = isReusedLiveStreamFrameReady(result, activeStream, expectedBinding);
       expectedBinding.readySent = reusedFrameReady;
       ws.liveDeskStreamIdsByDeviceId.set(deviceId, result.streamId);
       ws.liveDeskExpectedStreamBindingsByDeviceId.set(deviceId, expectedBinding);