@mindexec/cli 0.2.445 → 0.2.447

package/README.md

@@ -52,7 +52,7 @@ experiments. By default it binds to loopback only:
 
 ```bash
 npx @mindexec/cli
-npx @mindexec/remote connect --manager 127.0.0.1:5197 --pair <pair-token>
+npx @mindexec/remote connect --manager 127.0.0.1:5198 --pair <pair-token>
 ```
 
 Read the pair token from the protected local endpoint:
@@ -65,7 +65,7 @@ LAN/direct mode must be enabled explicitly by changing the RemoteHub bind host:
 
 ```powershell
 $env:REMOTE_HUB_HOST="0.0.0.0"
-$env:REMOTE_HUB_PORT="5197"
+$env:REMOTE_HUB_PORT="5198"
 $env:REMOTE_HUB_PAIR_TOKEN="<strong-token>"
 npx @mindexec/cli
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.445",
+  "version": "0.2.447",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -63,7 +63,7 @@
   },
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "@mindexec/remote": "^0.1.17",
+    "@mindexec/remote": "^0.1.18",
     "@openai/codex-sdk": "^0.144.1",
     "chokidar": "^3.6.0",
     "cors": "^2.8.5",
@@ -71,10 +71,13 @@
     "ffmpeg-static": "^5.3.0",
     "multer": "^2.2.0",
     "playwright-core": "^1.53.0",
-    "sharp": "^0.33.2",
+    "sharp": "^0.35.3",
     "web-tree-sitter": "^0.22.6",
     "ws": "^8.16.0"
   },
+  "overrides": {
+    "body-parser": "1.20.6"
+  },
   "bin": {
     "mindexec": "launch-bridge.cjs",
     "mind-bridge": "launch-bridge.cjs"

package/remote-hub.js

@@ -2,7 +2,7 @@ import net from 'net';
 import os from 'os';
 import crypto from 'crypto';
 
-const DEFAULT_REMOTE_HUB_PORT = 5197;
+const DEFAULT_REMOTE_HUB_PORT = 5198;
 const DEFAULT_REMOTE_HUB_HOST = '0.0.0.0';
 const DEFAULT_HEARTBEAT_MS = 5000;
 const DEFAULT_AGENT_TASK_TIMEOUT_MS = 120000;
@@ -212,6 +212,30 @@ function getSupportedRemoteFrameModeProfiles() {
         .map(serializeRemoteFrameModeProfile);
 }
 
+function resolveDeviceRemoteFrameMode(device, requestedMode, fallbackMode = DEFAULT_REMOTE_FRAME_MODE) {
+    const requested = normalizeRemoteFrameMode(requestedMode, fallbackMode);
+    if (device?.frameModesAdvertised === false) {
+        return normalizeRemoteFrameMode(device?.frameProtocol?.defaultMode, DEFAULT_REMOTE_FRAME_MODE);
+    }
+
+    const supportedModes = new Set(
+        (Array.isArray(device?.frameModes) ? device.frameModes : [])
+            .filter(profile => profile?.implemented !== false)
+            .map(profile => normalizeRemoteFrameMode(profile?.mode || profile?.frameMode || profile?.profile, ''))
+            .filter(Boolean));
+
+    if (supportedModes.size === 0 || supportedModes.has(requested)) {
+        return requested;
+    }
+
+    const deviceDefault = normalizeRemoteFrameMode(device?.frameProtocol?.defaultMode, fallbackMode);
+    if (supportedModes.has(deviceDefault)) {
+        return deviceDefault;
+    }
+
+    return supportedModes.values().next().value || normalizeRemoteFrameMode(fallbackMode);
+}
+
 function buildRemoteFrameProtocolDescriptor() {
     return {
         protocol: REMOTE_FRAME_PROTOCOL,
@@ -1125,6 +1149,12 @@ export function createRemoteHub(options = {}) {
     const taskBatches = new Map();
     const sockets = new Map();
     const allSockets = new Set();
+    const sideChannelSockets = {
+        input: new Map(),
+        frame: new Map(),
+        audio: new Map(),
+        file: new Map()
+    };
     const duplicateDeviceLogAt = new Map();
     let server = null;
     let started = false;
@@ -1523,6 +1553,9 @@ export function createRemoteHub(options = {}) {
 
     function closeExistingDeviceSocket(deviceId, nextSessionId) {
         const existing = devices.get(deviceId);
+        for (const channel of Object.keys(sideChannelSockets)) {
+            closeSideChannel(existing, channel, 'replaced-by-new-session');
+        }
         if (!existing?.socket || existing.socket.destroyed) {
             return;
         }
@@ -1537,6 +1570,37 @@ export function createRemoteHub(options = {}) {
         existing.socket.destroy();
     }
 
+    function closeSideChannel(device, channel, reason = `${channel}-socket-closed`) {
+        const socketKey = `${channel}Socket`;
+        const socket = device?.[socketKey];
+        if (!socket) return;
+        device[socketKey] = null;
+        sideChannelSockets[channel]?.delete(socket);
+        try {
+            writeJsonLine(socket, { type: 'disconnect', channel, reason });
+        } catch {
+            // Best-effort notice before closing the side channel.
+        }
+        try {
+            socket.destroy?.();
+        } catch {
+            // Ignore close failures.
+        }
+    }
+
+    function detachSideChannel(socket, channel, reason = `${channel}-socket-closed`) {
+        const channelMap = sideChannelSockets[channel];
+        const deviceId = channelMap?.get(socket);
+        channelMap?.delete(socket);
+        if (!deviceId) return;
+        const device = devices.get(deviceId);
+        const socketKey = `${channel}Socket`;
+        if (!device || device[socketKey] !== socket) return;
+        device[socketKey] = null;
+        device[`${channel}LastSeenAt`] = new Date().toISOString();
+        emitRemoteEvent(`Remote${channel[0].toUpperCase()}${channel.slice(1)}SocketDisconnected`, device, { reason });
+    }
+
     function getDeviceActivityMs(device) {
         return Math.max(
             Date.parse(device?.lastSeenAt || '') || 0,
@@ -1841,6 +1905,7 @@ export function createRemoteHub(options = {}) {
             protocolVersion: Number.isFinite(Number(hello.protocolVersion)) ? Math.max(1, Math.floor(Number(hello.protocolVersion))) : 1,
             frameProtocol: frameProtocol || buildRemoteFrameProtocolDescriptor(),
             frameModes: frameModes.length > 0 ? frameModes : getSupportedRemoteFrameModeProfiles(),
+            frameModesAdvertised: frameModes.length > 0,
             capabilities,
             connected: true,
             connectedAt: now,
@@ -1853,6 +1918,10 @@ export function createRemoteHub(options = {}) {
             status: {},
             latestThumbnail: null,
             latestLiveFrame: null,
+            inputSocket: null,
+            frameSocket: null,
+            audioSocket: null,
+            fileSocket: null,
             recentFramePayloads: {
                 thumbnail: [],
                 live: []
@@ -1885,6 +1954,40 @@ export function createRemoteHub(options = {}) {
         return device;
     }
 
+    function attachSideChannel(socket, hello, channel) {
+        const deviceId = normalizeDeviceId(hello.deviceId);
+        const device = devices.get(deviceId);
+        if (!device || !device.connected || !device.socket || device.socket.destroyed) {
+            writeJsonLine(socket, { type: 'error', error: 'device-not-connected' });
+            socket.destroy();
+            return null;
+        }
+
+        closeSideChannel(device, channel, `replaced-by-new-${channel}-socket`);
+        const now = new Date().toISOString();
+        device[`${channel}Socket`] = socket;
+        device[`${channel}ConnectedAt`] = now;
+        device[`${channel}LastSeenAt`] = now;
+        sideChannelSockets[channel].set(socket, deviceId);
+        writeJsonLine(socket, {
+            type: 'welcome',
+            channel,
+            protocol: REMOTE_AGENT_PROTOCOL,
+            protocolVersion: REMOTE_PROTOCOL_VERSION,
+            sessionId: device.sessionId,
+            deviceId,
+            ...(channel === 'frame'
+                ? {
+                    frameProtocol: buildRemoteFrameProtocolDescriptor(),
+                    frameModes: getSupportedRemoteFrameModeProfiles()
+                }
+                : {}),
+            serverTime: now
+        });
+        emitRemoteEvent(`Remote${channel[0].toUpperCase()}${channel.slice(1)}SocketConnected`, device);
+        return device;
+    }
+
     function detachSocket(socket, reason = 'socket-closed') {
         const deviceId = sockets.get(socket);
         sockets.delete(socket);
@@ -1906,6 +2009,9 @@ export function createRemoteHub(options = {}) {
             device.activeLiveStream.stoppedAt = device.disconnectedAt;
             device.activeLiveStream.stopReason = reason;
         }
+        for (const channel of Object.keys(sideChannelSockets)) {
+            closeSideChannel(device, channel, reason);
+        }
         failAllPendingTasks(device, 'device-disconnected');
         logWarn('remote', `device disconnected ${device.deviceName} (${deviceId}): ${reason}`);
         emitRemoteEvent('RemoteDeviceDisconnected', device, { reason });
@@ -2570,6 +2676,16 @@ export function createRemoteHub(options = {}) {
                 return;
             }
 
+            const channel = safeString(message.channel || message.Channel, 40).toLowerCase();
+            if (Object.hasOwn(sideChannelSockets, channel)) {
+                const device = attachSideChannel(socket, message, channel);
+                if (!device) return;
+                state.authenticated = true;
+                state.device = device;
+                state.sideChannel = channel;
+                return;
+            }
+
             const device = attachDevice(socket, message);
             if (!device) {
                 return;
@@ -2586,6 +2702,17 @@ export function createRemoteHub(options = {}) {
             return;
         }
 
+        if (state.sideChannel) {
+            device[`${state.sideChannel}LastSeenAt`] = new Date().toISOString();
+            if (state.sideChannel === 'input' && message.type === 'input.error') {
+                emitRemoteEvent('RemoteInputError', device, {
+                    inputSeq: Number(message.inputSeq || 0) || 0,
+                    error: safeString(message.error, 600) || 'remote-input-failed'
+                });
+            }
+            return;
+        }
+
         device.counters.messagesReceived += 1;
         device.lastSeenAt = new Date().toISOString();
 
@@ -2698,7 +2825,11 @@ export function createRemoteHub(options = {}) {
         const detach = reason => {
             allSockets.delete(socket);
             clearTimeout(helloTimer);
-            detachSocket(socket, reason);
+            if (state.sideChannel) {
+                detachSideChannel(socket, state.sideChannel, reason);
+            } else {
+                detachSocket(socket, reason);
+            }
         };
 
         socket.onCloseMessage = reason => detach(reason || 'websocket-closed');
@@ -2867,12 +2998,20 @@ export function createRemoteHub(options = {}) {
         socket.on('close', () => {
             allSockets.delete(socket);
             clearTimeout(helloTimer);
-            detachSocket(socket);
+            if (state.sideChannel) {
+                detachSideChannel(socket, state.sideChannel);
+            } else {
+                detachSocket(socket);
+            }
         });
         socket.on('error', err => {
             allSockets.delete(socket);
             clearTimeout(helloTimer);
-            detachSocket(socket, err?.message || 'socket-error');
+            if (state.sideChannel) {
+                detachSideChannel(socket, state.sideChannel, err?.message || 'socket-error');
+            } else {
+                detachSocket(socket, err?.message || 'socket-error');
+            }
         });
     }
 
@@ -2936,6 +3075,7 @@ export function createRemoteHub(options = {}) {
         }
 
         sockets.clear();
+        Object.values(sideChannelSockets).forEach(channelMap => channelMap.clear());
         if (!server) {
             started = false;
             return;
@@ -3058,10 +3198,29 @@ export function createRemoteHub(options = {}) {
             return { ok: false, error: 'missing-input-type' };
         }
 
+        const inputSocket = device.inputSocket;
+        if (inputSocket && !inputSocket.destroyed) {
+            const sent = writeJsonLine(inputSocket, {
+                type: 'input.control',
+                payload: {
+                    ...normalized,
+                    hubForwardedAtEpochMs: Date.now(),
+                    issuedAt: normalized.issuedAt || new Date().toISOString()
+                }
+            });
+            if (sent) {
+                device.counters.commandsSent += 1;
+                device.inputLastSeenAt = new Date().toISOString();
+                return { ok: true, inputSocket: true };
+            }
+            detachSideChannel(inputSocket, 'input', 'input-socket-write-failed');
+        }
+
         return sendCommand(deviceId, {
             command: 'input.control',
             payload: {
                 ...normalized,
+                hubForwardedAtEpochMs: Date.now(),
                 issuedAt: normalized.issuedAt || new Date().toISOString()
             }
         });
@@ -3285,7 +3444,10 @@ export function createRemoteHub(options = {}) {
             const now = new Date().toISOString();
             const streamId = safeString(options.streamId, 128) || `live-${Date.now()}`;
             const streamPurpose = safeString(options.streamPurpose, 32).toLowerCase();
-            const requestedMode = options.mode || (streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo');
+            const requestedMode = resolveDeviceRemoteFrameMode(
+                device,
+                options.mode || (streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo'),
+                streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo');
             const fps = clampNumber(options.fps, 1, 30, streamPurpose === 'control' ? 30 : 20);
             const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
             const transfer = buildRemoteFrameTransferDescriptor(requestedMode, streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo');
@@ -3342,7 +3504,10 @@ export function createRemoteHub(options = {}) {
         const now = new Date().toISOString();
         const streamId = safeString(options.streamId, 128) || `live-${Date.now()}`;
         const streamPurpose = safeString(options.streamPurpose, 32).toLowerCase();
-        const requestedMode = options.mode || (streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo');
+        const requestedMode = resolveDeviceRemoteFrameMode(
+            device,
+            options.mode || (streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo'),
+            streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo');
         const fps = clampNumber(options.fps, 1, 30, streamPurpose === 'control' ? 30 : 20);
         const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
         const transfer = buildRemoteFrameTransferDescriptor(requestedMode, streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo');

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

@@ -293,6 +293,7 @@ async function main() {
         const live = await fetchJson(`${hostBridge.baseUrl}/api/remote/devices/${encodeURIComponent(device.deviceId)}/live/start`, {
             method: 'POST',
             body: JSON.stringify({
+                mode: 'remote-fast',
                 fps: REQUESTED_FPS,
                 maxWidth: 960,
                 maxHeight: 540,

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

@@ -435,7 +435,9 @@ function projectDevice(device) {
 
 async function loadCss3DManager() {
     const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const hotPathModulePath = path.resolve(__dirname, '../../MindExecution.Shared/wwwroot/js/mind-map-css3d-hotpath.js');
     const managerPath = path.resolve(__dirname, '../../MindExecution.Shared/wwwroot/js/mind-map-css3d-manager.js');
+    const hotPathSource = await fs.readFile(hotPathModulePath, 'utf8');
     const source = await fs.readFile(managerPath, 'utf8');
     const document = new MiniDocument();
     const objectUrlCalls = [];
@@ -558,11 +560,18 @@ async function loadCss3DManager() {
                 textOverlayInvalidations.push({ module, nodeId, reason, fallback: true });
             }
         },
+        MindExecRemoteCodecs: {
+            async decodeH264Frame(canvas, frame, onFrame) {
+                onFrame?.(canvas, frame);
+                return true;
+            }
+        },
         Promise
     };
     context.window = context;
     context.self = context;
 
+    vm.runInNewContext(hotPathSource, context, { filename: hotPathModulePath });
     vm.runInNewContext(source, context, { filename: managerPath });
     return {
         manager: context.window.MindMapCss3DManager,
@@ -584,6 +593,15 @@ function wait(ms = 0) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+async function waitFor(predicate, timeoutMs = 500, intervalMs = 10) {
+    const deadline = Date.now() + Math.max(1, Number(timeoutMs || 500));
+    while (Date.now() < deadline) {
+        if (predicate()) return true;
+        await wait(intervalMs);
+    }
+    return predicate();
+}
+
 function encodeRemoteBinaryFrame(metadata, payload = new Uint8Array([0xff, 0xd8, 0xff, 0xd9])) {
     const metaBytes = new TextEncoder().encode(JSON.stringify(metadata));
     const payloadBytes = payload instanceof Uint8Array ? payload : new Uint8Array(payload);
@@ -598,7 +616,7 @@ function encodeRemoteBinaryFrame(metadata, payload = new Uint8Array([0xff, 0xd8,
 
 function buildMonitorNode(devices, hubStatus, latestTaskBatch = null, recentTaskBatches = [], lastError = '', nodeId = 'remote-fleet-render-smoke') {
     const connected = devices.filter(device => device.Connected).length;
-    const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5197';
+    const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5198';
     const pairToken = hubStatus.pairToken || 'render-smoke-token';
     const hostTargetState = hubStatus.hostTargetActive
         ? (hubStatus.hostTargetNodeId === nodeId ? 'hosting' : 'other-monitor')
@@ -665,7 +683,7 @@ function createRemoteFleetTemplateShell(document, focusDeviceId = '', nodeId = '
 }
 
 function buildDeviceNode(device, hubStatus) {
-    const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5197';
+    const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5198';
     return {
         id: 'remote-device-render-smoke',
         contentType: 'memo',
@@ -1060,6 +1078,13 @@ try {
         binaryDrawCalls.some(call => call.op === 'clearRect' || call.op === 'fillRect'),
         false,
         'binary Blob frame paint must not clear/fill the canvas before drawing');
+    assert.ok(
+        Number(moduleRef._forceUpdateFrames || 0) >= 2,
+        'binary live frame commits must wake the passive MDM CSS3D frame loop');
+    assert.equal(moduleRef._lastAnimationWakeReason, 'remote-live-css3d-frame');
+    assert.ok(
+        diagnostics.runtimeTrace.some(event => event.type === 'remote.frame.css3dWake'),
+        'binary live frame commits must trace the MDM CSS3D wake path');
     const binaryCanvasBeforeRerender = binaryCanvas;
 
     const liveOverlayCard = document.createElement('div');
@@ -1073,12 +1098,28 @@ try {
     moduleRef._lastAnimationWakeReason = '';
 
     await wait(20);
-    const liveWs = diagnostics.webSocketConnections[0];
-    assert.ok(liveWs, 'expected MDM render to open the binary frame WebSocket');
-    assert.equal(liveWs.readyState, 1, 'binary frame WebSocket should be open before rerender');
+    const liveWs = diagnostics.webSocketConnections.find(connection =>
+        String(connection?.url || '').includes('/api/remote/atlas/ws'));
+    assert.ok(
+        liveWs,
+        `expected MDM render to open the Mode 4 Atlas WebSocket: ${diagnostics.webSocketConnections.map(connection => connection.url).join(', ')}`
+    );
+    assert.equal(liveWs.readyState, 1, 'Mode 4 Atlas WebSocket should be open before rerender');
     const wsCountBeforeRerender = diagnostics.webSocketConnections.length;
     const wsCloseCountBeforeRerender = liveWs.closeCount;
     const websocketFrameSeq = 10001;
+    liveWs.onmessage?.({
+        data: JSON.stringify({
+            type: 'Mode4AtlasLayout',
+            tiles: [{
+                deviceId: patchTarget.DeviceId,
+                x: 0,
+                y: 0,
+                width: 64,
+                height: 36
+            }]
+        })
+    });
     liveWs.onmessage?.({
         data: new Blob([encodeRemoteBinaryFrame({
             type: 'remote.frame.binary',
@@ -1088,36 +1129,36 @@ try {
             streamId: 'render-smoke-ws-live',
             contentHash: `render-smoke-ws-live-${websocketFrameSeq}`,
             mimeType: 'image/jpeg',
+            frameMode: 'mode4-h264-atlas',
             width: 64,
             height: 36,
             capturedAt: new Date().toISOString(),
             receivedAt: new Date().toISOString()
         })])
     });
-    await wait(30);
+    await waitFor(
+        () => patchPreview.dataset.remoteFleetFrameSeq === String(websocketFrameSeq)
+    );
     assert.equal(
         patchPreview.dataset.remoteFleetFrameSeq,
         String(websocketFrameSeq),
         JSON.stringify(diagnostics.runtimeTrace.slice(-12)));
-    await wait(10);
-    assert.ok(
-        Number(moduleRef._forceUpdateFrames || 0) >= 2,
-        'binary live frame commits must wake the passive MDM CSS3D frame loop');
-    assert.equal(moduleRef._lastAnimationWakeReason, 'remote-live-css3d-frame');
     assert.ok(
-        diagnostics.runtimeTrace.some(event => event.type === 'remote.frame.css3dWake'),
-        'binary live frame commits must trace the MDM CSS3D wake path');
+        diagnostics.runtimeTrace.some(event =>
+            event.type === 'remote.atlas.painted' &&
+            Number(event.frameSeq || 0) === websocketFrameSeq),
+        'Mode 4 Atlas frame must paint its configured device tile');
 
     manager.renderRemoteFleetMonitorForTest(bodyView, buildMonitorNode(devices, hub.getStatus({ includeSecrets: true }), latestTaskBatch, recentTaskBatches));
     await wait(30);
     assert.equal(
         liveWs.closeCount,
         wsCloseCountBeforeRerender,
-        'MDM rerender must not close the active binary frame WebSocket');
+        'MDM rerender must not close the active Mode 4 Atlas WebSocket');
     assert.equal(
         diagnostics.webSocketConnections.length,
         wsCountBeforeRerender,
-        'MDM rerender must reuse the active binary frame WebSocket instead of opening a replacement');
+        'MDM rerender must reuse the active Mode 4 Atlas WebSocket instead of opening a replacement');
     const rerenderedPatchPreview = bodyView
         .querySelector(`article[data-device-id="${patchTarget.DeviceId}"]`)
         ?.querySelector('[data-remote-fleet-device-preview="tile"]');
@@ -1148,15 +1189,11 @@ try {
         .querySelector(`article[data-device-id="${patchTarget.DeviceId}"]`)
         ?.querySelector('[data-remote-fleet-device-preview="tile"]');
     assert.ok(otherBoardPatchPreview);
-    assert.equal(
-        otherBoardPatchPreview.dataset.remoteFleetFrameSeq,
-        String(websocketFrameSeq),
-        'a different-board MDM should prime from the device-global latest binary frame cache');
-    assert.equal(
-        otherBoardPatchPreview.querySelector('canvas[data-remote-fleet-frame-canvas="true"]')?.style.display,
-        'block');
+    assert.ok(
+        diagnostics.webSocketConnections.length > wsCountBeforeRerender,
+        'a different-board MDM must own a separate Mode 4 Atlas session');
     assert.ok(diagnostics.runtimeTrace.some(event =>
-        (event.type === 'remote.frame.wsCachePrimed' || event.type === 'remote.frame.surfaceCachePrimed')
+        event.type === 'remote.atlas.wsOpen'
         && event.nodeId === otherBoardNodeId));
     otherBoardShell.remove();
 
@@ -1260,18 +1297,17 @@ try {
             }
         })
         .filter(Boolean);
-    const autoLiveSubscribe = subscribeMessages.find(message =>
-        message.type === 'subscribe'
-        && message.nodeId === 'remote-fleet-render-smoke'
-        && message.autoStartLive === true);
+    const atlasConfigure = subscribeMessages.find(message =>
+        message.type === 'configure');
     assert.ok(diagnostics.fetchCalls.some(call => call.url.includes('/api/status?remoteFrames=ws')));
-    assert.ok(diagnostics.webSocketConnections.length >= 1, 'expected MDM render to open binary frame WebSocket');
-    assert.ok(autoLiveSubscribe, 'expected MDM render to subscribe with autoStartLive over WebSocket');
-    assert.equal(autoLiveSubscribe.fps, 12);
-    assert.equal(autoLiveSubscribe.maxWidth, 960);
-    assert.equal(autoLiveSubscribe.maxHeight, 540);
-    assert.equal(autoLiveSubscribe.quality, 60);
-    assert.ok(autoLiveSubscribe.deviceIds.length > 1, 'expected visible connected devices in WS subscription');
+    assert.ok(diagnostics.webSocketConnections.length >= 1, 'expected MDM render to open Mode 4 Atlas WebSocket');
+    assert.ok(atlasConfigure, 'expected MDM render to configure the Mode 4 Atlas WebSocket');
+    assert.equal(atlasConfigure.fps, 20);
+    assert.equal(atlasConfigure.width, 1920);
+    assert.equal(atlasConfigure.height, 1080);
+    assert.equal(atlasConfigure.tileWidth, 320);
+    assert.equal(atlasConfigure.tileHeight, 180);
+    assert.ok(atlasConfigure.deviceIds.length > 1, 'expected visible connected devices in Atlas configuration');
     assert.ok(diagnostics.runtimeTrace.some(event => event.type === 'remote.live.wsAutoStartRequested'));
     assert.equal(liveStartCalls.length, 0, 'WebSocket live path must not call DotNet live-start fallback');
     await wait(320);
@@ -1373,10 +1409,12 @@ try {
             && message.type === 'subscribe'
             && message.nodeId === 'remote-device-render-smoke'
             && message.autoStartLive === true
-            && message.fps === 20
+            && message.fps === 30
+            && message.mode === 'mode3-h264-hw'
+            && message.streamPurpose === 'control'
             && Array.isArray(message.deviceIds)
             && message.deviceIds.includes(focusedDevice.DeviceId));
-    assert.ok(deviceControlSubscribe, 'RemoteFleetDevice node should subscribe to 20fps binary frames');
+    assert.ok(deviceControlSubscribe, 'RemoteFleetDevice node should subscribe to 30fps Mode 3 control frames');
     const deviceControlWs = diagnostics.webSocketConnections
         .filter(ws => ws.url.includes('/api/remote/frames/ws'))
         .at(-1);

package/scripts/remote-hub-smoke.mjs

@@ -22,6 +22,13 @@ function wait(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+const defaultHub = createRemoteHub({
+    env: {
+        MINDEXEC_REMOTE_HUB: '0'
+    }
+});
+assert.equal(defaultHub.getStatus().port, 5198, 'MindExecution RemoteHub must not reuse the LiveDesk 5197 port');
+
 async function waitFor(predicate, timeoutMs = 3000) {
     const startedAt = Date.now();
     while (Date.now() - startedAt < timeoutMs) {

package/server.js

@@ -4354,7 +4354,7 @@ function appendRemoteAgentOutput(stream, chunk, stateConnectionKey = '') {
     const text = chunk.toString();
     const key = stream === 'stderr' ? 'stderrTail' : 'stdoutTail';
     remoteAgentState[key] = String((remoteAgentState[key] || '') + text).slice(-REMOTE_AGENT_STDIO_TAIL_CHARS);
-    if (/Connected to RemoteHub/i.test(text)) {
+    if (/Connected to (?:RemoteHub|LiveDesk Hub)/i.test(text)) {
         remoteAgentState.ready = true;
         remoteAgentState.connectedAt = new Date().toISOString();
         remoteAgentState.needsReconnect = false;
@@ -5222,7 +5222,7 @@ function appendRemoteAgentAttemptOutput(attempt, stream, chunk) {
     const text = chunk.toString();
     const key = stream === 'stderr' ? 'stderrTail' : 'stdoutTail';
     attempt.state[key] = String((attempt.state[key] || '') + text).slice(-REMOTE_AGENT_STDIO_TAIL_CHARS);
-    if (/Connected to RemoteHub/i.test(text)) {
+    if (/Connected to (?:RemoteHub|LiveDesk Hub)/i.test(text)) {
         attempt.state.ready = true;
         attempt.state.connectedAt = new Date().toISOString();
         attempt.state.needsReconnect = false;

package/wwwroot/_content/MindExecution.Shared/js/background-themes.js

@@ -302,10 +302,8 @@
         themeGroup.userData.localSnapGridStyle = options.localSnapGridStyle || 'line';
         themeGroup.userData.localSnapGridRadiusPx = 500;
         themeGroup.userData.themeAlias = options.themeAlias || 'LocalSnapGrid';
+        themeGroup.userData.localSnapGridBackgroundColor = options.backgroundColor;
         themeGroup.animate = () => { };
-        if (scene && options.backgroundColor !== undefined) {
-            scene.background = new THREE.Color(options.backgroundColor);
-        }
         return setThemeAnimationMode(themeGroup, THEME_ANIMATION_MODE.None);
     }