mindexec-ai 0.2.385

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

@@ -0,0 +1,263 @@
+#!/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-input-ws-smoke-token';
+const PAIR_TOKEN = 'remote-input-ws-pair-token';
+const DEVICE_ID = 'remote-input-ws-device';
+
+function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function waitFor(predicate, timeoutMs = 10000, label = 'condition') {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const value = await predicate();
+        if (value) {
+            return value;
+        }
+        await wait(50);
+    }
+
+    throw new Error(`Timed out waiting for ${label}.`);
+}
+
+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',
+        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
+    };
+}
+
+async function openWebSocket(url) {
+    const ws = new WebSocket(url);
+    await new Promise((resolve, reject) => {
+        ws.once('open', resolve);
+        ws.once('error', reject);
+    });
+    return ws;
+}
+
+async function main() {
+    const bridgePort = await findFreePort();
+    const remoteHubPort = await findFreePort();
+    const bridge = spawnBridge({ bridgePort, remoteHubPort });
+    let agentWs = null;
+    let inputWs = null;
+
+    try {
+        await waitForBridge(bridge.baseUrl, bridge.details);
+
+        const receivedCommands = [];
+        agentWs = await openWebSocket(`ws://127.0.0.1:${remoteHubPort}/remote-agent`);
+        agentWs.on('message', data => {
+            const text = Buffer.isBuffer(data) ? data.toString('utf8') : String(data || '');
+            if (!text.trim().startsWith('{')) {
+                return;
+            }
+
+            const message = JSON.parse(text);
+            if (message.command === 'input.control') {
+                receivedCommands.push(message);
+            }
+        });
+        agentWs.send(JSON.stringify({
+            type: 'hello',
+            pairToken: PAIR_TOKEN,
+            deviceId: DEVICE_ID,
+            deviceName: 'Remote Input WS Smoke',
+            hostname: 'remote-input-ws-smoke',
+            platform: process.platform,
+            arch: process.arch,
+            pid: process.pid,
+            agentVersion: '0.0.0-input-ws-smoke',
+            runtime: 'node-smoke',
+            capabilities: {
+                status: true,
+                thumbnail: true,
+                liveStream: true,
+                binaryFrames: true,
+                control: true,
+                computerAgent: true,
+                taskDispatch: true,
+                aiAssist: false
+            }
+        }));
+        agentWs.send(JSON.stringify({
+            type: 'status',
+            status: {
+                uptimeSec: 1,
+                totalMem: 2,
+                freeMem: 1,
+                timestamp: new Date().toISOString()
+            }
+        }));
+
+        await waitFor(async () => {
+            const result = await fetchJson(`${bridge.baseUrl}/api/remote/devices`);
+            return result.payload?.devices?.find(device => device.deviceId === DEVICE_ID && device.connected === true);
+        }, 10000, 'device registration');
+
+        inputWs = await openWebSocket(`${bridge.baseUrl.replace(/^http:/, 'ws:')}/api/remote/input/ws?token=${encodeURIComponent(BRIDGE_TOKEN)}`);
+        inputWs.send(JSON.stringify({
+            type: 'input',
+            deviceId: DEVICE_ID,
+            requestId: 'pointer-move',
+            input: {
+                type: 'pointerMove',
+                normalizedX: 0.42,
+                normalizedY: 0.54,
+                controlLeaseId: 'input-ws-smoke-lease'
+            }
+        }));
+        inputWs.send(JSON.stringify({
+            type: 'input',
+            deviceId: DEVICE_ID,
+            requestId: 'key-down',
+            input: {
+                type: 'keyDown',
+                key: 'A',
+                code: 'KeyA',
+                repeat: false,
+                controlLeaseId: 'input-ws-smoke-lease'
+            }
+        }));
+        inputWs.send(JSON.stringify({
+            type: 'input',
+            deviceId: DEVICE_ID,
+            requestId: 'key-up',
+            input: {
+                type: 'keyUp',
+                key: 'A',
+                code: 'KeyA',
+                repeat: false,
+                controlLeaseId: 'input-ws-smoke-lease'
+            }
+        }));
+
+        await waitFor(() => receivedCommands.length >= 3, 10000, 'input.control commands');
+        const commandTypes = receivedCommands.map(command => command.payload?.type);
+        assert.deepEqual(commandTypes.slice(0, 3), ['pointerMove', 'keyDown', 'keyUp']);
+        assert.equal(receivedCommands[0].payload.normalizedX, 0.42);
+        assert.equal(receivedCommands[0].payload.normalizedY, 0.54);
+        assert.equal(receivedCommands[1].payload.key, 'A');
+        assert.equal(receivedCommands[1].payload.code, 'KeyA');
+        assert.equal(receivedCommands[2].payload.key, 'A');
+        assert.equal(receivedCommands[2].payload.code, 'KeyA');
+
+        const status = await fetchJson(`${bridge.baseUrl}/api/status?remoteInput=ws`);
+        assert.equal(status.ok, true);
+        assert.equal(status.payload?.remoteInputWsPath, '/api/remote/input/ws');
+        assert.ok(status.payload?.remoteInputWs?.clientCount >= 1, JSON.stringify(status.payload?.remoteInputWs));
+        assert.ok(status.payload?.remoteInputWs?.inputsQueued >= 3, JSON.stringify(status.payload?.remoteInputWs));
+        assert.ok(status.payload?.remoteInputWs?.pointerMovesQueued >= 1, JSON.stringify(status.payload?.remoteInputWs));
+        assert.ok(status.payload?.remoteInputWs?.keyEventsQueued >= 2, JSON.stringify(status.payload?.remoteInputWs));
+        assert.equal(status.payload?.remoteInputWs?.lastDeviceId, DEVICE_ID);
+        assert.equal(status.payload?.remoteInputWs?.lastInputType, 'keyUp');
+
+        console.log('Remote input WebSocket smoke OK');
+    } finally {
+        if (inputWs && inputWs.readyState === WebSocket.OPEN) {
+            inputWs.close();
+        }
+        if (agentWs && agentWs.readyState === WebSocket.OPEN) {
+            agentWs.close();
+        }
+        await bridge.stop();
+    }
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exitCode = 1;
+});