@mindexec/cli 0.2.152 → 0.2.154

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.152",
+  "version": "0.2.154",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -21,14 +21,15 @@
   "scripts": {
     "start": "node launch-bridge.cjs",
     "dev": "node launch-bridge.cjs --watch",
-    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
+    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-input-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
     "test:auth": "node scripts/auth-session-smoke.mjs",
     "test:remote": "node scripts/remote-hub-smoke.mjs",
     "test:remote:scale": "node scripts/remote-hub-scale-smoke.mjs",
     "test:remote:render": "node scripts/remote-fleet-render-smoke.mjs",
-    "test:remote:http": "node scripts/remote-http-smoke.mjs",
-    "test:remote:frame-ws": "node scripts/remote-frame-ws-smoke.mjs",
-    "test:remote:agent-ws": "node scripts/remote-agent-ws-smoke.mjs",
+    "test:remote:http": "node scripts/remote-http-smoke.mjs",
+    "test:remote:frame-ws": "node scripts/remote-frame-ws-smoke.mjs",
+    "test:remote:input-ws": "node scripts/remote-input-ws-smoke.mjs",
+    "test:remote:agent-ws": "node scripts/remote-agent-ws-smoke.mjs",
     "test:remote:managed": "node scripts/remote-agent-managed-smoke.mjs",
     "test:remote:registry": "node scripts/remote-registry-follower-smoke.mjs",
     "test:remote:package": "node scripts/remote-agent-package-smoke.mjs",

package/scripts/remote-fleet-render-smoke.mjs

@@ -528,7 +528,8 @@ async function loadCss3DManager() {
                 status: 200,
                 json: async () => ({
                     bridgeToken: 'render-smoke-bridge-token',
-                    remoteFrameWsPath: '/api/remote/frames/ws'
+                    remoteFrameWsPath: '/api/remote/frames/ws',
+                    remoteInputWsPath: '/api/remote/input/ws'
                 })
             };
         },
@@ -864,6 +865,18 @@ try {
                 };
             }
 
+            if (methodName === 'AddRemoteFleetDeviceNodeFromJs') {
+                const deviceId = String(args[1] || '');
+                return {
+                    success: true,
+                    nodeId: 'remote-device-render-smoke',
+                    deviceId,
+                    nodeState: buildDeviceNode(
+                        devices.find(device => device.DeviceId === deviceId) || focusedDevice,
+                        hub.getStatus())
+                };
+            }
+
             return { success: true };
         }
     };
@@ -1094,110 +1107,16 @@ try {
     assert.equal(rerenderedPatchPreview.dataset.remoteFleetFrameSeq, String(websocketFrameSeq));
     assert.equal(rerenderedPatchPreview.querySelector('canvas[data-remote-fleet-frame-canvas="true"]')?.style.display, 'block');
 
-    const liveStartCallsBeforeControl = dotNetCalls.filter(call => call.methodName === 'StartRemoteFleetLiveStreamFromJs').length;
-    const sendCountBeforeControl = diagnostics.webSocketSends.length;
-    const drawCountBeforeControl = document.canvasDrawCalls.length;
     const controlCard = bodyView.querySelector(`article[data-device-id="${patchTarget.DeviceId}"]`);
     assert.ok(controlCard);
     controlCard.dispatchEvent({ type: 'dblclick', button: 0 });
     await wait(30);
-    const controlPopup = document.body.querySelector('[data-remote-fleet-control-popup="true"]');
-    assert.ok(controlPopup, 'double-clicking an MDM tile should open the control popup');
-    const controlShell = controlPopup.querySelector('[data-remote-fleet-control-shell="true"]');
-    const controlStage = controlPopup.querySelector('[data-remote-fleet-control-stage="true"]');
-    const controlCanvas = controlPopup.querySelector('[data-remote-fleet-control-canvas="true"]');
-    assert.ok(controlShell);
-    assert.ok(controlStage);
-    assert.ok(controlCanvas);
-    assert.equal(document.activeElement, controlShell);
-    const controlStartCalls = dotNetCalls
-        .filter(call => call.methodName === 'StartRemoteFleetLiveStreamFromJs')
-        .slice(liveStartCallsBeforeControl);
-    assert.equal(controlStartCalls.length, 1);
-    assert.equal(controlStartCalls[0].args[0], 'remote-fleet-render-smoke');
-    assert.equal(controlStartCalls[0].args[1], patchTarget.DeviceId);
-    assert.equal(controlStartCalls[0].args[2], 20);
-    const controlSubscribe = diagnostics.webSocketSends
-        .slice(sendCountBeforeControl)
-        .map(send => {
-            try {
-                return JSON.parse(send.payload);
-            } catch {
-                return null;
-            }
-        })
-        .find(message =>
-            message
-            && message.type === 'subscribe'
-            && message.nodeId === 'remote-fleet-render-smoke'
-            && message.autoStartLive === true
-            && message.fps === 20
-            && Array.isArray(message.deviceIds)
-            && message.deviceIds.includes(patchTarget.DeviceId));
-    assert.ok(controlSubscribe, 'control popup should reuse the binary frame WebSocket with a 20fps subscription');
-
-    const controlFrameSeq = 20001;
-    liveWs.onmessage?.({
-        data: new Blob([encodeRemoteBinaryFrame({
-            type: 'remote.frame.binary',
-            deviceId: patchTarget.DeviceId,
-            kind: 'live',
-            frameSeq: controlFrameSeq,
-            streamId: 'render-smoke-control-live',
-            contentHash: `render-smoke-control-live-${controlFrameSeq}`,
-            mimeType: 'image/jpeg',
-            width: 64,
-            height: 36,
-            capturedAt: new Date().toISOString(),
-            receivedAt: new Date().toISOString()
-        })])
-    });
-    await wait(40);
-    assert.equal(controlCanvas.style.display, 'block');
-    assert.ok(
-        document.canvasDrawCalls
-            .slice(drawCountBeforeControl)
-            .some(call => call.canvas === controlCanvas && call.op === 'drawImage'),
-        'control popup should paint binary WebSocket frames directly to its canvas');
-
-    controlStage.dispatchEvent({
-        type: 'pointerdown',
-        button: 0,
-        pointerId: 7,
-        clientX: 160,
-        clientY: 90
-    });
-    controlStage.dispatchEvent({
-        type: 'pointerup',
-        button: 0,
-        pointerId: 7,
-        clientX: 160,
-        clientY: 90
-    });
-    controlShell.dispatchEvent({
-        type: 'keydown',
-        key: 'A',
-        code: 'KeyA',
-        repeat: false
-    });
-    await wait(20);
-    const inputCalls = dotNetCalls.filter(call => call.methodName === 'SendRemoteFleetInputFromJs');
-    assert.ok(inputCalls.length >= 3, 'control popup should send pointer and keyboard input through JS interop');
-    const pointerDown = inputCalls.find(call => call.args[2]?.type === 'pointerDown');
-    const keyDown = inputCalls.find(call => call.args[2]?.type === 'keyDown');
-    assert.ok(pointerDown);
-    assert.ok(keyDown);
-    assert.equal(pointerDown.args[0], 'remote-fleet-render-smoke');
-    assert.equal(pointerDown.args[1], patchTarget.DeviceId);
-    assert.equal(pointerDown.args[2].button, 'left');
-    assert.ok(pointerDown.args[2].controlLeaseId);
-    assert.ok(pointerDown.args[2].normalizedX >= 0 && pointerDown.args[2].normalizedX <= 1);
-    assert.ok(pointerDown.args[2].normalizedY >= 0 && pointerDown.args[2].normalizedY <= 1);
-    assert.equal(keyDown.args[2].key, 'A');
-    assert.equal(keyDown.args[2].code, 'KeyA');
-    manager.closeRemoteFleetControlPopupForTest('render-smoke');
-    await wait(20);
     assert.equal(document.body.querySelector('[data-remote-fleet-control-popup="true"]'), null);
+    const addControlNodeCall = dotNetCalls.find(call =>
+        call.methodName === 'AddRemoteFleetDeviceNodeFromJs'
+        && call.args[0] === 'remote-fleet-render-smoke'
+        && call.args[1] === patchTarget.DeviceId);
+    assert.ok(addControlNodeCall, 'double-clicking an MDM tile should create a remote-control canvas node');
 
     const alternateDevice = devices.find(device =>
         device.Connected === true
@@ -1281,8 +1200,7 @@ try {
     assert.ok(devices.some(device => /^synthetic-response-/.test(device.LatestTaskResultResponseId)));
     await wait(20);
     const liveStartCalls = dotNetCalls
-        .filter(call => call.methodName === 'StartRemoteFleetLiveStreamFromJs')
-        .slice(0, liveStartCallsBeforeControl);
+        .filter(call => call.methodName === 'StartRemoteFleetLiveStreamFromJs');
     const subscribeMessages = diagnostics.webSocketSends
         .map(send => {
             try {
@@ -1368,9 +1286,120 @@ try {
         child !== errorFooter && (child.textContent || '').includes('RemoteHub is unavailable')), false);
 
     const deviceBody = document.createElement('div');
+    deviceBody.dataset.nodeId = 'remote-device-render-smoke';
     document.body.appendChild(deviceBody);
+    const sendCountBeforeControlNode = diagnostics.webSocketSends.length;
+    const drawCountBeforeControlNode = document.canvasDrawCalls.length;
     manager.renderRemoteFleetDeviceForTest(deviceBody, buildDeviceNode(focusedDevice, hub.getStatus()));
     assert.ok(deviceBody.textContent.includes(focusedDevice.Name));
+    const deviceControlStage = deviceBody.querySelector('[data-remote-fleet-control-node-stage="true"]');
+    const deviceControlCanvas = deviceBody.querySelector('[data-remote-fleet-control-node-canvas="true"]');
+    assert.ok(deviceControlStage);
+    assert.ok(deviceControlCanvas);
+    assert.equal(document.activeElement, deviceControlStage);
+    await wait(30);
+    const deviceControlSubscribe = diagnostics.webSocketSends
+        .slice(sendCountBeforeControlNode)
+        .map(send => {
+            try {
+                return JSON.parse(send.payload);
+            } catch {
+                return null;
+            }
+        })
+        .find(message =>
+            message
+            && message.type === 'subscribe'
+            && message.nodeId === 'remote-device-render-smoke'
+            && message.autoStartLive === true
+            && message.fps === 20
+            && Array.isArray(message.deviceIds)
+            && message.deviceIds.includes(focusedDevice.DeviceId));
+    assert.ok(deviceControlSubscribe, 'RemoteFleetDevice node should subscribe to 20fps binary frames');
+    const deviceControlWs = diagnostics.webSocketConnections
+        .filter(ws => ws.url.includes('/api/remote/frames/ws'))
+        .at(-1);
+    assert.ok(deviceControlWs, 'RemoteFleetDevice node should open a binary frame WebSocket');
+    const controlNodeFrameSeq = 30001;
+    deviceControlWs.onmessage?.({
+        data: new Blob([encodeRemoteBinaryFrame({
+            type: 'remote.frame.binary',
+            deviceId: focusedDevice.DeviceId,
+            kind: 'live',
+            frameSeq: controlNodeFrameSeq,
+            streamId: 'render-smoke-control-node-live',
+            contentHash: `render-smoke-control-node-live-${controlNodeFrameSeq}`,
+            mimeType: 'image/jpeg',
+            width: 64,
+            height: 36,
+            capturedAt: new Date().toISOString(),
+            receivedAt: new Date().toISOString()
+        })])
+    });
+    await wait(40);
+    assert.ok(
+        document.canvasDrawCalls
+            .slice(drawCountBeforeControlNode)
+            .some(call => call.canvas === deviceControlCanvas && call.op === 'drawImage'),
+        'RemoteFleetDevice node should paint binary WebSocket frames directly to its canvas');
+    deviceControlStage.dispatchEvent({
+        type: 'pointerdown',
+        button: 0,
+        pointerId: 11,
+        clientX: 160,
+        clientY: 90
+    });
+    deviceControlStage.dispatchEvent({
+        type: 'pointerup',
+        button: 0,
+        pointerId: 11,
+        clientX: 160,
+        clientY: 90
+    });
+    deviceControlStage.dispatchEvent({
+        type: 'keydown',
+        key: 'A',
+        code: 'KeyA',
+        repeat: false
+    });
+    deviceControlStage.dispatchEvent({
+        type: 'keyup',
+        key: 'A',
+        code: 'KeyA',
+        repeat: false
+    });
+    await wait(50);
+    const inputWsSends = diagnostics.webSocketSends
+        .filter(send => send.url.includes('/api/remote/input/ws'))
+        .map(send => {
+            try {
+                return JSON.parse(send.payload);
+            } catch {
+                return null;
+            }
+        })
+        .filter(Boolean);
+    assert.ok(inputWsSends.length >= 3, 'RemoteFleetDevice node should send pointer and keyboard input over the input WebSocket');
+    const pointerDown = inputWsSends.find(message => message.input?.type === 'pointerDown');
+    const keyDown = inputWsSends.find(message => message.input?.type === 'keyDown');
+    const keyUp = inputWsSends.find(message => message.input?.type === 'keyUp');
+    assert.ok(pointerDown);
+    assert.ok(keyDown);
+    assert.ok(keyUp);
+    assert.equal(pointerDown.nodeId, 'remote-device-render-smoke');
+    assert.equal(pointerDown.deviceId, focusedDevice.DeviceId);
+    assert.equal(pointerDown.input.button, 'left');
+    assert.ok(pointerDown.input.controlLeaseId);
+    assert.ok(pointerDown.input.normalizedX >= 0 && pointerDown.input.normalizedX <= 1);
+    assert.ok(pointerDown.input.normalizedY >= 0 && pointerDown.input.normalizedY <= 1);
+    assert.equal(keyDown.input.key, 'A');
+    assert.equal(keyDown.input.code, 'KeyA');
+    assert.equal(keyUp.input.key, 'A');
+    assert.equal(keyUp.input.code, 'KeyA');
+    assert.equal(
+        dotNetCalls.filter(call => call.methodName === 'SendRemoteFleetInputFromJs').length,
+        0,
+        'WebSocket input path should not use the slower DotNet input fallback in the happy path');
     assert.ok(deviceBody.querySelector('[data-remote-fleet-action="refresh-device"]'));
     assert.ok(deviceBody.querySelector('[data-remote-fleet-action="task-device"]'));
     assert.ok(deviceBody.textContent.includes('Task timed out waiting for the agent response.'));

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;
+});