@mindexec/cli 0.2.478 → 0.2.480

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

@@ -1,64 +1,64 @@
-#!/usr/bin/env node
-
-import assert from 'node:assert/strict';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-
-const execFileAsync = promisify(execFile);
-
-const REQUIRED_REMOTE_FAST_FILES = [
-    'remote-fast/win-x64/mindexec-remote-fast.exe',
-    'remote-fast/win-x64/mindexec-remote-fast.dll',
-    'remote-fast/win-x64/mindexec-remote-fast.runtimeconfig.json',
-    'remote-fast/osx-arm64/mindexec-remote-fast',
-    'remote-fast/osx-arm64/mindexec-remote-fast.dll',
-    'remote-fast/osx-arm64/mindexec-remote-fast.runtimeconfig.json',
-    'remote-fast/osx-x64/mindexec-remote-fast',
-    'remote-fast/osx-x64/mindexec-remote-fast.dll',
-    'remote-fast/osx-x64/mindexec-remote-fast.runtimeconfig.json'
-];
-
-function parsePackJson(stdout) {
-    const text = String(stdout || '').trim();
-    assert.ok(text, 'npm pack --dry-run should produce JSON output');
-    const payload = JSON.parse(text);
-    assert.ok(Array.isArray(payload) && payload.length > 0, 'npm pack dry-run JSON should contain one package entry');
-    return payload[0];
-}
-
-function resolveNpmPackCommand() {
-    const npmExecPath = String(process.env.npm_execpath || '').trim();
-    if (npmExecPath && /\.js$/i.test(npmExecPath)) {
-        return {
-            command: process.execPath,
-            argsPrefix: [npmExecPath]
-        };
-    }
-
-    return {
-        command: process.platform === 'win32' ? 'npm.cmd' : 'npm',
-        argsPrefix: []
-    };
-}
-
-async function main() {
-    const npm = resolveNpmPackCommand();
-    const { stdout } = await execFileAsync(npm.command, [...npm.argsPrefix, 'pack', '--dry-run', '--json'], {
-        windowsHide: true,
-        maxBuffer: 16 * 1024 * 1024
-    });
-    const pack = parsePackJson(stdout);
-    const files = new Set((pack.files || []).map(file => String(file.path || '').replace(/\\/g, '/')));
-
-    for (const required of REQUIRED_REMOTE_FAST_FILES) {
-        assert.ok(files.has(required), `packaged @mindexec/cli is missing ${required}`);
-    }
-
-    const npxFallbackOnly = [...files].some(file => file.endsWith('server.js'))
-        && ![...files].some(file => file.startsWith('remote-fast/'));
-    assert.equal(npxFallbackOnly, false, 'packaged CLI must include bundled RemoteFast, not only npx fallback code');
-
-    console.log('RemoteAgent package smoke OK');
-}
-
-await main();
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+const REQUIRED_REMOTE_FAST_FILES = [
+    'remote-fast/win-x64/mindexec-remote-fast.exe',
+    'remote-fast/win-x64/mindexec-remote-fast.dll',
+    'remote-fast/win-x64/mindexec-remote-fast.runtimeconfig.json',
+    'remote-fast/osx-arm64/mindexec-remote-fast',
+    'remote-fast/osx-arm64/mindexec-remote-fast.dll',
+    'remote-fast/osx-arm64/mindexec-remote-fast.runtimeconfig.json',
+    'remote-fast/osx-x64/mindexec-remote-fast',
+    'remote-fast/osx-x64/mindexec-remote-fast.dll',
+    'remote-fast/osx-x64/mindexec-remote-fast.runtimeconfig.json'
+];
+
+function parsePackJson(stdout) {
+    const text = String(stdout || '').trim();
+    assert.ok(text, 'npm pack --dry-run should produce JSON output');
+    const payload = JSON.parse(text);
+    assert.ok(Array.isArray(payload) && payload.length > 0, 'npm pack dry-run JSON should contain one package entry');
+    return payload[0];
+}
+
+function resolveNpmPackCommand() {
+    const npmExecPath = String(process.env.npm_execpath || '').trim();
+    if (npmExecPath && /\.js$/i.test(npmExecPath)) {
+        return {
+            command: process.execPath,
+            argsPrefix: [npmExecPath]
+        };
+    }
+
+    return {
+        command: process.platform === 'win32' ? 'npm.cmd' : 'npm',
+        argsPrefix: []
+    };
+}
+
+async function main() {
+    const npm = resolveNpmPackCommand();
+    const { stdout } = await execFileAsync(npm.command, [...npm.argsPrefix, 'pack', '--dry-run', '--json'], {
+        windowsHide: true,
+        maxBuffer: 16 * 1024 * 1024
+    });
+    const pack = parsePackJson(stdout);
+    const files = new Set((pack.files || []).map(file => String(file.path || '').replace(/\\/g, '/')));
+
+    for (const required of REQUIRED_REMOTE_FAST_FILES) {
+        assert.ok(files.has(required), `packaged @mindexec/cli is missing ${required}`);
+    }
+
+    const npxFallbackOnly = [...files].some(file => file.endsWith('server.js'))
+        && ![...files].some(file => file.startsWith('remote-fast/'));
+    assert.equal(npxFallbackOnly, false, 'packaged CLI must include bundled RemoteFast, not only npx fallback code');
+
+    console.log('RemoteAgent package smoke OK');
+}
+
+await main();

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

@@ -1,269 +1,269 @@
-#!/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',
-        protocol: 'mindexec.remote.agent',
-        protocolVersion: 2,
-        frameProtocol: {
-            protocol: 'mindexec.remote.frame.v2',
-            version: 2,
-            handshake: 'smartview-request-open-frame',
-            defaultMode: 'remote-fast'
-        },
-        frameModes: [{
-            mode: 'remote-fast',
-            label: 'RemoteFast JPEG Binary',
-            transport: 'ws-binary',
-            encoding: 'image',
-            codec: 'jpeg',
-            compression: 'image/jpeg',
-            profile: 'jpeg-binary-v1',
-            modeVersion: 1,
-            implemented: true
-        }],
-        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()
-        }
-    }));
-
-    const welcome = await waitFor(() => received.find(item => item.type === 'welcome'), 5000, 'welcome');
-    assert.equal(welcome.protocol, 'mindexec.remote.agent');
-    assert.equal(welcome.frameProtocol?.handshake, 'smartview-request-open-frame');
-    assert.equal(welcome.frameProtocol?.defaultMode, 'remote-fast');
-    assert.ok(welcome.frameModes?.some(item => item.mode === 'remote-fast'));
-    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);
-    assert.equal(device.protocol, 'mindexec.remote.agent');
-    assert.equal(device.frameProtocol?.handshake, 'smartview-request-open-frame');
-    assert.ok(device.frameModes?.some(item => item.mode === 'remote-fast'));
-
-    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);
-    const liveMessage = await waitFor(
-        () => received.find(item => item.commandId === liveCommand.commandId),
-        5000,
-        'live command');
-    assert.equal(liveMessage.command, 'stream.start');
-    assert.equal(liveMessage.payload?.handshake, 'smartview-request-open-frame');
-    assert.equal(liveMessage.payload?.mode, 'remote-fast');
-    assert.equal(liveMessage.payload?.frameMode, 'remote-fast');
-    assert.equal(liveMessage.payload?.frameProfile, 'jpeg-binary-v1');
-    assert.equal(liveMessage.payload?.compression, 'image/jpeg');
-    assert.equal(liveMessage.payload?.transferProtocol, 'mindexec.remote.frame.v2');
-    ws.send(JSON.stringify({
-        type: 'stream.open',
-        commandId: liveCommand.commandId,
-        streamId: 'remote-agent-ws-live',
-        mode: 'remote-fast',
-        frameMode: 'remote-fast',
-        frameProfile: 'jpeg-binary-v1',
-        encoding: 'image',
-        codec: 'png',
-        compression: 'image/png',
-        transferProtocol: 'mindexec.remote.frame.v2',
-        transferProtocolVersion: 2,
-        handshake: 'smartview-request-open-frame',
-        fps: 10,
-        width: 2,
-        height: 1,
-        openedAt: new Date().toISOString()
-    }));
-    await waitFor(() => hub.listDevices()[0]?.activeLiveStream?.open === true, 5000, 'live stream open');
-    writeAgentBinaryFrame(ws, {
-        frameKind: 'stream',
-        commandId: liveCommand.commandId,
-        streamId: 'remote-agent-ws-live',
-        frameSeq: 12,
-        width: 2,
-        height: 1,
-        mimeType: 'image/png',
-        mode: 'remote-fast',
-        frameMode: 'remote-fast',
-        frameProfile: 'jpeg-binary-v1',
-        encoding: 'image',
-        codec: 'png',
-        compression: 'image/png',
-        transferProtocol: 'mindexec.remote.frame.v2',
-        transferProtocolVersion: 2,
-        handshake: 'smartview-request-open-frame',
-        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');
-    assert.equal(liveDevice.activeLiveStream.open, true);
-    assert.equal(liveDevice.activeLiveStream.frameMode, 'remote-fast');
-    assert.equal(liveDevice.latestLiveFrame.frameMode, 'remote-fast');
-    assert.equal(liveDevice.latestLiveFrame.frameProfile, 'jpeg-binary-v1');
-    assert.equal(liveDevice.latestLiveFrame.compression, 'image/png');
-    assert.equal(liveDevice.latestLiveFrame.transferProtocol, 'mindexec.remote.frame.v2');
-
-    ws.close();
-    console.log('RemoteAgent WebSocket smoke OK');
-} finally {
-    if (ws && ws.readyState === WebSocket.OPEN) {
-        ws.close();
-    }
-    await hub.close();
-}
+#!/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',
+        protocol: 'mindexec.remote.agent',
+        protocolVersion: 2,
+        frameProtocol: {
+            protocol: 'mindexec.remote.frame.v2',
+            version: 2,
+            handshake: 'smartview-request-open-frame',
+            defaultMode: 'remote-fast'
+        },
+        frameModes: [{
+            mode: 'remote-fast',
+            label: 'RemoteFast JPEG Binary',
+            transport: 'ws-binary',
+            encoding: 'image',
+            codec: 'jpeg',
+            compression: 'image/jpeg',
+            profile: 'jpeg-binary-v1',
+            modeVersion: 1,
+            implemented: true
+        }],
+        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()
+        }
+    }));
+
+    const welcome = await waitFor(() => received.find(item => item.type === 'welcome'), 5000, 'welcome');
+    assert.equal(welcome.protocol, 'mindexec.remote.agent');
+    assert.equal(welcome.frameProtocol?.handshake, 'smartview-request-open-frame');
+    assert.equal(welcome.frameProtocol?.defaultMode, 'remote-fast');
+    assert.ok(welcome.frameModes?.some(item => item.mode === 'remote-fast'));
+    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);
+    assert.equal(device.protocol, 'mindexec.remote.agent');
+    assert.equal(device.frameProtocol?.handshake, 'smartview-request-open-frame');
+    assert.ok(device.frameModes?.some(item => item.mode === 'remote-fast'));
+
+    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);
+    const liveMessage = await waitFor(
+        () => received.find(item => item.commandId === liveCommand.commandId),
+        5000,
+        'live command');
+    assert.equal(liveMessage.command, 'stream.start');
+    assert.equal(liveMessage.payload?.handshake, 'smartview-request-open-frame');
+    assert.equal(liveMessage.payload?.mode, 'remote-fast');
+    assert.equal(liveMessage.payload?.frameMode, 'remote-fast');
+    assert.equal(liveMessage.payload?.frameProfile, 'jpeg-binary-v1');
+    assert.equal(liveMessage.payload?.compression, 'image/jpeg');
+    assert.equal(liveMessage.payload?.transferProtocol, 'mindexec.remote.frame.v2');
+    ws.send(JSON.stringify({
+        type: 'stream.open',
+        commandId: liveCommand.commandId,
+        streamId: 'remote-agent-ws-live',
+        mode: 'remote-fast',
+        frameMode: 'remote-fast',
+        frameProfile: 'jpeg-binary-v1',
+        encoding: 'image',
+        codec: 'png',
+        compression: 'image/png',
+        transferProtocol: 'mindexec.remote.frame.v2',
+        transferProtocolVersion: 2,
+        handshake: 'smartview-request-open-frame',
+        fps: 10,
+        width: 2,
+        height: 1,
+        openedAt: new Date().toISOString()
+    }));
+    await waitFor(() => hub.listDevices()[0]?.activeLiveStream?.open === true, 5000, 'live stream open');
+    writeAgentBinaryFrame(ws, {
+        frameKind: 'stream',
+        commandId: liveCommand.commandId,
+        streamId: 'remote-agent-ws-live',
+        frameSeq: 12,
+        width: 2,
+        height: 1,
+        mimeType: 'image/png',
+        mode: 'remote-fast',
+        frameMode: 'remote-fast',
+        frameProfile: 'jpeg-binary-v1',
+        encoding: 'image',
+        codec: 'png',
+        compression: 'image/png',
+        transferProtocol: 'mindexec.remote.frame.v2',
+        transferProtocolVersion: 2,
+        handshake: 'smartview-request-open-frame',
+        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');
+    assert.equal(liveDevice.activeLiveStream.open, true);
+    assert.equal(liveDevice.activeLiveStream.frameMode, 'remote-fast');
+    assert.equal(liveDevice.latestLiveFrame.frameMode, 'remote-fast');
+    assert.equal(liveDevice.latestLiveFrame.frameProfile, 'jpeg-binary-v1');
+    assert.equal(liveDevice.latestLiveFrame.compression, 'image/png');
+    assert.equal(liveDevice.latestLiveFrame.transferProtocol, 'mindexec.remote.frame.v2');
+
+    ws.close();
+    console.log('RemoteAgent WebSocket smoke OK');
+} finally {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.close();
+    }
+    await hub.close();
+}