livedesk 0.1.124 → 0.1.126

package/hub/src/remote-hub.js

@@ -1024,6 +1024,59 @@ function startsWithTcpBinaryFrameMagic(buffer) {
         && buffer.subarray(0, TCP_BINARY_FRAME_MAGIC.length).equals(TCP_BINARY_FRAME_MAGIC);
 }
 
+function isJsonObjectStartByte(value) {
+    return value === 0x7b;
+}
+
+function isWhitespaceByte(value) {
+    return value === 0x20 || value === 0x09 || value === 0x0d || value === 0x0a;
+}
+
+function findFirstNonWhitespaceByte(buffer) {
+    if (!Buffer.isBuffer(buffer)) {
+        return -1;
+    }
+
+    for (let index = 0; index < buffer.length; index += 1) {
+        if (!isWhitespaceByte(buffer[index])) {
+            return index;
+        }
+    }
+    return -1;
+}
+
+function findTcpFrameOnlySyncIndex(buffer, startIndex = 0) {
+    if (!Buffer.isBuffer(buffer) || buffer.length <= 0) {
+        return -1;
+    }
+
+    const safeStart = Math.max(0, Math.min(buffer.length, Math.floor(Number(startIndex) || 0)));
+    const magicIndex = buffer.indexOf(TCP_BINARY_FRAME_MAGIC, safeStart);
+    const jsonIndex = buffer.indexOf(0x7b, safeStart);
+    if (magicIndex < 0) {
+        return jsonIndex;
+    }
+    if (jsonIndex < 0) {
+        return magicIndex;
+    }
+    return Math.min(magicIndex, jsonIndex);
+}
+
+function keepTcpFrameOnlySyncTail(buffer) {
+    if (!Buffer.isBuffer(buffer) || buffer.length <= 0) {
+        return Buffer.alloc(0);
+    }
+
+    const maxTailLength = Math.min(buffer.length, TCP_BINARY_FRAME_MAGIC.length - 1);
+    for (let tailLength = maxTailLength; tailLength > 0; tailLength -= 1) {
+        const tail = buffer.subarray(buffer.length - tailLength);
+        if (hasTcpBinaryFrameMagicPrefix(tail)) {
+            return tail;
+        }
+    }
+    return Buffer.alloc(0);
+}
+
 function parseTcpBinaryFramePacket(buffer) {
     if (!Buffer.isBuffer(buffer) || buffer.length < TCP_BINARY_FRAME_HEADER_BYTES) {
         return { incomplete: true };
@@ -1286,7 +1339,9 @@ export function createRemoteHub(options = {}) {
     const inputSockets = new Map();
     const frameSockets = new Map();
     const allSockets = new Set();
+    const agentBinaryIngressLanes = [];
     const duplicateDeviceLogAt = new Map();
+    let agentBinaryIngressDraining = false;
     let server = null;
     let started = false;
     let boundPort = requestedPort;
@@ -3252,29 +3307,56 @@ export function createRemoteHub(options = {}) {
         state.binaryQueueDrops = Number(state.binaryQueueDrops || 0) + 1;
     }
 
-    function drainQueuedAgentBinaryFrames(socket, state) {
-        if (state.binaryQueueDraining || state.closed) {
+    function scheduleAgentBinaryIngress(socket, state) {
+        if (!state || state.closed || !socket || socket.destroyed) {
             return;
         }
-        state.binaryQueueDraining = true;
-        setImmediate(() => {
-            state.binaryQueueDraining = false;
-            if (state.closed || socket.destroyed) {
-                state.binaryQueue.length = 0;
-                return;
-            }
 
+        state.binaryQueueSocket = socket;
+        if (state.binaryQueueScheduled !== true) {
+            state.binaryQueueScheduled = true;
+            agentBinaryIngressLanes.push(state);
+        }
+        drainAgentBinaryIngressRoundRobin();
+    }
+
+    function drainAgentBinaryIngressRoundRobin() {
+        if (agentBinaryIngressDraining) {
+            return;
+        }
+        agentBinaryIngressDraining = true;
+        setImmediate(() => {
+            agentBinaryIngressDraining = false;
             let processed = 0;
-            while (state.binaryQueue.length > 0 && processed < AGENT_BINARY_INGRESS_DRAIN_BUDGET_PACKETS) {
+            while (agentBinaryIngressLanes.length > 0 && processed < AGENT_BINARY_INGRESS_DRAIN_BUDGET_PACKETS) {
+                const state = agentBinaryIngressLanes.shift();
+                if (!state) {
+                    continue;
+                }
+
+                state.binaryQueueScheduled = false;
+                const socket = state.binaryQueueSocket;
+                if (state.closed || !socket || socket.destroyed) {
+                    if (Array.isArray(state.binaryQueue)) {
+                        state.binaryQueue.length = 0;
+                    }
+                    continue;
+                }
+
                 const item = state.binaryQueue.shift();
                 if (item) {
                     handleAgentBinaryFrame(socket, state, item.header, item.payload);
                     processed += 1;
                 }
+
+                if (state.binaryQueue.length > 0 && !state.closed && !socket.destroyed) {
+                    state.binaryQueueScheduled = true;
+                    agentBinaryIngressLanes.push(state);
+                }
             }
 
-            if (state.binaryQueue.length > 0 && !state.closed && !socket.destroyed) {
-                drainQueuedAgentBinaryFrames(socket, state);
+            if (agentBinaryIngressLanes.length > 0) {
+                drainAgentBinaryIngressRoundRobin();
             }
         });
     }
@@ -3290,7 +3372,7 @@ export function createRemoteHub(options = {}) {
             dropQueuedAgentBinaryFrame(state);
         }
         state.binaryQueue.push({ header, payload });
-        drainQueuedAgentBinaryFrames(socket, state);
+        scheduleAgentBinaryIngress(socket, state);
     }
 
     function handleAgentMessage(socket, state, message) {
@@ -3436,6 +3518,8 @@ export function createRemoteHub(options = {}) {
             frameOnly: false,
             binaryQueue: [],
             binaryQueueDraining: false,
+            binaryQueueScheduled: false,
+            binaryQueueSocket: null,
             binaryQueueDrops: 0,
             closed: false
         };
@@ -3488,6 +3572,8 @@ export function createRemoteHub(options = {}) {
         const detach = reason => {
             state.closed = true;
             state.binaryQueue.length = 0;
+            state.binaryQueueScheduled = false;
+            state.binaryQueueSocket = null;
             allSockets.delete(socket);
             clearTimeout(helloTimer);
             detachInputSocket(socket, reason);
@@ -3587,6 +3673,8 @@ export function createRemoteHub(options = {}) {
             pendingBinaryFrame: null,
             binaryQueue: [],
             binaryQueueDraining: false,
+            binaryQueueScheduled: false,
+            binaryQueueSocket: null,
             binaryQueueDrops: 0,
             closed: false
         };
@@ -3619,6 +3707,15 @@ export function createRemoteHub(options = {}) {
                 }
 
                 if (state.authenticated && state.frameOnly && state.buffer.length > 0) {
+                    const firstNonWhitespaceIndex = findFirstNonWhitespaceByte(state.buffer);
+                    if (firstNonWhitespaceIndex < 0) {
+                        state.buffer = Buffer.alloc(0);
+                        return;
+                    }
+                    if (firstNonWhitespaceIndex > 0) {
+                        state.buffer = state.buffer.subarray(firstNonWhitespaceIndex);
+                    }
+
                     if (state.buffer.length < TCP_BINARY_FRAME_MAGIC.length && hasTcpBinaryFrameMagicPrefix(state.buffer)) {
                         return;
                     }
@@ -3629,9 +3726,13 @@ export function createRemoteHub(options = {}) {
                             return;
                         }
                         if (!packet || packet.invalid) {
-                            writeJsonLine(socket, { type: 'error', error: 'invalid-tcp-binary-frame' });
-                            logWarn('remote', `invalid tcp binary frame from agent: ${packet?.reason || 'bad-magic'}`);
-                            socket.destroy();
+                            const syncIndex = findTcpFrameOnlySyncIndex(state.buffer, 1);
+                            if (syncIndex > 0) {
+                                state.buffer = state.buffer.subarray(syncIndex);
+                                continue;
+                            }
+
+                            state.buffer = keepTcpFrameOnlySyncTail(state.buffer);
                             return;
                         }
 
@@ -3639,6 +3740,17 @@ export function createRemoteHub(options = {}) {
                         enqueueAgentBinaryFrame(socket, state, packet.header, packet.payload);
                         continue;
                     }
+
+                    if (!isJsonObjectStartByte(state.buffer[0])) {
+                        const syncIndex = findTcpFrameOnlySyncIndex(state.buffer, 1);
+                        if (syncIndex > 0) {
+                            state.buffer = state.buffer.subarray(syncIndex);
+                            continue;
+                        }
+
+                        state.buffer = keepTcpFrameOnlySyncTail(state.buffer);
+                        return;
+                    }
                 }
 
                 const newlineIndex = state.buffer.indexOf(0x0a);
@@ -3676,6 +3788,9 @@ export function createRemoteHub(options = {}) {
 
                     handleAgentMessage(socket, state, message);
                 } catch (err) {
+                    if (state.authenticated && state.frameOnly) {
+                        continue;
+                    }
                     writeJsonLine(socket, { type: 'error', error: 'invalid-json' });
                     logWarn('remote', `invalid agent message: ${err?.message || err}`);
                 }
@@ -3690,6 +3805,8 @@ export function createRemoteHub(options = {}) {
         socket.on('close', () => {
             state.closed = true;
             state.binaryQueue.length = 0;
+            state.binaryQueueScheduled = false;
+            state.binaryQueueSocket = null;
             allSockets.delete(socket);
             clearTimeout(helloTimer);
             detachInputSocket(socket);
@@ -3699,6 +3816,8 @@ export function createRemoteHub(options = {}) {
         socket.on('error', err => {
             state.closed = true;
             state.binaryQueue.length = 0;
+            state.binaryQueueScheduled = false;
+            state.binaryQueueSocket = null;
             allSockets.delete(socket);
             clearTimeout(helloTimer);
             detachInputSocket(socket, err?.message || 'socket-error');

package/hub/src/server.js

@@ -23,7 +23,7 @@ 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 frameBackpressureBytes = readPositiveIntegerEnv('LIVEDESK_FRAME_WS_BACKPRESSURE_BYTES', 16 * 1024 * 1024);
 const frameClientQueuePackets = readPositiveIntegerEnv('LIVEDESK_FRAME_WS_QUEUE_PACKETS', 12);
-const frameClientDrainBudgetPackets = readPositiveIntegerEnv('LIVEDESK_FRAME_WS_DRAIN_BUDGET_PACKETS', 96);
+const frameClientDrainBudgetPackets = readPositiveIntegerEnv('LIVEDESK_FRAME_WS_DRAIN_BUDGET_PACKETS', 8);
 const frameClients = new Set();
 const frameClientsByDeviceId = new Map();
 const frameWildcardClients = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livedesk",
-  "version": "0.1.124",
+  "version": "0.1.126",
   "description": "LiveDesk Hub and client launcher",
   "type": "module",
   "bin": {