mindexec-ai 0.2.385

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

@@ -0,0 +1,476 @@
+#!/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);
+const MAX_PAINT_DROP_RATIO = Number(process.env.MINDEXEC_REMOTE_MDM_BROWSER_MAX_PAINT_DROP_RATIO || 0.65);
+const MAX_PAINT_SEQ_GAP = Number(process.env.MINDEXEC_REMOTE_MDM_BROWSER_MAX_PAINT_SEQ_GAP || 10);
+
+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' : '',
+            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 paintedSeqs = painted.map(item => item.frameSeq);
+                const uniqueSeqs = new Set(paintedSeqs);
+                let maxPaintSeqGap = 0;
+                for (let index = 1; index < paintedSeqs.length; index += 1) {
+                    maxPaintSeqGap = Math.max(maxPaintSeqGap, Math.max(0, paintedSeqs[index] - paintedSeqs[index - 1] - 1));
+                }
+                const receivedUniqueSeqs = new Set(receivedSeqs);
+                const firstReceivedSeq = receivedSeqs[0] || 0;
+                const lastReceivedSeq = receivedSeqs[receivedSeqs.length - 1] || 0;
+                const expectedReceivedSeqs = lastReceivedSeq >= firstReceivedSeq
+                    ? lastReceivedSeq - firstReceivedSeq + 1
+                    : receivedUniqueSeqs.size;
+                const streamDroppedSeqs = Math.max(0, expectedReceivedSeqs - receivedUniqueSeqs.size);
+                const paintDroppedSeqs = Math.max(0, receivedUniqueSeqs.size - uniqueSeqs.size);
+                const paintDropRatio = receivedUniqueSeqs.size > 0
+                    ? paintDroppedSeqs / receivedUniqueSeqs.size
+                    : 0;
+                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,
+                    uniqueFramesReceived: receivedUniqueSeqs.size,
+                    expectedFramesReceived: expectedReceivedSeqs,
+                    streamDroppedSeqs,
+                    paintDroppedSeqs,
+                    paintDropRatio,
+                    framesPainted: painted.length,
+                    uniqueSeqs: uniqueSeqs.size,
+                    maxPaintSeqGap,
+                    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.ok(painted.paintDropRatio <= MAX_PAINT_DROP_RATIO, JSON.stringify(painted));
+        assert.ok(painted.maxPaintSeqGap <= MAX_PAINT_SEQ_GAP, 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, paint drop ${(painted.paintDropRatio * 100).toFixed(1)}%, max gap ${painted.maxPaintSeqGap}, 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();