@mindexec/cli 0.2.478 → 0.2.480

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

@@ -1,263 +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;
-});
+#!/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;
+});