@mindexec/cli 0.2.138 → 0.2.140

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.138",
+  "version": "0.2.140",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",

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

@@ -419,6 +419,10 @@ async function loadCss3DManager() {
     const objectUrlCalls = [];
     const revokedObjectUrls = [];
     const imageBitmapCalls = [];
+    const fetchCalls = [];
+    const runtimeTrace = [];
+    const webSocketConnections = [];
+    const webSocketSends = [];
     class SmokeURL extends URL {}
     SmokeURL.createObjectURL = blob => {
         objectUrlCalls.push(blob);
@@ -427,9 +431,43 @@ async function loadCss3DManager() {
     SmokeURL.revokeObjectURL = value => {
         revokedObjectUrls.push(String(value || ''));
     };
+    class MiniWebSocket {
+        static CONNECTING = 0;
+        static OPEN = 1;
+        static CLOSING = 2;
+        static CLOSED = 3;
+
+        constructor(url) {
+            this.url = String(url || '');
+            this.readyState = MiniWebSocket.CONNECTING;
+            this.binaryType = '';
+            this.sent = [];
+            webSocketConnections.push(this);
+            setTimeout(() => {
+                if (this.readyState !== MiniWebSocket.CONNECTING) return;
+                this.readyState = MiniWebSocket.OPEN;
+                this.onopen?.({ type: 'open' });
+            }, 0);
+        }
+
+        send(payload) {
+            const text = typeof payload === 'string' ? payload : String(payload || '');
+            this.sent.push(text);
+            webSocketSends.push({ url: this.url, payload: text });
+        }
+
+        close() {
+            if (this.readyState === MiniWebSocket.CLOSED) return;
+            this.readyState = MiniWebSocket.CLOSED;
+            this.onclose?.({ type: 'close' });
+        }
+    }
     const context = {
         console,
         document,
+        location: {
+            origin: 'http://localhost:5147'
+        },
         navigator: {
             clipboard: {
                 writeText: async () => {}
@@ -466,6 +504,23 @@ async function loadCss3DManager() {
         },
         THREE: createThreeStub(),
         URL: SmokeURL,
+        WebSocket: MiniWebSocket,
+        fetch: async (url, options = {}) => {
+            fetchCalls.push({ url: String(url || ''), options });
+            return {
+                ok: true,
+                status: 200,
+                json: async () => ({
+                    bridgeToken: 'render-smoke-bridge-token',
+                    remoteFrameWsPath: '/api/remote/frames/ws'
+                })
+            };
+        },
+        RuntimeTrace: {
+            emit(type, data = {}) {
+                runtimeTrace.push({ type, ...data });
+            }
+        },
         Promise
     };
     context.window = context;
@@ -478,7 +533,11 @@ async function loadCss3DManager() {
         diagnostics: {
             objectUrlCalls,
             revokedObjectUrls,
-            imageBitmapCalls
+            imageBitmapCalls,
+            fetchCalls,
+            runtimeTrace,
+            webSocketConnections,
+            webSocketSends
         }
     };
 }
@@ -530,6 +589,7 @@ function buildMonitorNode(devices, hubStatus, latestTaskBatch = null, recentTask
 function createRemoteFleetTemplateShell(document, focusDeviceId = '') {
     const nodeShell = document.createElement('div');
     nodeShell.setAttribute('class', 'map-node-template-card map-node-remote-fleet');
+    nodeShell.dataset.nodeId = 'remote-fleet-render-smoke';
     const shell = document.createElement('div');
     shell.setAttribute('class', 'template-card__shell template-card__shell--remote-fleet');
     const header = document.createElement('div');
@@ -542,7 +602,8 @@ function createRemoteFleetTemplateShell(document, focusDeviceId = '') {
     header.appendChild(icon);
     header.appendChild(titleWrap);
     const bodyView = document.createElement('div');
-    bodyView.setAttribute('class', 'template-card__remote-fleet-body');
+    bodyView.setAttribute('class', 'template-card__remote-fleet-body map-node-remote-fleet__body');
+    bodyView.dataset.nodeId = 'remote-fleet-render-smoke';
     bodyView.dataset.remoteFleetAutoMonitor = 'false';
     if (focusDeviceId) {
         bodyView.dataset.remoteFleetFocusDeviceId = focusDeviceId;
@@ -866,9 +927,14 @@ try {
     assert.equal(binaryImage?.style.display, 'none');
     assert.equal(diagnostics.imageBitmapCalls.length, imageBitmapCountBeforeBinary + 1);
     assert.equal(diagnostics.objectUrlCalls.length, objectUrlCountBeforeBinary);
+    const binaryDrawCalls = document.canvasDrawCalls.slice(drawCountBeforeBinary);
     assert.ok(
-        document.canvasDrawCalls.slice(drawCountBeforeBinary).some(call => call.op === 'drawImage'),
+        binaryDrawCalls.some(call => call.op === 'drawImage'),
         'expected binary Blob frame to draw directly to canvas');
+    assert.equal(
+        binaryDrawCalls.some(call => call.op === 'clearRect' || call.op === 'fillRect'),
+        false,
+        'binary Blob frame paint must not clear/fill the canvas before drawing');
     const alternateDevice = devices.find(device =>
         device.Connected === true
         && device.DeviceId !== focusedDevice.DeviceId);
@@ -934,9 +1000,31 @@ try {
     const resultPanel = bodyView.querySelector('[data-remote-fleet-task-results="true"]');
     assert.equal(resultPanel, null);
     assert.ok(devices.some(device => /^synthetic-response-/.test(device.LatestTaskResultResponseId)));
-    await wait();
+    await wait(20);
     const liveStartCalls = dotNetCalls.filter(call => call.methodName === 'StartRemoteFleetLiveStreamFromJs');
-    assert.ok(liveStartCalls.length > 1, `expected multiple visible live starts, got ${liveStartCalls.length}`);
+    const subscribeMessages = diagnostics.webSocketSends
+        .map(send => {
+            try {
+                return JSON.parse(send.payload);
+            } catch {
+                return null;
+            }
+        })
+        .filter(Boolean);
+    const autoLiveSubscribe = subscribeMessages.find(message =>
+        message.type === 'subscribe'
+        && message.nodeId === 'remote-fleet-render-smoke'
+        && message.autoStartLive === true);
+    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.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);
     assert.ok(dotNetCalls.some(call => call.methodName === 'RefreshRemoteFleetMonitorNodeFromJs'));
     assert.equal(bodyView.dataset.remoteFleetTaskFollowKey, 'render-smoke-batch');

package/wwwroot/_content/MindExecution.Shared/js/mind-map-css3d-manager.js

@@ -13461,7 +13461,7 @@
     const REMOTE_FLEET_FRAME_BLOB_CACHE_LIMIT = 96;
     const REMOTE_FLEET_LIVE_FRAME_DECODE_TIMEOUT_MS = 180;
     const REMOTE_FLEET_THUMBNAIL_FRAME_DECODE_TIMEOUT_MS = 1200;
-    const REMOTE_FLEET_BINARY_FRAME_MAX_DECODE_IN_FLIGHT = 2;
+    const REMOTE_FLEET_BINARY_FRAME_MAX_DECODE_IN_FLIGHT = 1;
     const REMOTE_FLEET_BINARY_FRAME_WS_RECONNECT_MS = 1500;
     const REMOTE_FLEET_BINARY_FRAME_SUBSCRIBE_MS = 1000;
     const REMOTE_FLEET_BINARY_FRAME_STALE_FALLBACK_MS = 1400;
@@ -14269,7 +14269,7 @@
             width: 100%;
             height: 100%;
             display: none;
-            background: #0f172a;
+            background: transparent;
         `;
         if (typeof preview?.insertBefore === 'function') {
             preview.insertBefore(canvas, preview.firstChild || null);
@@ -14361,9 +14361,6 @@
 
         context.imageSmoothingEnabled = true;
         context.imageSmoothingQuality = 'medium';
-        context.fillStyle = '#020617';
-        context.clearRect(0, 0, size.width, size.height);
-        context.fillRect(0, 0, size.width, size.height);
         context.drawImage(bitmap, sx, sy, sw, sh, dx, dy, dw, dh);
         canvas._remoteFleetContentRect = {
             left: dx / size.dpr,
@@ -18000,12 +17997,6 @@
         const hasVisibleLiveTarget = getVisibleLiveFrameDeviceIds().length > 0
             || devices.some(device => isRemoteFleetDeviceConnected(device) && isRemoteFleetLiveCapable(device));
         if (hasVisibleLiveTarget || hasActiveLiveStream) {
-            ensureVisibleRemoteFleetLiveStreams().catch(error => {
-                window.RuntimeTrace?.emit?.('remote.live.autoStartFailed', {
-                    nodeId,
-                    error: error?.message || String(error || '')
-                });
-            });
             const binaryFrameSocketStarted = startRemoteFleetBinaryFrameSocket(bodyView, () => {
                 const liveIds = getVisibleLiveFrameDeviceIds();
                 return liveIds.length > 0 ? liveIds : getVisibleFrameDeviceIds();
@@ -18022,6 +18013,18 @@
                     nodeId,
                     reason: 'binary-frame-socket-not-started'
                 });
+                ensureVisibleRemoteFleetLiveStreams().catch(error => {
+                    window.RuntimeTrace?.emit?.('remote.live.autoStartFailed', {
+                        nodeId,
+                        error: error?.message || String(error || '')
+                    });
+                });
+            } else {
+                window.RuntimeTrace?.emit?.('remote.live.wsAutoStartRequested', {
+                    nodeId,
+                    transport: 'ws-binary',
+                    fps: REMOTE_FLEET_MONITOR_LIVE_FPS
+                });
             }
             bodyView._remoteFleetLiveRefreshTimer = setInterval(async () => {
                 if (!document.body.contains(bodyView)) {

package/wwwroot/service-worker-assets.js

@@ -1,5 +1,5 @@
 self.assetsManifest = {
-    "version":  "IfRQGIi2",
+    "version":  "7WvF4J3m",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -86,7 +86,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js.backup"
                    },
                    {
-                       "hash":  "sha256-WBIjGLmIxv1h8qPdh1KvY1XXHi1slyoTo2BVqXis+hQ=",
+                       "hash":  "sha256-8Ndn0qAzhmRH7/OJtB0ve5LG2oN5e+PaAE7c0MyEzHM=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-css3d-manager.js"
                    },
                    {

package/wwwroot/service-worker.js

@@ -1,4 +1,4 @@
-/* Manifest version: IfRQGIi2 */
+/* Manifest version: 7WvF4J3m */
 // Hosted deployments should prefer the network over stale offline caches.
 // This service worker immediately clears old Blazor offline caches and unregisters itself.