@mindexec/cli 0.2.40 → 0.2.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.40",
+  "version": "0.2.41",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",

package/remote-hub.js

@@ -9,6 +9,8 @@ const DEFAULT_AGENT_TASK_TIMEOUT_MS = 120000;
 const MAX_LINE_CHARS = 4 * 1024 * 1024;
 const MAX_THUMBNAIL_BASE64_CHARS = 3 * 1024 * 1024;
 const MAX_STREAM_BASE64_CHARS = 3 * 1024 * 1024;
+const MAX_THUMBNAIL_BINARY_BYTES = Math.floor(MAX_THUMBNAIL_BASE64_CHARS * 3 / 4);
+const MAX_STREAM_BINARY_BYTES = Math.floor(MAX_STREAM_BASE64_CHARS * 3 / 4);
 const MAX_AGENT_TASK_CHARS = 4000;
 const MAX_AGENT_TASK_RESULT_CHARS = 3000;
 const RECENT_TASK_LIMIT = 12;
@@ -1075,6 +1077,161 @@ export function createRemoteHub(options = {}) {
         return task;
     }
 
+    function normalizeFrameByteLength(framePayload, frameData = '') {
+        if (Buffer.isBuffer(framePayload)) {
+            return framePayload.length;
+        }
+
+        return Math.floor(String(frameData || '').length * 3 / 4);
+    }
+
+    function buildFrameDataUrl(framePayload, frameData, mimeType) {
+        if (Buffer.isBuffer(framePayload)) {
+            return `data:${mimeType};base64,${framePayload.toString('base64')}`;
+        }
+
+        return String(frameData || '').startsWith('data:')
+            ? String(frameData || '')
+            : `data:${mimeType};base64,${frameData}`;
+    }
+
+    function applyThumbnailFrame(device, message, framePayload, transport = 'json-base64') {
+        const frameData = Buffer.isBuffer(framePayload)
+            ? ''
+            : safeString(framePayload, MAX_THUMBNAIL_BASE64_CHARS + 1);
+        const frameSeq = Number(message.frameSeq);
+        const byteLength = normalizeFrameByteLength(framePayload, frameData);
+        if ((!Buffer.isBuffer(framePayload) && !frameData)
+            || byteLength > MAX_THUMBNAIL_BINARY_BYTES
+            || !Number.isFinite(frameSeq)) {
+            device.counters.thumbnailFramesDropped += 1;
+            emitRemoteEvent('RemoteFrameDropped', device, {
+                reason: 'invalid-thumbnail-frame',
+                frameSeq: Number.isFinite(frameSeq) ? frameSeq : null,
+                transport
+            });
+            return false;
+        }
+
+        const mimeType = safeString(message.mimeType || message.format || 'image/jpeg', 80) || 'image/jpeg';
+        const capturedAt = safeString(message.capturedAt, 80) || device.lastSeenAt;
+        device.latestThumbnail = {
+            streamId: safeString(message.streamId, 128) || 'thumbnail',
+            frameSeq,
+            commandId: safeString(message.commandId, 128),
+            width: Number.isFinite(Number(message.width)) ? Number(message.width) : 0,
+            height: Number.isFinite(Number(message.height)) ? Number(message.height) : 0,
+            mimeType,
+            format: mimeType,
+            capturedAt,
+            receivedAt: device.lastSeenAt,
+            byteLength,
+            transport,
+            dataUrl: buildFrameDataUrl(framePayload, frameData, mimeType)
+        };
+        device.counters.thumbnailFramesReceived += 1;
+        emitRemoteEvent('RemoteFrameReceived', device, {
+            streamId: device.latestThumbnail.streamId,
+            frameSeq,
+            width: device.latestThumbnail.width,
+            height: device.latestThumbnail.height,
+            transport
+        });
+        return true;
+    }
+
+    function applyLiveFrame(device, message, framePayload, transport = 'json-base64') {
+        const frameData = Buffer.isBuffer(framePayload)
+            ? ''
+            : safeString(framePayload, MAX_STREAM_BASE64_CHARS + 1);
+        const frameSeq = Number(message.frameSeq);
+        const streamId = safeString(message.streamId, 128) || 'live';
+        if (!device.activeLiveStream?.active || device.activeLiveStream.streamId !== streamId) {
+            device.counters.liveFramesDropped += 1;
+            emitRemoteEvent('RemoteFrameDropped', device, {
+                reason: 'stale-live-stream-frame',
+                streamId,
+                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)) {
+            device.counters.liveFramesDropped += 1;
+            emitRemoteEvent('RemoteFrameDropped', device, {
+                reason: 'invalid-live-frame',
+                streamId,
+                frameSeq: Number.isFinite(frameSeq) ? frameSeq : null,
+                transport
+            });
+            return false;
+        }
+
+        const mimeType = safeString(message.mimeType || message.format || 'image/jpeg', 80) || 'image/jpeg';
+        const capturedAt = safeString(message.capturedAt, 80) || device.lastSeenAt;
+        device.latestLiveFrame = {
+            streamId,
+            frameSeq,
+            commandId: safeString(message.commandId, 128),
+            width: Number.isFinite(Number(message.width)) ? Number(message.width) : 0,
+            height: Number.isFinite(Number(message.height)) ? Number(message.height) : 0,
+            mimeType,
+            format: mimeType,
+            mode: safeString(message.mode || device.activeLiveStream.mode || 'remote-fast', 80),
+            fps: Number.isFinite(Number(message.fps)) ? Number(message.fps) : device.activeLiveStream.fps,
+            capturedAt,
+            receivedAt: device.lastSeenAt,
+            byteLength,
+            transport,
+            dataUrl: buildFrameDataUrl(framePayload, frameData, mimeType)
+        };
+        device.activeLiveStream.lastFrameAt = device.lastSeenAt;
+        device.activeLiveStream.lastFrameSeq = frameSeq;
+        device.activeLiveStream.framesReceived = (device.activeLiveStream.framesReceived || 0) + 1;
+        device.counters.liveFramesReceived += 1;
+        emitRemoteEvent('RemoteFrameReceived', device, {
+            streamId,
+            frameSeq,
+            width: device.latestLiveFrame.width,
+            height: device.latestLiveFrame.height,
+            mode: device.latestLiveFrame.mode,
+            transport
+        });
+        return true;
+    }
+
+    function handleAgentBinaryFrame(socket, state, header, framePayload) {
+        if (!state.authenticated || !state.device) {
+            writeJsonLine(socket, { type: 'error', error: 'hello-required' });
+            socket.destroy();
+            return;
+        }
+
+        const device = state.device;
+        device.counters.messagesReceived += 1;
+        device.lastSeenAt = new Date().toISOString();
+
+        const frameKind = safeString(header.frameKind || header.kind || header.frameType || '', 40).toLowerCase();
+        if (frameKind === 'thumbnail' || header.type === 'thumbnail.binary') {
+            applyThumbnailFrame(device, header, framePayload, 'binary');
+            return;
+        }
+
+        if (frameKind === 'stream' || frameKind === 'live' || header.type === 'stream.binary') {
+            applyLiveFrame(device, header, framePayload, 'binary');
+            return;
+        }
+
+        emitRemoteEvent('RemoteAgentMessageIgnored', device, {
+            messageType: safeString(header.type, 80),
+            frameKind
+        });
+    }
+
     function handleAgentMessage(socket, state, message) {
         if (!message || typeof message !== 'object') {
             return;
@@ -1139,97 +1296,11 @@ export function createRemoteHub(options = {}) {
                 });
                 break;
             case 'thumbnail.frame': {
-                const frameData = safeString(message.data, MAX_THUMBNAIL_BASE64_CHARS + 1);
-                const frameSeq = Number(message.frameSeq);
-                if (!frameData || frameData.length > MAX_THUMBNAIL_BASE64_CHARS || !Number.isFinite(frameSeq)) {
-                    device.counters.thumbnailFramesDropped += 1;
-                    emitRemoteEvent('RemoteFrameDropped', device, {
-                        reason: 'invalid-thumbnail-frame',
-                        frameSeq: Number.isFinite(frameSeq) ? frameSeq : null
-                    });
-                    break;
-                }
-
-                const mimeType = safeString(message.mimeType || message.format || 'image/jpeg', 80) || 'image/jpeg';
-                const capturedAt = safeString(message.capturedAt, 80) || device.lastSeenAt;
-                device.latestThumbnail = {
-                    streamId: safeString(message.streamId, 128) || 'thumbnail',
-                    frameSeq,
-                    commandId: safeString(message.commandId, 128),
-                    width: Number.isFinite(Number(message.width)) ? Number(message.width) : 0,
-                    height: Number.isFinite(Number(message.height)) ? Number(message.height) : 0,
-                    mimeType,
-                    format: mimeType,
-                    capturedAt,
-                    receivedAt: device.lastSeenAt,
-                    byteLength: Math.floor(frameData.length * 3 / 4),
-                    dataUrl: frameData.startsWith('data:')
-                        ? frameData
-                        : `data:${mimeType};base64,${frameData}`
-                };
-                device.counters.thumbnailFramesReceived += 1;
-                emitRemoteEvent('RemoteFrameReceived', device, {
-                    streamId: device.latestThumbnail.streamId,
-                    frameSeq,
-                    width: device.latestThumbnail.width,
-                    height: device.latestThumbnail.height
-                });
+                applyThumbnailFrame(device, message, message.data, 'json-base64');
                 break;
             }
             case 'stream.frame': {
-                const frameData = safeString(message.data, MAX_STREAM_BASE64_CHARS + 1);
-                const frameSeq = Number(message.frameSeq);
-                const streamId = safeString(message.streamId, 128) || 'live';
-                if (!device.activeLiveStream?.active || device.activeLiveStream.streamId !== streamId) {
-                    device.counters.liveFramesDropped += 1;
-                    emitRemoteEvent('RemoteFrameDropped', device, {
-                        reason: 'stale-live-stream-frame',
-                        streamId,
-                        frameSeq: Number.isFinite(frameSeq) ? frameSeq : null
-                    });
-                    break;
-                }
-
-                if (!frameData || frameData.length > MAX_STREAM_BASE64_CHARS || !Number.isFinite(frameSeq)) {
-                    device.counters.liveFramesDropped += 1;
-                    emitRemoteEvent('RemoteFrameDropped', device, {
-                        reason: 'invalid-live-frame',
-                        streamId,
-                        frameSeq: Number.isFinite(frameSeq) ? frameSeq : null
-                    });
-                    break;
-                }
-
-                const mimeType = safeString(message.mimeType || message.format || 'image/jpeg', 80) || 'image/jpeg';
-                const capturedAt = safeString(message.capturedAt, 80) || device.lastSeenAt;
-                device.latestLiveFrame = {
-                    streamId,
-                    frameSeq,
-                    commandId: safeString(message.commandId, 128),
-                    width: Number.isFinite(Number(message.width)) ? Number(message.width) : 0,
-                    height: Number.isFinite(Number(message.height)) ? Number(message.height) : 0,
-                    mimeType,
-                    format: mimeType,
-                    mode: safeString(message.mode || device.activeLiveStream.mode || 'remote-fast', 80),
-                    fps: Number.isFinite(Number(message.fps)) ? Number(message.fps) : device.activeLiveStream.fps,
-                    capturedAt,
-                    receivedAt: device.lastSeenAt,
-                    byteLength: Math.floor(frameData.length * 3 / 4),
-                    dataUrl: frameData.startsWith('data:')
-                        ? frameData
-                        : `data:${mimeType};base64,${frameData}`
-                };
-                device.activeLiveStream.lastFrameAt = device.lastSeenAt;
-                device.activeLiveStream.lastFrameSeq = frameSeq;
-                device.activeLiveStream.framesReceived = (device.activeLiveStream.framesReceived || 0) + 1;
-                device.counters.liveFramesReceived += 1;
-                emitRemoteEvent('RemoteFrameReceived', device, {
-                    streamId,
-                    frameSeq,
-                    width: device.latestLiveFrame.width,
-                    height: device.latestLiveFrame.height,
-                    mode: device.latestLiveFrame.mode
-                });
+                applyLiveFrame(device, message, message.data, 'json-base64');
                 break;
             }
             default:
@@ -1242,14 +1313,14 @@ export function createRemoteHub(options = {}) {
 
     function handleSocket(socket) {
         allSockets.add(socket);
-        socket.setEncoding('utf8');
         socket.setNoDelay(true);
         socket.setKeepAlive(true, heartbeatMs);
 
         const state = {
             authenticated: false,
             device: null,
-            buffer: ''
+            buffer: Buffer.alloc(0),
+            pendingBinaryFrame: null
         };
 
         const helloTimer = setTimeout(() => {
@@ -1260,27 +1331,63 @@ export function createRemoteHub(options = {}) {
         }, 10000);
 
         socket.on('data', chunk => {
-            state.buffer += chunk;
-            if (state.buffer.length > MAX_LINE_CHARS) {
-                writeJsonLine(socket, { type: 'error', error: 'message-too-large' });
-                socket.destroy();
-                return;
-            }
+            const incoming = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            state.buffer = state.buffer.length > 0
+                ? Buffer.concat([state.buffer, incoming])
+                : incoming;
+
+            while (!socket.destroyed) {
+                if (state.pendingBinaryFrame) {
+                    const { header, byteLength } = state.pendingBinaryFrame;
+                    if (state.buffer.length < byteLength) {
+                        return;
+                    }
+
+                    const framePayload = state.buffer.subarray(0, byteLength);
+                    state.buffer = state.buffer.subarray(byteLength);
+                    state.pendingBinaryFrame = null;
+                    handleAgentBinaryFrame(socket, state, header, framePayload);
+                    continue;
+                }
+
+                const newlineIndex = state.buffer.indexOf(0x0a);
+                if (newlineIndex < 0) {
+                    if (state.buffer.length > MAX_LINE_CHARS) {
+                        writeJsonLine(socket, { type: 'error', error: 'message-too-large' });
+                        socket.destroy();
+                    }
+                    return;
+                }
 
-            let newlineIndex = state.buffer.indexOf('\n');
-            while (newlineIndex >= 0) {
-                const line = state.buffer.slice(0, newlineIndex);
-                state.buffer = state.buffer.slice(newlineIndex + 1);
+                const lineBuffer = state.buffer.subarray(0, newlineIndex);
+                state.buffer = state.buffer.subarray(newlineIndex + 1);
 
                 try {
-                    const message = parseJsonLine(line);
+                    const message = parseJsonLine(lineBuffer.toString('utf8'));
+                    if (message?.type === 'frame.binary') {
+                        const frameKind = safeString(message.frameKind || message.kind || message.frameType, 40).toLowerCase();
+                        const maxBytes = frameKind === 'thumbnail'
+                            ? MAX_THUMBNAIL_BINARY_BYTES
+                            : MAX_STREAM_BINARY_BYTES;
+                        const byteLength = Number(message.byteLength ?? message.payloadBytes ?? message.dataLength);
+                        if (!Number.isFinite(byteLength) || byteLength < 1 || byteLength > maxBytes) {
+                            writeJsonLine(socket, { type: 'error', error: 'invalid-binary-frame' });
+                            logWarn('remote', 'invalid binary frame header from agent.');
+                            continue;
+                        }
+
+                        state.pendingBinaryFrame = {
+                            header: message,
+                            byteLength: Math.floor(byteLength)
+                        };
+                        continue;
+                    }
+
                     handleAgentMessage(socket, state, message);
                 } catch (err) {
                     writeJsonLine(socket, { type: 'error', error: 'invalid-json' });
                     logWarn('remote', `invalid agent message: ${err?.message || err}`);
                 }
-
-                newlineIndex = state.buffer.indexOf('\n');
             }
         });
 

package/scripts/remote-http-smoke.mjs

@@ -5,10 +5,13 @@ import net from 'node:net';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
 
 const BRIDGE_TOKEN = 'remote-http-smoke-token';
 const PAIR_TOKEN = 'remote-http-pair-token';
 const SYNTHETIC_COUNT = Number(process.env.REMOTE_HTTP_SMOKE_COUNT || 500);
+const LOCAL_BRIDGE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const LOCAL_BRIDGE_PACKAGE = JSON.parse(readFileSync(path.join(LOCAL_BRIDGE_DIR, 'package.json'), 'utf8'));
 
 function wait(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
@@ -155,7 +158,7 @@ async function runSyntheticEnabledSmoke() {
     assert.equal(status.started, true);
     assert.equal(status.port, remoteHubPort);
     assert.equal(status.managerPackage, '@mindexec/cli');
-    assert.equal(status.managerVersion, '0.2.25');
+    assert.equal(status.managerVersion, LOCAL_BRIDGE_PACKAGE.version);
     assert.equal(status.agentPackage, '@mindexec/remote');
     assert.equal(status.canvasPagination, 'none');
     assert.equal(status.canvasDeviceListMode, 'all-devices');

package/scripts/remote-hub-smoke.mjs

@@ -8,6 +8,16 @@ function writeJsonLine(socket, payload) {
     socket.write(`${JSON.stringify(payload)}\n`);
 }
 
+function writeBinaryFrame(socket, header, payload) {
+    const framePayload = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+    socket.write(`${JSON.stringify({
+        ...header,
+        type: 'frame.binary',
+        byteLength: framePayload.length
+    })}\n`);
+    socket.write(framePayload);
+}
+
 function wait(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
@@ -34,6 +44,7 @@ const hub = createRemoteHub({
         REMOTE_HUB_TASK_TIMEOUT_MS: '120'
     }
 });
+const smokePngFrame = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC', 'base64');
 
 try {
     await hub.start();
@@ -115,6 +126,33 @@ try {
     assert.equal(thumbnailDevice.latestThumbnail.streamId, 'smoke-thumb');
     assert.equal(thumbnailDevice.counters.thumbnailFramesReceived, 1);
 
+    const binaryThumbnailCommand = hub.requestThumbnail('smoke-device', {
+        streamId: 'smoke-thumb-binary',
+        maxWidth: 320,
+        maxHeight: 180,
+        quality: 50
+    });
+    assert.equal(binaryThumbnailCommand.ok, true);
+    writeBinaryFrame(socket, {
+        frameKind: 'thumbnail',
+        commandId: binaryThumbnailCommand.commandId,
+        streamId: 'smoke-thumb-binary',
+        frameSeq: 4,
+        width: 2,
+        height: 1,
+        mimeType: 'image/png',
+        capturedAt: new Date().toISOString()
+    }, smokePngFrame);
+
+    const binaryThumbnailDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.latestThumbnail?.frameSeq === 4 ? current[0] : null;
+    });
+    assert.equal(binaryThumbnailDevice.latestThumbnail.streamId, 'smoke-thumb-binary');
+    assert.equal(binaryThumbnailDevice.latestThumbnail.transport, 'binary');
+    assert.equal(binaryThumbnailDevice.latestThumbnail.byteLength, smokePngFrame.length);
+    assert.equal(binaryThumbnailDevice.counters.thumbnailFramesReceived, 2);
+
     const liveCommand = hub.startLiveStream('smoke-device', {
         streamId: 'smoke-live',
         fps: 5,
@@ -145,6 +183,28 @@ try {
     assert.equal(liveDevice.latestLiveFrame.mode, 'remote-fast');
     assert.equal(liveDevice.counters.liveFramesReceived, 1);
 
+    writeBinaryFrame(socket, {
+        frameKind: 'stream',
+        commandId: liveCommand.commandId,
+        streamId: 'smoke-live',
+        frameSeq: 5,
+        width: 2,
+        height: 1,
+        mimeType: 'image/png',
+        mode: 'remote-fast',
+        fps: 5,
+        capturedAt: new Date().toISOString()
+    }, smokePngFrame);
+
+    const binaryLiveDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.latestLiveFrame?.frameSeq === 5 ? current[0] : null;
+    });
+    assert.equal(binaryLiveDevice.latestLiveFrame.streamId, 'smoke-live');
+    assert.equal(binaryLiveDevice.latestLiveFrame.transport, 'binary');
+    assert.equal(binaryLiveDevice.latestLiveFrame.byteLength, smokePngFrame.length);
+    assert.equal(binaryLiveDevice.counters.liveFramesReceived, 2);
+
     const staleFrameBefore = liveDevice.counters.liveFramesDropped;
     writeJsonLine(socket, {
         type: 'stream.frame',