livedesk 0.1.81 → 0.1.83

package/hub/src/remote-hub.js

@@ -22,6 +22,9 @@ const RECENT_THUMBNAIL_FRAME_CACHE_LIMIT = 4;
 const RECENT_LIVE_FRAME_CACHE_LIMIT = 80;
 const RECENT_THUMBNAIL_FRAME_CACHE_MAX_BYTES = 3 * 1024 * 1024;
 const RECENT_LIVE_FRAME_CACHE_MAX_BYTES = 24 * 1024 * 1024;
+const LIVE_STREAM_PENDING_REUSE_MS = 5000;
+const LIVE_STREAM_MIN_FRESH_MS = 3000;
+const LIVE_STREAM_MAX_FRESH_MS = 12000;
 const REMOTE_PROTOCOL_VERSION = 2;
 const REMOTE_AGENT_PROTOCOL = 'mindexec.remote.agent';
 const REMOTE_FRAME_PROTOCOL = 'mindexec.remote.frame.v2';
@@ -1205,6 +1208,7 @@ export function createRemoteHub(options = {}) {
     const devices = new Map();
     const taskBatches = new Map();
     const sockets = new Map();
+    const inputSockets = new Map();
     const allSockets = new Set();
     const duplicateDeviceLogAt = new Map();
     let server = null;
@@ -1738,6 +1742,7 @@ export function createRemoteHub(options = {}) {
 
     function closeExistingDeviceSocket(deviceId, nextSessionId) {
         const existing = devices.get(deviceId);
+        closeInputSocket(existing, 'replaced-by-new-session');
         if (!existing?.socket || existing.socket.destroyed) {
             return;
         }
@@ -1752,6 +1757,43 @@ export function createRemoteHub(options = {}) {
         existing.socket.destroy();
     }
 
+    function closeInputSocket(device, reason = 'input-socket-closed') {
+        const socket = device?.inputSocket;
+        if (!socket) {
+            return;
+        }
+
+        device.inputSocket = null;
+        inputSockets.delete(socket);
+        try {
+            writeJsonLine(socket, { type: 'disconnect', reason });
+        } catch {
+            // Best-effort notice before closing the side channel.
+        }
+        try {
+            socket.destroy?.();
+        } catch {
+            // Ignore close failures.
+        }
+    }
+
+    function detachInputSocket(socket, reason = 'input-socket-closed') {
+        const deviceId = inputSockets.get(socket);
+        inputSockets.delete(socket);
+        if (!deviceId) {
+            return;
+        }
+
+        const device = devices.get(deviceId);
+        if (!device || device.inputSocket !== socket) {
+            return;
+        }
+
+        device.inputSocket = null;
+        device.inputLastSeenAt = new Date().toISOString();
+        emitRemoteEvent('RemoteInputSocketDisconnected', device, { reason });
+    }
+
     function getDeviceActivityMs(device) {
         return Math.max(
             Date.parse(device?.lastSeenAt || '') || 0,
@@ -2136,6 +2178,7 @@ export function createRemoteHub(options = {}) {
 
         const device = {
             socket,
+            inputSocket: null,
             deviceId,
             sessionId,
             deviceName: safeString(hello.deviceName || hello.hostname || deviceId, 120),
@@ -2152,6 +2195,8 @@ export function createRemoteHub(options = {}) {
             capabilities,
             connected: true,
             connectedAt: now,
+            inputConnectedAt: '',
+            inputLastSeenAt: '',
             disconnectedAt: '',
             lastSeenAt: now,
             lastStatusAt: '',
@@ -2195,6 +2240,37 @@ export function createRemoteHub(options = {}) {
         return device;
     }
 
+    function attachInputSocket(socket, hello) {
+        const deviceId = normalizeDeviceId(hello.deviceId);
+        const device = devices.get(deviceId);
+        if (!device || !device.connected || !device.socket || device.socket.destroyed) {
+            writeJsonLine(socket, { type: 'error', error: 'device-not-connected' });
+            socket.destroy();
+            return null;
+        }
+
+        closeInputSocket(device, 'replaced-by-new-input-socket');
+
+        const now = new Date().toISOString();
+        device.inputSocket = socket;
+        device.inputConnectedAt = now;
+        device.inputLastSeenAt = now;
+        inputSockets.set(socket, deviceId);
+
+        writeJsonLine(socket, {
+            type: 'welcome',
+            channel: 'input',
+            protocol: REMOTE_AGENT_PROTOCOL,
+            protocolVersion: REMOTE_PROTOCOL_VERSION,
+            sessionId: device.sessionId,
+            deviceId,
+            serverTime: now
+        });
+
+        emitRemoteEvent('RemoteInputSocketConnected', device);
+        return device;
+    }
+
     function detachSocket(socket, reason = 'socket-closed') {
         const deviceId = sockets.get(socket);
         sockets.delete(socket);
@@ -2209,6 +2285,7 @@ export function createRemoteHub(options = {}) {
 
         device.connected = false;
         device.socket = null;
+        closeInputSocket(device, reason);
         device.disconnectedAt = new Date().toISOString();
         device.lastDisconnectReason = reason;
         if (device.activeLiveStream) {
@@ -2973,6 +3050,12 @@ export function createRemoteHub(options = {}) {
         }
 
         const device = state.device;
+        if (state.inputOnly) {
+            writeJsonLine(socket, { type: 'error', error: 'input-channel-binary-not-supported' });
+            socket.destroy();
+            return;
+        }
+
         device.counters.messagesReceived += 1;
         device.lastSeenAt = new Date().toISOString();
 
@@ -3016,6 +3099,19 @@ export function createRemoteHub(options = {}) {
                 return;
             }
 
+            const channel = safeString(message.channel || message.Channel, 40).toLowerCase();
+            if (channel === 'input') {
+                const device = attachInputSocket(socket, message);
+                if (!device) {
+                    return;
+                }
+
+                state.authenticated = true;
+                state.device = device;
+                state.inputOnly = true;
+                return;
+            }
+
             const device = attachDevice(socket, message);
             if (!device) {
                 return;
@@ -3032,6 +3128,11 @@ export function createRemoteHub(options = {}) {
             return;
         }
 
+        if (state.inputOnly) {
+            device.inputLastSeenAt = new Date().toISOString();
+            return;
+        }
+
         device.counters.messagesReceived += 1;
         device.lastSeenAt = new Date().toISOString();
 
@@ -3103,7 +3204,8 @@ export function createRemoteHub(options = {}) {
 
         const state = {
             authenticated: false,
-            device: null
+            device: null,
+            inputOnly: false
         };
 
         const helloTimer = setTimeout(() => {
@@ -3154,6 +3256,7 @@ export function createRemoteHub(options = {}) {
         const detach = reason => {
             allSockets.delete(socket);
             clearTimeout(helloTimer);
+            detachInputSocket(socket, reason);
             detachSocket(socket, reason);
         };
 
@@ -3243,6 +3346,7 @@ export function createRemoteHub(options = {}) {
         const state = {
             authenticated: false,
             device: null,
+            inputOnly: false,
             buffer: Buffer.alloc(0),
             pendingBinaryFrame: null
         };
@@ -3323,11 +3427,13 @@ export function createRemoteHub(options = {}) {
         socket.on('close', () => {
             allSockets.delete(socket);
             clearTimeout(helloTimer);
+            detachInputSocket(socket);
             detachSocket(socket);
         });
         socket.on('error', err => {
             allSockets.delete(socket);
             clearTimeout(helloTimer);
+            detachInputSocket(socket, err?.message || 'socket-error');
             detachSocket(socket, err?.message || 'socket-error');
         });
     }
@@ -3514,6 +3620,24 @@ export function createRemoteHub(options = {}) {
             return { ok: false, error: 'missing-input-type' };
         }
 
+        const inputSocket = device.inputSocket;
+        if (inputSocket && !inputSocket.destroyed) {
+            const sent = writeJsonLine(inputSocket, {
+                type: 'input.control',
+                payload: {
+                    ...normalized,
+                    issuedAt: normalized.issuedAt || new Date().toISOString()
+                }
+            });
+            if (sent) {
+                device.counters.commandsSent += 1;
+                device.inputLastSeenAt = new Date().toISOString();
+                return { ok: true, inputSocket: true };
+            }
+
+            detachInputSocket(inputSocket, 'input-socket-write-failed');
+        }
+
         return sendCommand(deviceId, {
             command: 'input.control',
             payload: {
@@ -3751,7 +3875,37 @@ export function createRemoteHub(options = {}) {
             return false;
         }
         const startedAt = Date.parse(activeLiveStream.startedAt || '');
-        return Number.isFinite(startedAt) && Date.now() - startedAt < 5000;
+        return Number.isFinite(startedAt) && Date.now() - startedAt < LIVE_STREAM_PENDING_REUSE_MS;
+    }
+
+    function getLiveStreamFreshWindowMs(activeLiveStream) {
+        const fps = Number(activeLiveStream?.fps || 0);
+        const frameMs = Number.isFinite(fps) && fps > 0 ? 1000 / fps : 500;
+        return Math.max(
+            LIVE_STREAM_MIN_FRESH_MS,
+            Math.min(LIVE_STREAM_MAX_FRESH_MS, Math.round(frameMs * 20))
+        );
+    }
+
+    function getLiveStreamIdleMs(activeLiveStream) {
+        const lastFrameAt = Date.parse(activeLiveStream?.lastFrameAt || activeLiveStream?.openedAt || activeLiveStream?.startedAt || '');
+        if (!Number.isFinite(lastFrameAt)) {
+            return Infinity;
+        }
+        return Math.max(0, Date.now() - lastFrameAt);
+    }
+
+    function liveStreamIsReusable(activeLiveStream) {
+        if (!activeLiveStream?.active) {
+            return false;
+        }
+        if (liveStreamStartStillPending(activeLiveStream)) {
+            return true;
+        }
+        if (activeLiveStream.open !== true) {
+            return false;
+        }
+        return getLiveStreamIdleMs(activeLiveStream) <= getLiveStreamFreshWindowMs(activeLiveStream);
     }
 
     function liveStreamMatchesOptions(activeLiveStream, normalized) {
@@ -3855,7 +4009,7 @@ export function createRemoteHub(options = {}) {
         const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
         if (device.activeLiveStream?.streamId === streamId
             && liveStreamMatchesOptions(device.activeLiveStream, normalized)
-            && (device.activeLiveStream.open === true || liveStreamStartStillPending(device.activeLiveStream))) {
+            && liveStreamIsReusable(device.activeLiveStream)) {
             emitRemoteEvent('RemoteLiveStreamStartReused', device, {
                 streamId,
                 fps,
@@ -3874,6 +4028,21 @@ export function createRemoteHub(options = {}) {
                 reused: true
             };
         }
+        if (device.activeLiveStream?.streamId === streamId
+            && liveStreamMatchesOptions(device.activeLiveStream, normalized)
+            && device.activeLiveStream.open === true
+            && !liveStreamIsReusable(device.activeLiveStream)) {
+            emitRemoteEvent('RemoteLiveStreamStaleRestart', device, {
+                streamId,
+                fps,
+                mode: transfer.mode,
+                frameMode: transfer.frameMode,
+                monitorIndex,
+                idleMs: getLiveStreamIdleMs(device.activeLiveStream),
+                staleAfterMs: getLiveStreamFreshWindowMs(device.activeLiveStream),
+                lastFrameAt: device.activeLiveStream.lastFrameAt || ''
+            });
+        }
         if (device.activeLiveStream?.active && device.activeLiveStream.streamId && device.activeLiveStream.streamId !== streamId) {
             sendCommand(deviceId, {
                 command: 'stream.stop',

package/hub/src/server.js

@@ -27,6 +27,7 @@ const audioClients = new Set();
 let frameClientSeq = 0;
 let inputClientSeq = 0;
 let audioClientSeq = 0;
+const FRAME_LIVE_WATCHDOG_MS = 2500;
 
 function handleRemoteHubEvent(type, event) {
   if (type !== 'RemoteDeviceConnected') {
@@ -246,6 +247,9 @@ function startFrameSubscriptionLive(ws, reason = 'subscribe', onlyDeviceId = '')
       skipped.push({ deviceId, reason: result?.error || 'start-failed' });
     }
   }
+  if (reason === 'watchdog' && !started.some(item => item.reused !== true)) {
+    return;
+  }
   sendJson(ws, {
     type: 'RemoteFrameLiveAutoStart',
     timestamp: new Date().toISOString(),
@@ -702,6 +706,16 @@ httpServer.on('upgrade', (req, socket, head) => {
 frameWss.on('connection', (ws, req) => {
   frameClients.add(ws);
   ws.liveDeskFrameClientId = `rfws-${++frameClientSeq}`;
+  const liveWatchdog = setInterval(() => {
+    if (ws.readyState === 1) {
+      startFrameSubscriptionLive(ws, 'watchdog');
+    }
+  }, FRAME_LIVE_WATCHDOG_MS);
+  liveWatchdog.unref?.();
+  const cleanup = () => {
+    clearInterval(liveWatchdog);
+    frameClients.delete(ws);
+  };
   try {
     const parsed = new URL(req.url || '/', `http://${req.headers.host || '127.0.0.1'}`);
     updateFrameSubscription(ws, { deviceIds: parsed.searchParams.get('devices') || '' });
@@ -718,8 +732,8 @@ frameWss.on('connection', (ws, req) => {
       sendJson(ws, { type: 'RemoteFrameSubscriptionError', error: 'invalid-message' });
     }
   });
-  ws.on('close', () => frameClients.delete(ws));
-  ws.on('error', () => frameClients.delete(ws));
+  ws.on('close', cleanup);
+  ws.on('error', cleanup);
   sendJson(ws, {
     type: 'RemoteFrameSocketReady',
     protocol: 'livedesk.remote.frames.binary.v1',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livedesk",
-  "version": "0.1.81",
+  "version": "0.1.83",
   "description": "LiveDesk Hub and client launcher",
   "type": "module",
   "bin": {
@@ -30,7 +30,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@livedesk/client": "0.1.61",
+    "@livedesk/client": "0.1.62",
     "cors": "^2.8.5",
     "express": "^4.21.2",
     "ws": "^8.18.3"