mindexec-ai 0.2.385

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

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { WebSocket } from 'ws';
+import { createRemoteHub } from '../remote-hub.js';
+
+const PAIR_TOKEN = 'remote-agent-ws-smoke-token';
+const DEVICE_ID = 'remote-agent-ws-smoke-device';
+const SMOKE_PNG = Buffer.from(
+    'iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC',
+    'base64');
+
+function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function waitFor(predicate, timeoutMs = 5000, label = 'condition') {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const value = predicate();
+        if (value) {
+            return value;
+        }
+        await wait(25);
+    }
+
+    throw new Error(`Timed out waiting for ${label}.`);
+}
+
+function writeAgentBinaryFrame(ws, header, payload) {
+    const framePayload = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+    const metadata = Buffer.from(JSON.stringify({
+        ...header,
+        type: 'frame.binary',
+        byteLength: framePayload.length
+    }), 'utf8');
+    const packet = Buffer.allocUnsafe(4 + metadata.length + framePayload.length);
+    packet.writeUInt32BE(metadata.length, 0);
+    metadata.copy(packet, 4);
+    framePayload.copy(packet, 4 + metadata.length);
+    ws.send(packet);
+}
+
+const hub = createRemoteHub({
+    env: {
+        MINDEXEC_REMOTE_HUB: '1',
+        REMOTE_HUB_HOST: '127.0.0.1',
+        REMOTE_HUB_PORT: '0',
+        REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN
+    }
+});
+
+let ws = null;
+
+try {
+    await hub.start();
+    const status = hub.getStatus({ includeSecrets: true });
+    assert.equal(status.started, true);
+
+    ws = new WebSocket(`ws://127.0.0.1:${status.port}/remote-agent`);
+    const received = [];
+    ws.on('message', data => {
+        if (typeof data !== 'string' && !Buffer.isBuffer(data)) {
+            return;
+        }
+
+        const text = Buffer.isBuffer(data) ? data.toString('utf8') : data;
+        if (!text.trim().startsWith('{')) {
+            return;
+        }
+
+        received.push(JSON.parse(text));
+    });
+
+    await new Promise((resolve, reject) => {
+        ws.once('open', resolve);
+        ws.once('error', reject);
+    });
+
+    ws.send(JSON.stringify({
+        type: 'hello',
+        pairToken: PAIR_TOKEN,
+        deviceId: DEVICE_ID,
+        deviceName: 'Remote Agent WS Smoke',
+        hostname: 'remote-agent-ws-smoke',
+        platform: process.platform,
+        arch: process.arch,
+        pid: process.pid,
+        agentVersion: '0.0.0-ws-smoke',
+        runtime: 'node-smoke',
+        capabilities: {
+            status: true,
+            thumbnail: true,
+            liveStream: true,
+            binaryFrames: true,
+            control: true,
+            computerAgent: true,
+            taskDispatch: true,
+            aiAssist: false
+        }
+    }));
+    ws.send(JSON.stringify({
+        type: 'status',
+        status: {
+            uptimeSec: 1,
+            totalMem: 2,
+            freeMem: 1,
+            timestamp: new Date().toISOString()
+        }
+    }));
+
+    await waitFor(() => received.find(item => item.type === 'welcome'), 5000, 'welcome');
+    const device = await waitFor(() => {
+        const current = hub.listDevices();
+        return current.length === 1 && current[0].deviceId === DEVICE_ID ? current[0] : null;
+    }, 5000, 'device registration');
+    assert.equal(device.connected, true);
+    assert.equal(device.capabilities.binaryFrames, true);
+
+    const inputCommand = hub.sendInputControl(DEVICE_ID, { type: 'noop' });
+    assert.equal(inputCommand.ok, true);
+    const inputMessage = await waitFor(
+        () => received.find(item => item.commandId === inputCommand.commandId),
+        5000,
+        'input command');
+    assert.equal(inputMessage.command, 'input.control');
+    ws.send(JSON.stringify({
+        type: 'command.result',
+        commandId: inputCommand.commandId,
+        result: {
+            input: true,
+            handled: true
+        }
+    }));
+    await waitFor(() => hub.listDevices()[0]?.counters?.commandResultsReceived === 1, 5000, 'input result');
+
+    const thumbnailCommand = hub.requestThumbnail(DEVICE_ID, {
+        streamId: 'remote-agent-ws-thumb',
+        maxWidth: 320,
+        maxHeight: 180,
+        quality: 50
+    });
+    assert.equal(thumbnailCommand.ok, true);
+    await waitFor(
+        () => received.find(item => item.commandId === thumbnailCommand.commandId),
+        5000,
+        'thumbnail command');
+    writeAgentBinaryFrame(ws, {
+        frameKind: 'thumbnail',
+        commandId: thumbnailCommand.commandId,
+        streamId: 'remote-agent-ws-thumb',
+        frameSeq: 11,
+        width: 2,
+        height: 1,
+        mimeType: 'image/png',
+        capturedAt: new Date().toISOString()
+    }, SMOKE_PNG);
+    const thumbnailDevice = await waitFor(() => {
+        const current = hub.listDevices()[0];
+        return current?.latestThumbnail?.frameSeq === 11 ? current : null;
+    }, 5000, 'websocket binary thumbnail');
+    assert.equal(thumbnailDevice.latestThumbnail.transport, 'binary');
+    assert.equal(thumbnailDevice.latestThumbnail.byteLength, SMOKE_PNG.length);
+
+    const liveCommand = hub.startLiveStream(DEVICE_ID, {
+        streamId: 'remote-agent-ws-live',
+        fps: 10,
+        maxWidth: 320,
+        maxHeight: 180,
+        quality: 50
+    });
+    assert.equal(liveCommand.ok, true);
+    await waitFor(
+        () => received.find(item => item.commandId === liveCommand.commandId),
+        5000,
+        'live command');
+    writeAgentBinaryFrame(ws, {
+        frameKind: 'stream',
+        commandId: liveCommand.commandId,
+        streamId: 'remote-agent-ws-live',
+        frameSeq: 12,
+        width: 2,
+        height: 1,
+        mimeType: 'image/png',
+        fps: 10,
+        capturedAt: new Date().toISOString()
+    }, SMOKE_PNG);
+    const liveDevice = await waitFor(() => {
+        const current = hub.listDevices()[0];
+        return current?.latestLiveFrame?.frameSeq === 12 ? current : null;
+    }, 5000, 'websocket binary live frame');
+    assert.equal(liveDevice.latestLiveFrame.transport, 'binary');
+    assert.equal(liveDevice.latestLiveFrame.streamId, 'remote-agent-ws-live');
+
+    ws.close();
+    console.log('RemoteAgent WebSocket smoke OK');
+} finally {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.close();
+    }
+    await hub.close();
+}

package/scripts/remote-fast-live-rate-smoke.mjs

@@ -0,0 +1,355 @@
+#!/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 } from 'node:url';
+import { WebSocket } from 'ws';
+
+const BRIDGE_TOKEN = 'remote-fast-live-rate-smoke-token';
+const PAIR_TOKEN = 'remote-fast-live-rate-pair-token';
+const LEASE_ID = 'remote-fast-live-rate-lease';
+const LOCAL_BRIDGE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const REQUESTED_FPS = Number(process.env.MINDEXEC_REMOTE_LIVE_RATE_REQUEST_FPS || 12);
+const SAMPLE_MS = Number(process.env.MINDEXEC_REMOTE_LIVE_RATE_SAMPLE_MS || 3500);
+const MIN_EFFECTIVE_FPS = Number(process.env.MINDEXEC_REMOTE_LIVE_RATE_MIN_FPS || 10);
+const MAX_DROP_RATIO = Number(process.env.MINDEXEC_REMOTE_LIVE_RATE_MAX_DROP_RATIO || 0.2);
+const MAX_SEQ_GAP = Number(process.env.MINDEXEC_REMOTE_LIVE_RATE_MAX_SEQ_GAP || 4);
+
+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 || {})
+        }
+    });
+
+    let payload = null;
+    try {
+        payload = await response.json();
+    } catch {
+        // Some failure responses may be empty.
+    }
+
+    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()}`);
+}
+
+function parseFramePacket(data) {
+    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    if (buffer.length <= 8 || buffer[0] === 0x7b || buffer[0] === 0x5b) {
+        return null;
+    }
+
+    const metaLength = buffer.readUInt32BE(0);
+    if (metaLength <= 0 || metaLength > 64 * 1024 || 4 + metaLength >= buffer.length) {
+        return null;
+    }
+
+    const metadata = JSON.parse(buffer.subarray(4, 4 + metaLength).toString('utf8'));
+    const payload = buffer.subarray(4 + metaLength);
+    if (String(metadata?.type || '').toLowerCase() !== 'remote.frame.binary') {
+        return null;
+    }
+
+    return { metadata, payload, receivedAtMs: Date.now() };
+}
+
+async function openFrameSocket(baseUrl, deviceId) {
+    const ws = new WebSocket(`${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: [deviceId] }));
+    return ws;
+}
+
+async function collectLiveFrames(ws, deviceId, sampleMs) {
+    const frames = [];
+    let firstFrameAt = 0;
+    let settle = null;
+    let settled = false;
+
+    const finish = () => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        settle?.();
+    };
+
+    const done = new Promise((resolve, reject) => {
+        settle = resolve;
+        const timeout = setTimeout(() => reject(new Error('timed out waiting for RemoteFast binary frames')), 25000);
+        ws.on('message', data => {
+            const frame = parseFramePacket(data);
+            if (!frame
+                || String(frame.metadata.kind || '').toLowerCase() !== 'live'
+                || String(frame.metadata.deviceId || '') !== deviceId) {
+                return;
+            }
+
+            frames.push(frame);
+            if (!firstFrameAt) {
+                firstFrameAt = frame.receivedAtMs;
+            }
+            if (frame.receivedAtMs - firstFrameAt >= sampleMs) {
+                clearTimeout(timeout);
+                finish();
+            }
+        });
+        ws.once('close', () => {
+            clearTimeout(timeout);
+            if (!settled) {
+                reject(new Error('frame websocket closed during live-rate sample'));
+            }
+        });
+        ws.once('error', error => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
+
+    await done;
+    return frames;
+}
+
+function summarizeFrames(frames) {
+    const first = frames[0];
+    const last = frames[frames.length - 1];
+    const durationMs = Math.max(1, Number(last?.receivedAtMs || 0) - Number(first?.receivedAtMs || 0));
+    const fps = frames.length > 1 ? ((frames.length - 1) * 1000) / durationMs : 0;
+    const seqs = frames.map(frame => Number(frame.metadata.frameSeq || 0)).filter(Number.isFinite);
+    const uniqueSeqs = new Set(seqs);
+    const firstSeq = seqs[0] || 0;
+    const lastSeq = seqs[seqs.length - 1] || 0;
+    const expectedSeqs = lastSeq >= firstSeq ? lastSeq - firstSeq + 1 : uniqueSeqs.size;
+    const droppedSeqs = Math.max(0, expectedSeqs - uniqueSeqs.size);
+    let maxSeqGap = 0;
+    for (let index = 1; index < seqs.length; index += 1) {
+        maxSeqGap = Math.max(maxSeqGap, Math.max(0, seqs[index] - seqs[index - 1] - 1));
+    }
+    const byteLengths = frames.map(frame => Number(frame.payload?.length || 0)).filter(value => value > 0);
+    return {
+        frames: frames.length,
+        uniqueSeqs: uniqueSeqs.size,
+        expectedSeqs,
+        droppedSeqs,
+        dropRatio: expectedSeqs > 0 ? droppedSeqs / expectedSeqs : 0,
+        maxSeqGap,
+        durationMs,
+        fps,
+        firstSeq,
+        lastSeq,
+        minBytes: byteLengths.length > 0 ? Math.min(...byteLengths) : 0,
+        maxBytes: byteLengths.length > 0 ? Math.max(...byteLengths) : 0,
+        metadataFps: Number(last?.metadata?.fps || 0) || 0,
+        mode: String(last?.metadata?.mode || '')
+    };
+}
+
+async function main() {
+    const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'mindexec-remote-fast-live-rate-'));
+    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 ws = 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-live-rate-node',
+                engine: 'auto',
+                source: 'live-rate-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()}`);
+
+        ws = await openFrameSocket(hostBridge.baseUrl, device.deviceId);
+        const live = await fetchJson(`${hostBridge.baseUrl}/api/remote/devices/${encodeURIComponent(device.deviceId)}/live/start`, {
+            method: 'POST',
+            body: JSON.stringify({
+                fps: REQUESTED_FPS,
+                maxWidth: 960,
+                maxHeight: 540,
+                quality: 60
+            })
+        });
+        assert.equal(live.ok, true, JSON.stringify(live.payload));
+        assert.equal(live.payload?.ok, true, JSON.stringify(live.payload));
+
+        let frames = [];
+        try {
+            frames = await collectLiveFrames(ws, device.deviceId, SAMPLE_MS);
+        } catch (error) {
+            const hostStatus = await fetchJson(`${hostBridge.baseUrl}/api/remote/status`).catch(() => null);
+            const hostDevices = await fetchJson(`${hostBridge.baseUrl}/api/remote/devices`).catch(() => null);
+            const clientAgent = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/status`).catch(() => null);
+            error.message = `${error.message}\n` +
+                `hostStatus=${JSON.stringify(hostStatus?.payload || null)}\n` +
+                `hostDevices=${JSON.stringify(hostDevices?.payload || null)}\n` +
+                `clientAgent=${JSON.stringify(clientAgent?.payload || null)}\n` +
+                `${hostBridge.details()}\n${clientBridge.details()}`;
+            throw error;
+        }
+        const summary = summarizeFrames(frames);
+        assert.ok(summary.frames >= 2, JSON.stringify(summary));
+        assert.equal(summary.uniqueSeqs, summary.frames, `frameSeq should advance for each binary frame: ${JSON.stringify(summary)}`);
+        assert.ok(summary.minBytes > 0, `binary payload should be non-empty: ${JSON.stringify(summary)}`);
+        assert.equal(summary.metadataFps, REQUESTED_FPS, JSON.stringify(summary));
+        assert.equal(summary.mode, 'remote-fast', JSON.stringify(summary));
+        assert.ok(summary.fps >= MIN_EFFECTIVE_FPS, `RemoteFast live-rate too low: ${JSON.stringify(summary)}`);
+        assert.ok(summary.dropRatio <= MAX_DROP_RATIO, `RemoteFast live-rate dropped too many frame sequences: ${JSON.stringify(summary)}`);
+        assert.ok(summary.maxSeqGap <= MAX_SEQ_GAP, `RemoteFast live-rate sequence gap too large: ${JSON.stringify(summary)}`);
+
+        console.log(`RemoteFast live-rate smoke OK (${summary.frames} frames, ${summary.fps.toFixed(1)} fps, drop ${(summary.dropRatio * 100).toFixed(1)}%, max gap ${summary.maxSeqGap}, bytes ${summary.minBytes}-${summary.maxBytes})`);
+    } finally {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+            ws.close();
+        }
+        if (clientBridge) {
+            await clientBridge.stop();
+        }
+        if (hostBridge) {
+            await hostBridge.stop();
+        }
+        await rm(tempRoot, { recursive: true, force: true });
+    }
+}
+
+await main();