mindexec-ai 0.2.385

package/scripts/remote-frame-ws-smoke.mjs

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { WebSocket } from 'ws';
+
+const BRIDGE_TOKEN = 'remote-frame-ws-smoke-token';
+const PAIR_TOKEN = 'remote-frame-ws-pair-token';
+
+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 { ok: response.ok, status: response.status, payload };
+}
+
+async function waitForBridge(baseUrl, details) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 30000) {
+        try {
+            const result = await fetchJson(`${baseUrl}/api/remote/status`);
+            if (result.ok && result.payload?.started === true) {
+                return result.payload;
+            }
+        } catch {
+            // Server is still starting.
+        }
+        await wait(100);
+    }
+
+    throw new Error(`Timed out waiting for LocalBridge.\n${details()}`);
+}
+
+function spawnBridge({ bridgePort, remoteHubPort }) {
+    const bridgeRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+    const env = {
+        ...process.env,
+        BRIDGE_PORT: String(bridgePort),
+        BRIDGE_TOKEN,
+        BRIDGE_REQUIRE_TOKEN: '1',
+        MINDEXEC_REMOTE_HUB: '1',
+        MINDEXEC_REMOTE_SYNTHETIC_FLEET: '1',
+        REMOTE_HUB_HOST: '127.0.0.1',
+        REMOTE_HUB_PORT: String(remoteHubPort),
+        REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN,
+        NO_COLOR: '1'
+    };
+
+    const child = spawn(process.execPath, ['server.js'], {
+        cwd: bridgeRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        env
+    });
+
+    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 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}`,
+        details: () => `stdout=${stdout}\nstderr=${stderr}`,
+        stop
+    };
+}
+
+function parseFramePacket(data) {
+    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    assert.ok(buffer.length > 8, 'binary frame packet should include header, metadata, and payload');
+    const metaLength = buffer.readUInt32BE(0);
+    assert.ok(metaLength > 0 && metaLength < 64 * 1024, 'metadata length should be bounded');
+    assert.ok(4 + metaLength < buffer.length, 'packet should include binary payload after metadata');
+    const metadata = JSON.parse(buffer.subarray(4, 4 + metaLength).toString('utf8'));
+    const payload = buffer.subarray(4 + metaLength);
+    return { metadata, payload };
+}
+
+async function waitForBinaryFrame(ws) {
+    return await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error('timed out waiting for binary frame')), 10000);
+        ws.on('message', data => {
+            if (typeof data === 'string') {
+                return;
+            }
+            const raw = Buffer.isBuffer(data) ? data : Buffer.from(data);
+            if (raw[0] === 0x7b || raw[0] === 0x5b) {
+                return;
+            }
+            clearTimeout(timeout);
+            try {
+                resolve(parseFramePacket(raw));
+            } catch (error) {
+                reject(error);
+            }
+        });
+        ws.on('error', reject);
+        ws.on('close', () => reject(new Error('websocket closed before binary frame')));
+    });
+}
+
+async function main() {
+    const bridgePort = await findFreePort();
+    const remoteHubPort = await findFreePort();
+    const bridge = spawnBridge({ bridgePort, remoteHubPort });
+
+    try {
+        const status = await waitForBridge(bridge.baseUrl, bridge.details);
+        assert.equal(status.started, true);
+
+        const seed = await fetchJson(`${bridge.baseUrl}/api/remote/synthetic/seed`, {
+            method: 'POST',
+            body: JSON.stringify({ count: 4, connectedRatio: 1, thumbnailRatio: 1, liveCount: 0 })
+        });
+        assert.equal(seed.ok, true);
+
+        const devicesResult = await fetchJson(`${bridge.baseUrl}/api/remote/devices`);
+        assert.equal(devicesResult.ok, true);
+        const device = devicesResult.payload?.devices?.find(item => item.connected === true);
+        assert.ok(device?.deviceId, 'expected connected synthetic device');
+
+        const ws = new WebSocket(`${bridge.baseUrl.replace(/^http:/, 'ws:')}/api/remote/frames/ws?token=${encodeURIComponent(BRIDGE_TOKEN)}`);
+        await new Promise((resolve, reject) => {
+            ws.once('open', resolve);
+            ws.once('error', reject);
+        });
+        ws.send(JSON.stringify({
+            type: 'subscribe',
+            deviceIds: [device.deviceId],
+            autoStartLive: true,
+            fps: 12,
+            maxWidth: 960,
+            maxHeight: 540,
+            quality: 60
+        }));
+
+        const framePromise = waitForBinaryFrame(ws);
+        const frame = await framePromise;
+        assert.equal(frame.metadata.type, 'remote.frame.binary');
+        assert.equal(frame.metadata.kind, 'live');
+        assert.equal(frame.metadata.deviceId, device.deviceId);
+        assert.equal(frame.metadata.fps, 12);
+        assert.ok(frame.metadata.frameSeq > 0, 'frameSeq should be positive');
+        assert.equal(frame.metadata.mimeType, 'image/png');
+        assert.ok(frame.payload.length > 0, 'payload should be non-empty');
+
+        const afterFirstAutoStart = await fetchJson(`${bridge.baseUrl}/api/remote/devices`);
+        const firstDeviceState = afterFirstAutoStart.payload?.devices?.find(item => item.deviceId === device.deviceId);
+        assert.equal(firstDeviceState?.activeLiveStream?.active, true, 'auto-start should mark the synthetic device live');
+        assert.equal(firstDeviceState?.counters?.liveStreamsStarted, 1, 'first subscribe should start one live stream');
+
+        ws.send(JSON.stringify({
+            type: 'subscribe',
+            deviceIds: [device.deviceId],
+            autoStartLive: true,
+            fps: 12,
+            maxWidth: 960,
+            maxHeight: 540,
+            quality: 60
+        }));
+        await wait(120);
+        const afterDuplicateSubscribe = await fetchJson(`${bridge.baseUrl}/api/remote/devices`);
+        const duplicateDeviceState = afterDuplicateSubscribe.payload?.devices?.find(item => item.deviceId === device.deviceId);
+        assert.equal(
+            duplicateDeviceState?.counters?.liveStreamsStarted,
+            1,
+            'duplicate keep-live subscribe must not restart a fresh live stream');
+
+        const frameStatus = await fetchJson(`${bridge.baseUrl}/api/status?remoteFrames=ws`);
+        assert.equal(frameStatus.ok, true);
+        assert.ok(frameStatus.payload?.remoteFrameWs?.clientCount >= 1, JSON.stringify(frameStatus.payload?.remoteFrameWs));
+        assert.ok(frameStatus.payload?.remoteFrameWs?.framesSent >= 1, JSON.stringify(frameStatus.payload?.remoteFrameWs));
+        assert.equal(frameStatus.payload?.remoteFrameWs?.lastFrameDeviceId, device.deviceId);
+        assert.equal(frameStatus.payload?.remoteFrameWs?.lastFrameSeq, frame.metadata.frameSeq);
+        assert.ok(
+            frameStatus.payload?.remoteFrameWs?.clients?.some(client =>
+                Array.isArray(client.deviceIds)
+                && client.deviceIds.includes(device.deviceId)
+                && client.autoStartLive === true
+                && client.sent >= 1),
+            JSON.stringify(frameStatus.payload?.remoteFrameWs));
+        ws.close();
+
+        console.log('Remote frame WebSocket smoke OK');
+    } finally {
+        await bridge.stop();
+    }
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exitCode = 1;
+});