livedesk 0.1.365 → 0.1.366

package/hub/src/remote-hub.js

@@ -617,11 +617,12 @@ function normalizeRemoteInputEvent(value = {}) {
     const location = Number(input.location ?? input.Location);
     const monitorIndex = Number(input.monitorIndex ?? input.MonitorIndex ?? input.screenIndex ?? input.ScreenIndex ?? input.displayIndex ?? input.DisplayIndex);
     const inputSeq = Number(input.inputSeq ?? input.InputSeq);
-    const issuedAtEpochMs = Number(input.issuedAtEpochMs ?? input.IssuedAtEpochMs);
-    const hubReceivedAtEpochMs = Number(input.hubReceivedAtEpochMs ?? input.HubReceivedAtEpochMs);
-    return {
-        type,
-        monitorIndex: Number.isFinite(monitorIndex) ? normalizeMonitorIndex(monitorIndex) : 0,
+    const issuedAtEpochMs = Number(input.issuedAtEpochMs ?? input.IssuedAtEpochMs);
+    const hubReceivedAtEpochMs = Number(input.hubReceivedAtEpochMs ?? input.HubReceivedAtEpochMs);
+    const captureGeneration = Number(input.captureGeneration ?? input.CaptureGeneration);
+    return {
+        type,
+        monitorIndex: Number.isFinite(monitorIndex) ? normalizeMonitorIndex(monitorIndex) : 0,
         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),
@@ -636,9 +637,13 @@ function normalizeRemoteInputEvent(value = {}) {
         shiftKey: input.shiftKey === true || input.ShiftKey === true,
         ctrlKey: input.ctrlKey === true || input.ControlKey === true || input.CtrlKey === true,
         altKey: input.altKey === true || input.AltKey === true,
-        metaKey: input.metaKey === true || input.MetaKey === true || input.commandKey === true || input.CommandKey === true,
-        controlLeaseId: safeString(input.controlLeaseId || input.ControlLeaseId, 128),
-        inputSeq: Number.isSafeInteger(inputSeq) && inputSeq > 0 ? inputSeq : 0,
+        metaKey: input.metaKey === true || input.MetaKey === true || input.commandKey === true || input.CommandKey === true,
+        controlLeaseId: safeString(input.controlLeaseId || input.ControlLeaseId, 128),
+        controlSessionId: safeString(input.controlSessionId || input.sessionId || input.ControlSessionId || input.SessionId, 160),
+        controlCommandId: safeString(input.controlCommandId || input.commandId || input.ControlCommandId || input.CommandId, 128),
+        captureGeneration: Number.isSafeInteger(captureGeneration) && captureGeneration > 0 ? captureGeneration : 0,
+        hubConnectionId: safeString(input.hubConnectionId || input.HubConnectionId, 128),
+        inputSeq: Number.isSafeInteger(inputSeq) && inputSeq > 0 ? inputSeq : 0,
         requestAck: input.requestAck !== false && input.RequestAck !== false,
         issuedAtEpochMs: Number.isFinite(issuedAtEpochMs) ? issuedAtEpochMs : 0,
         hubReceivedAtEpochMs: Number.isFinite(hubReceivedAtEpochMs) ? hubReceivedAtEpochMs : 0,
@@ -3397,9 +3402,9 @@ export function createRemoteHub(options = {}) {
         const activatingPendingGeneration = isPendingGeneration && commandId !== activeCommandId;
         const transfer = buildRemoteFrameTransferDescriptorFromMessage(message, streamState.mode || DEFAULT_REMOTE_FRAME_MODE);
         const openedAt = safeString(message.openedAt, 80) || device.lastSeenAt || new Date().toISOString();
-        const nextStreamState = {
-            ...streamState,
-            commandId: activatingPendingGeneration ? commandId : streamState.commandId,
+        const nextStreamState = {
+            ...streamState,
+            commandId: activatingPendingGeneration ? commandId : streamState.commandId,
             pendingCommandId: activatingPendingGeneration ? '' : streamState.pendingCommandId,
             pendingStartedAt: activatingPendingGeneration ? '' : streamState.pendingStartedAt,
             pendingRestartToken: activatingPendingGeneration ? '' : streamState.pendingRestartToken,
@@ -3419,10 +3424,14 @@ 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),
-            monitorCount: Number.isFinite(Number(message.monitorCount)) ? clampNumber(message.monitorCount, 1, 64, 1) : Number(streamState.monitorCount || 1),
-            openedFrameSeq: Number.isFinite(Number(message.frameSeq)) ? Number(message.frameSeq) : Number(streamState.openedFrameSeq || 0)
-        };
+            monitorIndex: Number.isFinite(Number(message.monitorIndex)) ? normalizeMonitorIndex(message.monitorIndex) : Number(streamState.monitorIndex || 0),
+            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
+                ? Number(message.captureGeneration)
+                : Number(streamState.captureGeneration || 0),
+            openedFrameSeq: Number.isFinite(Number(message.frameSeq)) ? Number(message.frameSeq) : Number(streamState.openedFrameSeq || 0)
+        };
         setDeviceLiveStream(device, nextStreamState);
         emitRemoteEvent('RemoteLiveStreamOpened', device, {
             streamId,
@@ -3457,9 +3466,9 @@ export function createRemoteHub(options = {}) {
             });
             return false;
         }
-        const activeCommandId = safeString(streamState.commandId, 128);
-        const pendingCommandId = safeString(streamState.pendingCommandId, 128);
-        const isActiveGeneration = !commandId || !activeCommandId || commandId === activeCommandId;
+        const activeCommandId = safeString(streamState.commandId, 128);
+        const pendingCommandId = safeString(streamState.pendingCommandId, 128);
+        const isActiveGeneration = !commandId || !activeCommandId || commandId === activeCommandId;
         if (!isActiveGeneration) {
             device.counters.liveFramesDropped += 1;
             emitRemoteEvent('RemoteFrameDropped', device, {
@@ -3471,8 +3480,25 @@ export function createRemoteHub(options = {}) {
                 frameSeq: Number.isFinite(frameSeq) ? frameSeq : null,
                 transport
             });
-            return false;
-        }
+            return false;
+        }
+        const frameCaptureGeneration = Number(message.captureGeneration || streamState.captureGeneration || 0);
+        const activeCaptureGeneration = Number(streamState.captureGeneration || 0);
+        if (activeCaptureGeneration > 0
+            && frameCaptureGeneration > 0
+            && frameCaptureGeneration !== activeCaptureGeneration) {
+            device.counters.liveFramesDropped += 1;
+            emitRemoteEvent('RemoteFrameDropped', device, {
+                reason: 'stale-capture-generation-frame',
+                streamId,
+                commandId,
+                captureGeneration: frameCaptureGeneration,
+                activeCaptureGeneration,
+                frameSeq: Number.isFinite(frameSeq) ? frameSeq : null,
+                transport
+            });
+            return false;
+        }
 
         const byteLength = normalizeFrameByteLength(framePayload, frameData);
         if ((!Buffer.isBuffer(framePayload) && !frameData)
@@ -3511,9 +3537,12 @@ export function createRemoteHub(options = {}) {
         device.latestLiveFrame = {
             streamId,
             frameSeq,
-            streamFrameSeq: Number.isFinite(Number(message.streamFrameSeq)) ? Number(message.streamFrameSeq) : frameSeq,
-            commandId,
-            width: Number.isFinite(Number(message.width)) ? Number(message.width) : 0,
+            streamFrameSeq: Number.isFinite(Number(message.streamFrameSeq)) ? Number(message.streamFrameSeq) : frameSeq,
+            commandId,
+            sessionId: device.sessionId,
+            captureGeneration: activeCaptureGeneration || frameCaptureGeneration,
+            streamPurpose: safeString(message.streamPurpose || streamState.streamPurpose, 24) || 'wall',
+            width: Number.isFinite(Number(message.width)) ? Number(message.width) : 0,
             height: Number.isFinite(Number(message.height)) ? Number(message.height) : 0,
             sourceWidth: Number.isFinite(Number(message.sourceWidth)) ? Number(message.sourceWidth) : Number(message.width || 0),
             sourceHeight: Number.isFinite(Number(message.sourceHeight)) ? Number(message.sourceHeight) : Number(message.height || 0),
@@ -4667,17 +4696,49 @@ export function createRemoteHub(options = {}) {
         const denied = policyError(device, 'allowControl');
         if (denied) return { ok: false, error: denied };
 
-        if (!readCapabilityFlag(device.capabilities, 'control')) {
-            return { ok: false, error: 'device-input-control-unavailable' };
-        }
-
-        const normalized = normalizeRemoteInputEvent(input);
-        if (!normalized.type) {
-            return { ok: false, error: 'missing-input-type' };
-        }
-
-        const inputSocket = device.inputSocket;
-        if (inputSocket && !inputSocket.destroyed) {
+        if (!readCapabilityFlag(device.capabilities, 'control')) {
+            const permissionMissing = device.capabilities?.controlPermission === false
+                || device.capabilities?.accessibilityPermission === false;
+            return { ok: false, error: permissionMissing ? 'INPUT_PERMISSION_DENIED' : 'device-input-control-unavailable' };
+        }
+
+        const normalized = normalizeRemoteInputEvent(input);
+        if (!normalized.type) {
+            return { ok: false, error: 'missing-input-type' };
+        }
+        const controlStream = getActiveControlStream(device);
+        if (!controlStream
+            || controlStream.open !== true
+            || !safeString(controlStream.commandId, 128)
+            || Number(controlStream.captureGeneration || 0) <= 0) {
+            return { ok: false, error: 'CONTROL_NOT_READY' };
+        }
+        if (!normalized.controlSessionId
+            || normalized.controlSessionId !== safeString(device.sessionId, 160)) {
+            return {
+                ok: false,
+                error: 'STALE_CONTROL_SESSION',
+                activeSessionId: safeString(device.sessionId, 160)
+            };
+        }
+        if (!normalized.controlCommandId
+            || normalized.controlCommandId !== safeString(controlStream.commandId, 128)) {
+            return {
+                ok: false,
+                error: 'STALE_CONTROL_SESSION',
+                activeCommandId: safeString(controlStream.commandId, 128)
+            };
+        }
+        if (normalized.captureGeneration !== Number(controlStream.captureGeneration || 0)) {
+            return {
+                ok: false,
+                error: 'STALE_CAPTURE_GENERATION',
+                activeCaptureGeneration: Number(controlStream.captureGeneration || 0)
+            };
+        }
+
+        const inputSocket = device.inputSocket;
+        if (inputSocket && !inputSocket.destroyed) {
             const sent = writeJsonLine(inputSocket, {
                 type: 'input.control',
                 payload: {
@@ -4687,22 +4748,21 @@ export function createRemoteHub(options = {}) {
                 }
             });
             if (sent) {
-                device.counters.commandsSent += 1;
-                device.inputLastSeenAt = new Date().toISOString();
-                return { ok: true, inputSocket: true };
-            }
+                device.counters.commandsSent += 1;
+                device.inputLastSeenAt = new Date().toISOString();
+                return {
+                    ok: true,
+                    inputSocket: true,
+                    sessionId: device.sessionId,
+                    commandId: controlStream.commandId,
+                    captureGeneration: controlStream.captureGeneration
+                };
+            }
 
             detachInputSocket(inputSocket, 'input-socket-write-failed');
         }
 
-        return sendCommand(deviceId, {
-            command: 'input.control',
-            payload: {
-                ...normalized,
-                hubForwardedAtEpochMs: Date.now(),
-                issuedAt: normalized.issuedAt || new Date().toISOString()
-            }
-        });
+        return { ok: false, error: 'CONTROL_NOT_READY', detail: 'input-channel-not-connected' };
     }
 
     function notifyAgentProgress(deviceIds, progress = {}) {
@@ -5061,11 +5121,83 @@ export function createRemoteHub(options = {}) {
         }
     }
 
-    function makeStableLiveStreamId(deviceId, purpose = 'wall') {
-        const hash = crypto.createHash('sha1').update(String(deviceId || 'device')).digest('hex').slice(0, 16);
-        const role = safeString(purpose, 24).toLowerCase().replace(/[^a-z0-9_-]+/g, '-') || 'wall';
-        return `${role}-${hash}`;
-    }
+    function makeStableLiveStreamId(deviceId, purpose = 'wall') {
+        const hash = crypto.createHash('sha1').update(String(deviceId || 'device')).digest('hex').slice(0, 16);
+        const role = safeString(purpose, 24).toLowerCase().replace(/[^a-z0-9_-]+/g, '-') || 'wall';
+        return `${role}-${hash}`;
+    }
+
+    function getActiveLiveStreams(device) {
+        if (!device || typeof device !== 'object') {
+            return [];
+        }
+        return [...ensureDeviceLiveStreams(device).values()].filter(stream => stream?.active === true);
+    }
+
+    function getActiveControlStream(device) {
+        return getActiveLiveStreams(device).find(stream =>
+            safeString(stream?.streamPurpose, 24).toLowerCase() === 'control') || null;
+    }
+
+    function stopCompetingMacCaptureStreams(deviceId, device, nextStreamId, nextPurpose) {
+        if (normalizeLivePlatform(device?.platform) !== 'macos') {
+            return { ok: true, stopped: [] };
+        }
+
+        const activeControl = getActiveControlStream(device);
+        if (nextPurpose !== 'control'
+            && activeControl
+            && activeControl.streamId !== nextStreamId) {
+            return {
+                ok: true,
+                suppressed: true,
+                reason: 'CONTROL_CAPTURE_OWNS_DEVICE',
+                ownerStreamId: activeControl.streamId,
+                ownerCommandId: activeControl.commandId,
+                captureGeneration: Number(activeControl.captureGeneration || 0)
+            };
+        }
+
+        const stopped = [];
+        for (const stream of getActiveLiveStreams(device)) {
+            if (!stream?.streamId || stream.streamId === nextStreamId) {
+                continue;
+            }
+            const stopCommandId = crypto.randomUUID();
+            const result = sendCommand(deviceId, {
+                command: 'stream.stop',
+                commandId: stopCommandId,
+                payload: {
+                    streamId: stream.streamId,
+                    requestedAt: new Date().toISOString(),
+                    reason: `mac-capture-owner-transition:${nextPurpose}`
+                }
+            });
+            if (!result.ok) {
+                return {
+                    ok: false,
+                    error: 'CAPTURE_TRANSITION_IN_PROGRESS',
+                    streamId: stream.streamId,
+                    detail: result.error || 'stream-stop-dispatch-failed'
+                };
+            }
+            stream.active = false;
+            stream.pendingCommandId = '';
+            stream.pendingStartedAt = '';
+            stream.pendingRestartToken = '';
+            stream.stoppedAt = new Date().toISOString();
+            stream.stopReason = `mac-capture-owner-transition:${nextPurpose}`;
+            stopped.push({ streamId: stream.streamId, commandId: stopCommandId });
+        }
+        return { ok: true, stopped };
+    }
+
+    function nextCaptureGeneration(device) {
+        const current = Number(device?.captureGenerationCounter || 0);
+        const next = Number.isSafeInteger(current) && current > 0 ? current + 1 : 1;
+        device.captureGenerationCounter = next;
+        return next;
+    }
 
     function normalizeLivePlatform(value) {
         const normalized = safeString(value, 32).toLowerCase();
@@ -5158,11 +5290,11 @@ export function createRemoteHub(options = {}) {
             }
 
             const now = new Date().toISOString();
-            const normalized = normalizeLiveStreamStartOptions({ fps: 2, ...options, platform: device.platform });
-            const { fps, maxWidth, maxHeight, quality, monitorIndex, transfer, streamPurpose } = normalized;
-            const streamId = safeString(options.streamId, 128) || makeStableLiveStreamId(deviceId, streamPurpose);
-            const activeLiveStream = getDeviceLiveStream(device, streamId);
-            const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
+            const normalized = normalizeLiveStreamStartOptions({ fps: 2, ...options, platform: device.platform });
+            const { fps, maxWidth, maxHeight, quality, monitorIndex, transfer, streamPurpose } = normalized;
+            const streamId = safeString(options.streamId, 128) || makeStableLiveStreamId(deviceId, streamPurpose);
+            const activeLiveStream = getDeviceLiveStream(device, streamId);
+            const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
             if (activeLiveStream
                 && liveStreamMatchesOptions(activeLiveStream, normalized)
                 && (activeLiveStream.open === true || liveStreamStartStillPending(activeLiveStream))) {
@@ -5173,13 +5305,15 @@ export function createRemoteHub(options = {}) {
                     fps,
                     mode: transfer.mode,
                     frameMode: transfer.frameMode,
-                    monitorIndex,
-                    synthetic: true,
-                    reused: true
-                };
-            }
-            device.counters.commandsSent += 1;
-            setDeviceLiveStream(device, {
+                    monitorIndex,
+                    captureGeneration: Number(activeLiveStream.captureGeneration || 0),
+                    synthetic: true,
+                    reused: true
+                };
+            }
+            const captureGeneration = nextCaptureGeneration(device);
+            device.counters.commandsSent += 1;
+            setDeviceLiveStream(device, {
                 streamId,
                 commandId,
                 active: true,
@@ -5204,11 +5338,12 @@ export function createRemoteHub(options = {}) {
                 startedAt: now,
                 stoppedAt: '',
                 stopReason: '',
-                lastFrameAt: '',
-                lastFrameSeq: 0,
-                framesReceived: 0,
-                streamPurpose
-            });
+                lastFrameAt: '',
+                lastFrameSeq: 0,
+                framesReceived: 0,
+                streamPurpose,
+                captureGeneration
+            });
             device.counters.liveStreamsStarted += 1;
             applySyntheticLiveFrame(device, streamId, {
                 commandId,
@@ -5224,7 +5359,7 @@ export function createRemoteHub(options = {}) {
                 mode: transfer.mode,
                 synthetic: true
             });
-            return { ok: true, commandId, streamId, fps, mode: transfer.mode, frameMode: transfer.frameMode, monitorIndex, synthetic: true };
+            return { ok: true, commandId, streamId, fps, mode: transfer.mode, frameMode: transfer.frameMode, monitorIndex, captureGeneration, synthetic: true };
         }
 
         if (!device?.socket || device.socket.destroyed || !device.connected) {
@@ -5235,11 +5370,35 @@ export function createRemoteHub(options = {}) {
         }
 
         const now = new Date().toISOString();
-        const normalized = normalizeLiveStreamStartOptions({ ...options, platform: device.platform });
-        const { fps, maxWidth, maxHeight, quality, monitorIndex, transfer, streamPurpose } = normalized;
-        const streamId = safeString(options.streamId, 128) || makeStableLiveStreamId(deviceId, streamPurpose);
-        const activeLiveStream = getDeviceLiveStream(device, streamId);
-        if (activeLiveStream?.pendingCommandId) {
+        const normalized = normalizeLiveStreamStartOptions({ ...options, platform: device.platform });
+        const { fps, maxWidth, maxHeight, quality, monitorIndex, transfer, streamPurpose } = normalized;
+        const streamId = safeString(options.streamId, 128) || makeStableLiveStreamId(deviceId, streamPurpose);
+        const activeLiveStream = getDeviceLiveStream(device, streamId);
+        const macTransition = stopCompetingMacCaptureStreams(deviceId, device, streamId, streamPurpose);
+        if (!macTransition.ok) {
+            return macTransition;
+        }
+        if (macTransition.suppressed) {
+            emitRemoteEvent('RemoteLiveStreamStartSuppressed', device, {
+                streamId,
+                streamPurpose,
+                reason: macTransition.reason,
+                ownerStreamId: macTransition.ownerStreamId,
+                ownerCommandId: macTransition.ownerCommandId,
+                captureGeneration: macTransition.captureGeneration
+            });
+            return {
+                ok: true,
+                suppressed: true,
+                streamId,
+                streamPurpose,
+                reason: macTransition.reason,
+                ownerStreamId: macTransition.ownerStreamId,
+                ownerCommandId: macTransition.ownerCommandId,
+                captureGeneration: macTransition.captureGeneration
+            };
+        }
+        if (activeLiveStream?.pendingCommandId) {
             if (liveStreamReplacementStillPending(activeLiveStream)) {
                 emitRemoteEvent('RemoteLiveStreamRestartPending', device, {
                     streamId,
@@ -5253,11 +5412,12 @@ export function createRemoteHub(options = {}) {
                     streamId,
                     fps: Number(activeLiveStream.fps || fps),
                     mode: activeLiveStream.mode || transfer.mode,
-                    frameMode: activeLiveStream.frameMode || transfer.frameMode,
-                    monitorIndex: Number(activeLiveStream.monitorIndex || monitorIndex),
-                    pending: true,
-                    reused: true
-                };
+                    frameMode: activeLiveStream.frameMode || transfer.frameMode,
+                    monitorIndex: Number(activeLiveStream.monitorIndex || monitorIndex),
+                    captureGeneration: Number(activeLiveStream.captureGeneration || 0),
+                    pending: true,
+                    reused: true
+                };
             }
             activeLiveStream.pendingCommandId = '';
             activeLiveStream.pendingStartedAt = '';
@@ -5275,10 +5435,11 @@ export function createRemoteHub(options = {}) {
                 streamId,
                 fps: Number(activeLiveStream.fps || fps),
                 mode: activeLiveStream.mode || transfer.mode,
-                frameMode: activeLiveStream.frameMode || transfer.frameMode,
-                monitorIndex: Number(activeLiveStream.monitorIndex || monitorIndex),
-                reused: true
-            };
+                frameMode: activeLiveStream.frameMode || transfer.frameMode,
+                monitorIndex: Number(activeLiveStream.monitorIndex || monitorIndex),
+                captureGeneration: Number(activeLiveStream.captureGeneration || 0),
+                reused: true
+            };
         }
         if (activeLiveStream
             && options.forceRestart !== true
@@ -5299,10 +5460,11 @@ export function createRemoteHub(options = {}) {
                 streamId,
                 fps,
                 mode: transfer.mode,
-                frameMode: transfer.frameMode,
-                monitorIndex,
-                reused: true
-            };
+                frameMode: transfer.frameMode,
+                monitorIndex,
+                captureGeneration: Number(activeLiveStream.captureGeneration || 0),
+                reused: true
+            };
         }
         if (options.forceRestart === true && activeLiveStream) {
             emitRemoteEvent('RemoteLiveStreamForcedRestart', device, {
@@ -5329,10 +5491,11 @@ export function createRemoteHub(options = {}) {
                 lastFrameAt: activeLiveStream.lastFrameAt || ''
             });
         }
-        const result = sendCommand(deviceId, {
-            command: 'stream.start',
-            commandId,
-            payload: {
+        const captureGeneration = nextCaptureGeneration(device);
+        const result = sendCommand(deviceId, {
+            command: 'stream.start',
+            commandId,
+            payload: {
                 streamId,
                 mode: transfer.mode,
                 frameMode: transfer.frameMode,
@@ -5347,10 +5510,12 @@ export function createRemoteHub(options = {}) {
                 maxWidth,
                 maxHeight,
                 quality,
-                monitorIndex,
-                streamPurpose,
-                requestedAt: now
-            }
+                monitorIndex,
+                streamPurpose,
+                captureGeneration,
+                sessionId: device.sessionId,
+                requestedAt: now
+            }
         });
 
         if (!result.ok) {
@@ -5392,9 +5557,10 @@ export function createRemoteHub(options = {}) {
             stopReason: '',
             lastFrameAt: '',
             lastFrameSeq: 0,
-            framesReceived: 0,
-            streamPurpose
-        });
+            framesReceived: 0,
+            streamPurpose,
+            captureGeneration
+        });
         device.counters.liveStreamsStarted += 1;
         emitRemoteEvent('RemoteLiveStreamStarted', device, {
             streamId,
@@ -5407,7 +5573,7 @@ export function createRemoteHub(options = {}) {
             monitorIndex
         });
 
-        return { ok: true, commandId, streamId, fps, mode: transfer.mode, frameMode: transfer.frameMode, monitorIndex };
+        return { ok: true, commandId, streamId, fps, mode: transfer.mode, frameMode: transfer.frameMode, monitorIndex, captureGeneration };
     }
 
     function stopLiveStream(deviceId, options = {}) {

package/hub/src/server.js

@@ -3844,10 +3844,10 @@ inputWss.on('connection', ws => {
       sendJson(ws, { type: 'RemoteInputError', error: 'invalid-json' });
       return;
     }
-    const deviceId = String(payload?.deviceId || '').trim();
-    const input = payload?.input && typeof payload.input === 'object'
-      ? { ...payload.input, hubReceivedAtEpochMs: Date.now() }
-      : { ...payload, hubReceivedAtEpochMs: Date.now() };
+    const deviceId = String(payload?.deviceId || '').trim();
+    const input = payload?.input && typeof payload.input === 'object'
+      ? { ...payload.input, hubConnectionId: ws.liveDeskInputClientId, hubReceivedAtEpochMs: Date.now() }
+      : { ...payload, hubConnectionId: ws.liveDeskInputClientId, hubReceivedAtEpochMs: Date.now() };
     const result = remoteHub.sendInputControl(deviceId, input);
     const inputType = String(input?.type || '').toLowerCase();
     const fireAndForget = payload?.fireAndForget === true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livedesk",
-  "version": "0.1.365",
+  "version": "0.1.366",
   "buildFlavor": "production",
   "description": "LiveDesk Hub and client launcher",
   "type": "module",
@@ -48,10 +48,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.365",
-    "@livedesk/fast-osx-arm64": "0.1.365",
-    "@livedesk/fast-osx-x64": "0.1.365",
-    "@livedesk/fast-win-x64": "0.1.365"
+    "@livedesk/fast-linux-x64": "0.1.366",
+    "@livedesk/fast-osx-arm64": "0.1.366",
+    "@livedesk/fast-osx-x64": "0.1.366",
+    "@livedesk/fast-win-x64": "0.1.366"
   },
   "publishConfig": {
     "access": "public"