@mindexec/cli 0.2.478 → 0.2.480

package/scripts/remote-fast-mdm-browser-smoke.mjs

@@ -1,453 +1,453 @@
-#!/usr/bin/env node
-
-import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
-import { mkdtemp, rm } from 'node:fs/promises';
-import net from 'node:net';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-
-const BRIDGE_TOKEN = 'remote-fast-mdm-browser-smoke-token';
-const PAIR_TOKEN = 'remote-fast-mdm-browser-pair-token';
-const LEASE_ID = 'remote-fast-mdm-browser-lease';
-const LOCAL_BRIDGE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const REQUESTED_FPS = Number(process.env.MINDEXEC_REMOTE_MDM_BROWSER_REQUEST_FPS || 12);
-const SAMPLE_MS = Number(process.env.MINDEXEC_REMOTE_MDM_BROWSER_SAMPLE_MS || 1500);
-const MIN_PAINT_FPS = Number(process.env.MINDEXEC_REMOTE_MDM_BROWSER_MIN_PAINT_FPS || 8);
-
-function wait(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-async function findFreePort() {
-    return await new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.unref();
-        server.once('error', reject);
-        server.listen(0, '127.0.0.1', () => {
-            const address = server.address();
-            const port = typeof address === 'object' && address ? address.port : 0;
-            server.close(() => resolve(port));
-        });
-    });
-}
-
-async function fetchJson(url, options = {}) {
-    const response = await fetch(url, {
-        ...options,
-        headers: {
-            ...(options.body ? { 'Content-Type': 'application/json' } : {}),
-            'X-Bridge-Token': BRIDGE_TOKEN,
-            ...(options.headers || {})
-        }
-    });
-
-    const payload = await response.json().catch(() => null);
-    return { status: response.status, ok: response.ok, payload };
-}
-
-async function waitFor(predicate, timeoutMs = 30000, label = 'condition') {
-    const startedAt = Date.now();
-    let lastError = null;
-    while (Date.now() - startedAt < timeoutMs) {
-        try {
-            const value = await predicate();
-            if (value) {
-                return value;
-            }
-        } catch (error) {
-            lastError = error;
-        }
-
-        await wait(100);
-    }
-
-    throw new Error(`Timed out waiting for ${label}${lastError ? `: ${lastError.message}` : ''}.`);
-}
-
-function spawnBridge({ bridgePort, remoteHubPort, workspacePath, label, traceFrames = false }) {
-    const child = spawn(process.execPath, ['server.js'], {
-        cwd: LOCAL_BRIDGE_DIR,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        windowsHide: true,
-        env: {
-            ...process.env,
-            BRIDGE_PORT: String(bridgePort),
-            BRIDGE_TOKEN,
-            BRIDGE_REQUIRE_TOKEN: '1',
-            MINDEXEC_REMOTE_HUB: '1',
-            MINDEXEC_REMOTE_TRACE_FRAMES: traceFrames ? '1' : '',
-            MINDEXEC_REMOTE_REGISTRY_FOLLOWER: '0',
-            MINDEXEC_REMOTE_REGISTRY_REALTIME: '0',
-            MINDEXEC_REMOTE_HOST_TARGET_AUTO_RENEW: '0',
-            REMOTE_HUB_HOST: '127.0.0.1',
-            REMOTE_HUB_PORT: String(remoteHubPort),
-            REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN,
-            WORKSPACE_PATH: workspacePath,
-            NO_COLOR: '1'
-        }
-    });
-
-    let stdout = '';
-    let stderr = '';
-    child.stdout.on('data', chunk => {
-        stdout += chunk.toString();
-    });
-    child.stderr.on('data', chunk => {
-        stderr += chunk.toString();
-    });
-
-    const exitPromise = new Promise(resolve => child.once('exit', resolve));
-    const details = () => `${label} stdout=${stdout}\n${label} stderr=${stderr}`;
-    const stop = async () => {
-        if (child.exitCode === null && !child.killed) {
-            child.kill('SIGTERM');
-            await Promise.race([exitPromise, wait(5000)]);
-            if (child.exitCode === null && !child.killed) {
-                child.kill('SIGKILL');
-            }
-        }
-    };
-
-    return {
-        baseUrl: `http://127.0.0.1:${bridgePort}`,
-        child,
-        details,
-        stop
-    };
-}
-
-async function waitForBridge(bridge) {
-    return await waitFor(async () => {
-        const result = await fetchJson(`${bridge.baseUrl}/api/status`);
-        return result.ok && result.payload?.status === 'ok' ? result.payload : null;
-    }, 30000, `bridge startup\n${bridge.details()}`);
-}
-
-async function loadPlaywrightChromium() {
-    const candidates = [
-        path.join(LOCAL_BRIDGE_DIR, 'node_modules', 'playwright', 'index.js'),
-        path.join(LOCAL_BRIDGE_DIR, 'node_modules', 'playwright-core', 'index.mjs'),
-        path.join(LOCAL_BRIDGE_DIR, 'node_modules', 'playwright-core', 'index.js')
-    ];
-
-    let lastError = null;
-    for (const candidate of candidates) {
-        try {
-            const mod = await import(pathToFileURL(candidate).href);
-            if (mod.chromium) {
-                return mod.chromium;
-            }
-        } catch (error) {
-            lastError = error;
-        }
-    }
-
-    throw new Error(`Playwright chromium is unavailable: ${lastError?.message || 'not installed'}`);
-}
-
-async function launchBrowser(chromium) {
-    const launchers = [
-        () => chromium.launch({ channel: 'chrome', headless: true }),
-        () => chromium.launch({ channel: 'msedge', headless: true }),
-        () => chromium.launch({ headless: true })
-    ];
-
-    let lastError = null;
-    for (const launch of launchers) {
-        try {
-            return await launch();
-        } catch (error) {
-            lastError = error;
-        }
-    }
-
-    throw new Error(`Unable to launch a Chromium browser: ${lastError?.message || 'unknown error'}`);
-}
-
-async function paintRemoteFramesInBrowser(page, wsUrl, deviceId, fps = REQUESTED_FPS) {
-    await page.setContent(`
-        <!doctype html>
-        <meta charset="utf-8">
-        <canvas id="screen" width="320" height="180"></canvas>
-    `);
-
-    return await page.evaluate(async ({ wsUrl, deviceId, fps, sampleMs, minPaintFps }) => {
-        const canvas = document.getElementById('screen');
-        const context = canvas.getContext('2d', { alpha: false, desynchronized: true }) || canvas.getContext('2d');
-        if (!context) {
-            throw new Error('canvas-2d-context-unavailable');
-        }
-        if (typeof createImageBitmap !== 'function') {
-            throw new Error('createImageBitmap-unavailable');
-        }
-
-        function parsePacket(buffer) {
-            const view = new DataView(buffer);
-            const metaLength = view.getUint32(0);
-            if (!Number.isFinite(metaLength) || metaLength <= 0 || metaLength > 64 * 1024 || 4 + metaLength >= buffer.byteLength) {
-                throw new Error('invalid-frame-packet');
-            }
-
-            const metadataBytes = new Uint8Array(buffer, 4, metaLength);
-            const metadata = JSON.parse(new TextDecoder().decode(metadataBytes));
-            const payload = buffer.slice(4 + metaLength);
-            return { metadata, payload };
-        }
-
-        return await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                try {
-                    ws?.close();
-                } catch {
-                    // ignore close failure
-                }
-                reject(new Error('timed-out-waiting-for-mdm-frames'));
-            }, 20000);
-            const ws = new WebSocket(wsUrl);
-            const painted = [];
-            const receivedSeqs = [];
-            let firstPaintAt = 0;
-            let lastPaintAt = 0;
-            let processing = false;
-            let pendingPacket = null;
-            let settled = false;
-
-            function finishIfReady() {
-                if (settled || painted.length < 2 || !firstPaintAt || !lastPaintAt) {
-                    return;
-                }
-
-                const elapsedMs = lastPaintAt - firstPaintAt;
-                if (elapsedMs < sampleMs) {
-                    return;
-                }
-
-                const uniqueSeqs = new Set(painted.map(item => item.frameSeq));
-                const paintFps = painted.length > 1
-                    ? ((painted.length - 1) * 1000) / Math.max(1, elapsedMs)
-                    : 0;
-                if (paintFps < minPaintFps) {
-                    return;
-                }
-
-                settled = true;
-                clearTimeout(timeout);
-                ws.onclose = null;
-                try {
-                    ws.close();
-                } catch {
-                    // ignore close failure
-                }
-                resolve({
-                    framesReceived: receivedSeqs.length,
-                    framesPainted: painted.length,
-                    uniqueSeqs: uniqueSeqs.size,
-                    firstSeq: painted[0]?.frameSeq || 0,
-                    lastSeq: painted[painted.length - 1]?.frameSeq || 0,
-                    durationMs: elapsedMs,
-                    paintFps,
-                    fps: painted[painted.length - 1]?.fps || 0,
-                    width: painted[painted.length - 1]?.width || 0,
-                    height: painted[painted.length - 1]?.height || 0,
-                    minBytes: Math.min(...painted.map(item => item.byteLength).filter(value => value > 0)),
-                    maxBytes: Math.max(...painted.map(item => item.byteLength).filter(value => value > 0)),
-                    mimeType: painted[painted.length - 1]?.mimeType || '',
-                    transport: painted[painted.length - 1]?.transport || ''
-                });
-            }
-
-            async function paintPacket(packet) {
-                const { metadata, payload } = packet;
-                const blob = new Blob([payload], { type: metadata.mimeType || 'image/jpeg' });
-                const bitmap = await createImageBitmap(blob);
-                context.drawImage(bitmap, 0, 0, canvas.width, canvas.height);
-                bitmap.close?.();
-                const now = performance.now();
-                const frameSeq = Number(metadata.frameSeq || 0);
-                if (!firstPaintAt) {
-                    firstPaintAt = now;
-                }
-                lastPaintAt = now;
-                painted.push({
-                    frameSeq,
-                    fps: Number(metadata.fps || 0),
-                    width: Number(metadata.width || 0),
-                    height: Number(metadata.height || 0),
-                    byteLength: Number(metadata.byteLength || payload.byteLength || 0),
-                    mimeType: String(metadata.mimeType || ''),
-                    transport: String(metadata.transport || '')
-                });
-                finishIfReady();
-            }
-
-            async function processLatest(packet) {
-                pendingPacket = packet;
-                if (processing) {
-                    return;
-                }
-
-                processing = true;
-                try {
-                    while (pendingPacket && !settled) {
-                        const next = pendingPacket;
-                        pendingPacket = null;
-                        await paintPacket(next);
-                    }
-                } catch (error) {
-                    settled = true;
-                    clearTimeout(timeout);
-                    try {
-                        ws.close();
-                    } catch {
-                        // ignore close failure
-                    }
-                    reject(error);
-                } finally {
-                    processing = false;
-                }
-            }
-
-            ws.binaryType = 'arraybuffer';
-            ws.onopen = () => {
-                ws.send(JSON.stringify({
-                    type: 'subscribe',
-                    deviceIds: [deviceId],
-                    autoStartLive: true,
-                    fps,
-                    maxWidth: 960,
-                    maxHeight: 540,
-                    quality: 60
-                }));
-            };
-            ws.onerror = () => {
-                clearTimeout(timeout);
-                reject(new Error('remote-frame-websocket-error'));
-            };
-            ws.onclose = () => {
-                clearTimeout(timeout);
-                reject(new Error('remote-frame-websocket-closed-before-paint'));
-            };
-            ws.onmessage = async event => {
-                if (typeof event.data === 'string') {
-                    return;
-                }
-
-                try {
-                    const { metadata, payload } = parsePacket(event.data);
-                    if (String(metadata.type || '').toLowerCase() !== 'remote.frame.binary'
-                        || String(metadata.kind || '').toLowerCase() !== 'live'
-                        || String(metadata.deviceId || '') !== deviceId) {
-                        return;
-                    }
-
-                    if (metadata.dataUrl || metadata.framePath || metadata.frameUrl) {
-                        throw new Error('binary-ws-metadata-must-not-carry-frame-url-or-data-url');
-                    }
-
-                    receivedSeqs.push(Number(metadata.frameSeq || 0));
-                    await processLatest({ metadata, payload });
-                } catch (error) {
-                    if (!settled) {
-                        settled = true;
-                        clearTimeout(timeout);
-                        try {
-                            ws.close();
-                        } catch {
-                            // ignore close failure
-                        }
-                        reject(error);
-                    }
-                }
-            };
-        });
-    }, { wsUrl, deviceId, fps, sampleMs: SAMPLE_MS, minPaintFps: MIN_PAINT_FPS });
-}
-
-async function main() {
-    const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'mindexec-remote-mdm-browser-'));
-    const hostWorkspace = path.join(tempRoot, 'host');
-    const clientWorkspace = path.join(tempRoot, 'client');
-    const hostBridgePort = await findFreePort();
-    const hostRemotePort = await findFreePort();
-    const clientBridgePort = await findFreePort();
-    const clientRemotePort = await findFreePort();
-    const managerEndpoint = `127.0.0.1:${hostRemotePort}`;
-    let hostBridge = null;
-    let clientBridge = null;
-    let browser = null;
-
-    try {
-        hostBridge = spawnBridge({
-            bridgePort: hostBridgePort,
-            remoteHubPort: hostRemotePort,
-            workspacePath: hostWorkspace,
-            label: 'host'
-        });
-        await waitForBridge(hostBridge);
-
-        clientBridge = spawnBridge({
-            bridgePort: clientBridgePort,
-            remoteHubPort: clientRemotePort,
-            workspacePath: clientWorkspace,
-            label: 'client',
-            traceFrames: true
-        });
-        await waitForBridge(clientBridge);
-
-        const connectResult = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/connect`, {
-            method: 'POST',
-            body: JSON.stringify({
-                managerCandidates: [managerEndpoint],
-                pairToken: PAIR_TOKEN,
-                leaseId: LEASE_ID,
-                nodeId: 'remote-fast-mdm-browser-node',
-                engine: 'auto',
-                source: 'mdm-browser-smoke'
-            })
-        });
-        assert.equal(connectResult.ok, true, JSON.stringify(connectResult.payload));
-        assert.equal(connectResult.payload?.ok, true, JSON.stringify(connectResult.payload));
-        assert.equal(connectResult.payload?.agent?.usingNpx, false, JSON.stringify(connectResult.payload?.agent));
-        assert.match(String(connectResult.payload?.agent?.launcher || ''), /mindexec-remote-fast/i);
-
-        const device = await waitFor(async () => {
-            const result = await fetchJson(`${hostBridge.baseUrl}/api/remote/devices`);
-            return result.payload?.devices?.find(item =>
-                item.connected === true
-                && item.capabilities?.liveStream === true
-                && item.capabilities?.binaryFrames === true) || null;
-        }, 15000, `RemoteFast device registration\n${hostBridge.details()}\n${clientBridge.details()}`);
-
-        const chromium = await loadPlaywrightChromium();
-        browser = await launchBrowser(chromium);
-        const page = await browser.newPage();
-        const wsUrl = `${hostBridge.baseUrl.replace(/^http:/, 'ws:')}/api/remote/frames/ws?token=${encodeURIComponent(BRIDGE_TOKEN)}`;
-        const painted = await paintRemoteFramesInBrowser(page, wsUrl, device.deviceId, REQUESTED_FPS);
-        assert.ok(painted.framesReceived >= painted.framesPainted, JSON.stringify(painted));
-        assert.ok(painted.framesPainted >= Math.max(4, Math.floor((SAMPLE_MS / 1000) * MIN_PAINT_FPS)), JSON.stringify(painted));
-        assert.ok(painted.uniqueSeqs >= painted.framesPainted - 1, JSON.stringify(painted));
-        assert.ok(painted.lastSeq > painted.firstSeq, JSON.stringify(painted));
-        assert.ok(painted.paintFps >= MIN_PAINT_FPS, JSON.stringify(painted));
-        assert.equal(painted.fps, REQUESTED_FPS, JSON.stringify(painted));
-        assert.ok(painted.width > 0 && painted.height > 0, JSON.stringify(painted));
-        assert.ok(painted.minBytes > 0 && painted.maxBytes >= painted.minBytes, JSON.stringify(painted));
-        assert.match(painted.mimeType, /^image\/(jpeg|png|webp)$/i, JSON.stringify(painted));
-
-        console.log(`RemoteFast MDM browser smoke OK (${painted.framesPainted} paints, ${painted.paintFps.toFixed(1)} fps, seq ${painted.firstSeq}-${painted.lastSeq}, ${painted.width}x${painted.height}, ${painted.minBytes}-${painted.maxBytes} bytes)`);
-    } finally {
-        if (browser) {
-            await browser.close().catch(() => undefined);
-        }
-        if (clientBridge) {
-            await clientBridge.stop();
-        }
-        if (hostBridge) {
-            await hostBridge.stop();
-        }
-        await rm(tempRoot, { recursive: true, force: true });
-    }
-}
-
-await main();
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const BRIDGE_TOKEN = 'remote-fast-mdm-browser-smoke-token';
+const PAIR_TOKEN = 'remote-fast-mdm-browser-pair-token';
+const LEASE_ID = 'remote-fast-mdm-browser-lease';
+const LOCAL_BRIDGE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const REQUESTED_FPS = Number(process.env.MINDEXEC_REMOTE_MDM_BROWSER_REQUEST_FPS || 12);
+const SAMPLE_MS = Number(process.env.MINDEXEC_REMOTE_MDM_BROWSER_SAMPLE_MS || 1500);
+const MIN_PAINT_FPS = Number(process.env.MINDEXEC_REMOTE_MDM_BROWSER_MIN_PAINT_FPS || 8);
+
+function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function findFreePort() {
+    return await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            server.close(() => resolve(port));
+        });
+    });
+}
+
+async function fetchJson(url, options = {}) {
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+            'X-Bridge-Token': BRIDGE_TOKEN,
+            ...(options.headers || {})
+        }
+    });
+
+    const payload = await response.json().catch(() => null);
+    return { status: response.status, ok: response.ok, payload };
+}
+
+async function waitFor(predicate, timeoutMs = 30000, label = 'condition') {
+    const startedAt = Date.now();
+    let lastError = null;
+    while (Date.now() - startedAt < timeoutMs) {
+        try {
+            const value = await predicate();
+            if (value) {
+                return value;
+            }
+        } catch (error) {
+            lastError = error;
+        }
+
+        await wait(100);
+    }
+
+    throw new Error(`Timed out waiting for ${label}${lastError ? `: ${lastError.message}` : ''}.`);
+}
+
+function spawnBridge({ bridgePort, remoteHubPort, workspacePath, label, traceFrames = false }) {
+    const child = spawn(process.execPath, ['server.js'], {
+        cwd: LOCAL_BRIDGE_DIR,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        env: {
+            ...process.env,
+            BRIDGE_PORT: String(bridgePort),
+            BRIDGE_TOKEN,
+            BRIDGE_REQUIRE_TOKEN: '1',
+            MINDEXEC_REMOTE_HUB: '1',
+            MINDEXEC_REMOTE_TRACE_FRAMES: traceFrames ? '1' : '',
+            MINDEXEC_REMOTE_REGISTRY_FOLLOWER: '0',
+            MINDEXEC_REMOTE_REGISTRY_REALTIME: '0',
+            MINDEXEC_REMOTE_HOST_TARGET_AUTO_RENEW: '0',
+            REMOTE_HUB_HOST: '127.0.0.1',
+            REMOTE_HUB_PORT: String(remoteHubPort),
+            REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN,
+            WORKSPACE_PATH: workspacePath,
+            NO_COLOR: '1'
+        }
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => {
+        stdout += chunk.toString();
+    });
+    child.stderr.on('data', chunk => {
+        stderr += chunk.toString();
+    });
+
+    const exitPromise = new Promise(resolve => child.once('exit', resolve));
+    const details = () => `${label} stdout=${stdout}\n${label} stderr=${stderr}`;
+    const stop = async () => {
+        if (child.exitCode === null && !child.killed) {
+            child.kill('SIGTERM');
+            await Promise.race([exitPromise, wait(5000)]);
+            if (child.exitCode === null && !child.killed) {
+                child.kill('SIGKILL');
+            }
+        }
+    };
+
+    return {
+        baseUrl: `http://127.0.0.1:${bridgePort}`,
+        child,
+        details,
+        stop
+    };
+}
+
+async function waitForBridge(bridge) {
+    return await waitFor(async () => {
+        const result = await fetchJson(`${bridge.baseUrl}/api/status`);
+        return result.ok && result.payload?.status === 'ok' ? result.payload : null;
+    }, 30000, `bridge startup\n${bridge.details()}`);
+}
+
+async function loadPlaywrightChromium() {
+    const candidates = [
+        path.join(LOCAL_BRIDGE_DIR, 'node_modules', 'playwright', 'index.js'),
+        path.join(LOCAL_BRIDGE_DIR, 'node_modules', 'playwright-core', 'index.mjs'),
+        path.join(LOCAL_BRIDGE_DIR, 'node_modules', 'playwright-core', 'index.js')
+    ];
+
+    let lastError = null;
+    for (const candidate of candidates) {
+        try {
+            const mod = await import(pathToFileURL(candidate).href);
+            if (mod.chromium) {
+                return mod.chromium;
+            }
+        } catch (error) {
+            lastError = error;
+        }
+    }
+
+    throw new Error(`Playwright chromium is unavailable: ${lastError?.message || 'not installed'}`);
+}
+
+async function launchBrowser(chromium) {
+    const launchers = [
+        () => chromium.launch({ channel: 'chrome', headless: true }),
+        () => chromium.launch({ channel: 'msedge', headless: true }),
+        () => chromium.launch({ headless: true })
+    ];
+
+    let lastError = null;
+    for (const launch of launchers) {
+        try {
+            return await launch();
+        } catch (error) {
+            lastError = error;
+        }
+    }
+
+    throw new Error(`Unable to launch a Chromium browser: ${lastError?.message || 'unknown error'}`);
+}
+
+async function paintRemoteFramesInBrowser(page, wsUrl, deviceId, fps = REQUESTED_FPS) {
+    await page.setContent(`
+        <!doctype html>
+        <meta charset="utf-8">
+        <canvas id="screen" width="320" height="180"></canvas>
+    `);
+
+    return await page.evaluate(async ({ wsUrl, deviceId, fps, sampleMs, minPaintFps }) => {
+        const canvas = document.getElementById('screen');
+        const context = canvas.getContext('2d', { alpha: false, desynchronized: true }) || canvas.getContext('2d');
+        if (!context) {
+            throw new Error('canvas-2d-context-unavailable');
+        }
+        if (typeof createImageBitmap !== 'function') {
+            throw new Error('createImageBitmap-unavailable');
+        }
+
+        function parsePacket(buffer) {
+            const view = new DataView(buffer);
+            const metaLength = view.getUint32(0);
+            if (!Number.isFinite(metaLength) || metaLength <= 0 || metaLength > 64 * 1024 || 4 + metaLength >= buffer.byteLength) {
+                throw new Error('invalid-frame-packet');
+            }
+
+            const metadataBytes = new Uint8Array(buffer, 4, metaLength);
+            const metadata = JSON.parse(new TextDecoder().decode(metadataBytes));
+            const payload = buffer.slice(4 + metaLength);
+            return { metadata, payload };
+        }
+
+        return await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                try {
+                    ws?.close();
+                } catch {
+                    // ignore close failure
+                }
+                reject(new Error('timed-out-waiting-for-mdm-frames'));
+            }, 20000);
+            const ws = new WebSocket(wsUrl);
+            const painted = [];
+            const receivedSeqs = [];
+            let firstPaintAt = 0;
+            let lastPaintAt = 0;
+            let processing = false;
+            let pendingPacket = null;
+            let settled = false;
+
+            function finishIfReady() {
+                if (settled || painted.length < 2 || !firstPaintAt || !lastPaintAt) {
+                    return;
+                }
+
+                const elapsedMs = lastPaintAt - firstPaintAt;
+                if (elapsedMs < sampleMs) {
+                    return;
+                }
+
+                const uniqueSeqs = new Set(painted.map(item => item.frameSeq));
+                const paintFps = painted.length > 1
+                    ? ((painted.length - 1) * 1000) / Math.max(1, elapsedMs)
+                    : 0;
+                if (paintFps < minPaintFps) {
+                    return;
+                }
+
+                settled = true;
+                clearTimeout(timeout);
+                ws.onclose = null;
+                try {
+                    ws.close();
+                } catch {
+                    // ignore close failure
+                }
+                resolve({
+                    framesReceived: receivedSeqs.length,
+                    framesPainted: painted.length,
+                    uniqueSeqs: uniqueSeqs.size,
+                    firstSeq: painted[0]?.frameSeq || 0,
+                    lastSeq: painted[painted.length - 1]?.frameSeq || 0,
+                    durationMs: elapsedMs,
+                    paintFps,
+                    fps: painted[painted.length - 1]?.fps || 0,
+                    width: painted[painted.length - 1]?.width || 0,
+                    height: painted[painted.length - 1]?.height || 0,
+                    minBytes: Math.min(...painted.map(item => item.byteLength).filter(value => value > 0)),
+                    maxBytes: Math.max(...painted.map(item => item.byteLength).filter(value => value > 0)),
+                    mimeType: painted[painted.length - 1]?.mimeType || '',
+                    transport: painted[painted.length - 1]?.transport || ''
+                });
+            }
+
+            async function paintPacket(packet) {
+                const { metadata, payload } = packet;
+                const blob = new Blob([payload], { type: metadata.mimeType || 'image/jpeg' });
+                const bitmap = await createImageBitmap(blob);
+                context.drawImage(bitmap, 0, 0, canvas.width, canvas.height);
+                bitmap.close?.();
+                const now = performance.now();
+                const frameSeq = Number(metadata.frameSeq || 0);
+                if (!firstPaintAt) {
+                    firstPaintAt = now;
+                }
+                lastPaintAt = now;
+                painted.push({
+                    frameSeq,
+                    fps: Number(metadata.fps || 0),
+                    width: Number(metadata.width || 0),
+                    height: Number(metadata.height || 0),
+                    byteLength: Number(metadata.byteLength || payload.byteLength || 0),
+                    mimeType: String(metadata.mimeType || ''),
+                    transport: String(metadata.transport || '')
+                });
+                finishIfReady();
+            }
+
+            async function processLatest(packet) {
+                pendingPacket = packet;
+                if (processing) {
+                    return;
+                }
+
+                processing = true;
+                try {
+                    while (pendingPacket && !settled) {
+                        const next = pendingPacket;
+                        pendingPacket = null;
+                        await paintPacket(next);
+                    }
+                } catch (error) {
+                    settled = true;
+                    clearTimeout(timeout);
+                    try {
+                        ws.close();
+                    } catch {
+                        // ignore close failure
+                    }
+                    reject(error);
+                } finally {
+                    processing = false;
+                }
+            }
+
+            ws.binaryType = 'arraybuffer';
+            ws.onopen = () => {
+                ws.send(JSON.stringify({
+                    type: 'subscribe',
+                    deviceIds: [deviceId],
+                    autoStartLive: true,
+                    fps,
+                    maxWidth: 960,
+                    maxHeight: 540,
+                    quality: 60
+                }));
+            };
+            ws.onerror = () => {
+                clearTimeout(timeout);
+                reject(new Error('remote-frame-websocket-error'));
+            };
+            ws.onclose = () => {
+                clearTimeout(timeout);
+                reject(new Error('remote-frame-websocket-closed-before-paint'));
+            };
+            ws.onmessage = async event => {
+                if (typeof event.data === 'string') {
+                    return;
+                }
+
+                try {
+                    const { metadata, payload } = parsePacket(event.data);
+                    if (String(metadata.type || '').toLowerCase() !== 'remote.frame.binary'
+                        || String(metadata.kind || '').toLowerCase() !== 'live'
+                        || String(metadata.deviceId || '') !== deviceId) {
+                        return;
+                    }
+
+                    if (metadata.dataUrl || metadata.framePath || metadata.frameUrl) {
+                        throw new Error('binary-ws-metadata-must-not-carry-frame-url-or-data-url');
+                    }
+
+                    receivedSeqs.push(Number(metadata.frameSeq || 0));
+                    await processLatest({ metadata, payload });
+                } catch (error) {
+                    if (!settled) {
+                        settled = true;
+                        clearTimeout(timeout);
+                        try {
+                            ws.close();
+                        } catch {
+                            // ignore close failure
+                        }
+                        reject(error);
+                    }
+                }
+            };
+        });
+    }, { wsUrl, deviceId, fps, sampleMs: SAMPLE_MS, minPaintFps: MIN_PAINT_FPS });
+}
+
+async function main() {
+    const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'mindexec-remote-mdm-browser-'));
+    const hostWorkspace = path.join(tempRoot, 'host');
+    const clientWorkspace = path.join(tempRoot, 'client');
+    const hostBridgePort = await findFreePort();
+    const hostRemotePort = await findFreePort();
+    const clientBridgePort = await findFreePort();
+    const clientRemotePort = await findFreePort();
+    const managerEndpoint = `127.0.0.1:${hostRemotePort}`;
+    let hostBridge = null;
+    let clientBridge = null;
+    let browser = null;
+
+    try {
+        hostBridge = spawnBridge({
+            bridgePort: hostBridgePort,
+            remoteHubPort: hostRemotePort,
+            workspacePath: hostWorkspace,
+            label: 'host'
+        });
+        await waitForBridge(hostBridge);
+
+        clientBridge = spawnBridge({
+            bridgePort: clientBridgePort,
+            remoteHubPort: clientRemotePort,
+            workspacePath: clientWorkspace,
+            label: 'client',
+            traceFrames: true
+        });
+        await waitForBridge(clientBridge);
+
+        const connectResult = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/connect`, {
+            method: 'POST',
+            body: JSON.stringify({
+                managerCandidates: [managerEndpoint],
+                pairToken: PAIR_TOKEN,
+                leaseId: LEASE_ID,
+                nodeId: 'remote-fast-mdm-browser-node',
+                engine: 'auto',
+                source: 'mdm-browser-smoke'
+            })
+        });
+        assert.equal(connectResult.ok, true, JSON.stringify(connectResult.payload));
+        assert.equal(connectResult.payload?.ok, true, JSON.stringify(connectResult.payload));
+        assert.equal(connectResult.payload?.agent?.usingNpx, false, JSON.stringify(connectResult.payload?.agent));
+        assert.match(String(connectResult.payload?.agent?.launcher || ''), /mindexec-remote-fast/i);
+
+        const device = await waitFor(async () => {
+            const result = await fetchJson(`${hostBridge.baseUrl}/api/remote/devices`);
+            return result.payload?.devices?.find(item =>
+                item.connected === true
+                && item.capabilities?.liveStream === true
+                && item.capabilities?.binaryFrames === true) || null;
+        }, 15000, `RemoteFast device registration\n${hostBridge.details()}\n${clientBridge.details()}`);
+
+        const chromium = await loadPlaywrightChromium();
+        browser = await launchBrowser(chromium);
+        const page = await browser.newPage();
+        const wsUrl = `${hostBridge.baseUrl.replace(/^http:/, 'ws:')}/api/remote/frames/ws?token=${encodeURIComponent(BRIDGE_TOKEN)}`;
+        const painted = await paintRemoteFramesInBrowser(page, wsUrl, device.deviceId, REQUESTED_FPS);
+        assert.ok(painted.framesReceived >= painted.framesPainted, JSON.stringify(painted));
+        assert.ok(painted.framesPainted >= Math.max(4, Math.floor((SAMPLE_MS / 1000) * MIN_PAINT_FPS)), JSON.stringify(painted));
+        assert.ok(painted.uniqueSeqs >= painted.framesPainted - 1, JSON.stringify(painted));
+        assert.ok(painted.lastSeq > painted.firstSeq, JSON.stringify(painted));
+        assert.ok(painted.paintFps >= MIN_PAINT_FPS, JSON.stringify(painted));
+        assert.equal(painted.fps, REQUESTED_FPS, JSON.stringify(painted));
+        assert.ok(painted.width > 0 && painted.height > 0, JSON.stringify(painted));
+        assert.ok(painted.minBytes > 0 && painted.maxBytes >= painted.minBytes, JSON.stringify(painted));
+        assert.match(painted.mimeType, /^image\/(jpeg|png|webp)$/i, JSON.stringify(painted));
+
+        console.log(`RemoteFast MDM browser smoke OK (${painted.framesPainted} paints, ${painted.paintFps.toFixed(1)} fps, seq ${painted.firstSeq}-${painted.lastSeq}, ${painted.width}x${painted.height}, ${painted.minBytes}-${painted.maxBytes} bytes)`);
+    } finally {
+        if (browser) {
+            await browser.close().catch(() => undefined);
+        }
+        if (clientBridge) {
+            await clientBridge.stop();
+        }
+        if (hostBridge) {
+            await hostBridge.stop();
+        }
+        await rm(tempRoot, { recursive: true, force: true });
+    }
+}
+
+await main();