@mindexec/cli 0.2.151 → 0.2.153

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

@@ -13494,6 +13494,8 @@
     const REMOTE_FLEET_LIVE_FRAME_REFRESH_MS = Math.round(1000 / REMOTE_FLEET_MONITOR_LIVE_FPS);
     const REMOTE_FLEET_CONTROL_LIVE_FPS = 20;
     const REMOTE_FLEET_CONTROL_FRAME_REFRESH_MS = Math.round(1000 / REMOTE_FLEET_CONTROL_LIVE_FPS);
+    const REMOTE_FLEET_CONTROL_INPUT_MOVE_MS = 16;
+    const REMOTE_FLEET_CONTROL_INPUT_QUEUE_LIMIT = 64;
     const REMOTE_FLEET_THUMBNAIL_FRAME_REFRESH_MS = 2000;
     const REMOTE_FLEET_FRAME_CANVAS_MAX_DPR = 2;
     const REMOTE_FLEET_FRAME_BLOB_CACHE_MS = 10000;
@@ -13829,6 +13831,22 @@
         return url.toString();
     }
 
+    function buildRemoteFleetInputWsUrl(status) {
+        const baseUrl = String(status?.__remoteFleetBridgeBaseUrl || window.location?.origin || '').trim();
+        const path = String(status?.remoteInputWsPath || '/api/remote/input/ws').trim() || '/api/remote/input/ws';
+        if (!baseUrl) {
+            return '';
+        }
+
+        const url = new URL(path, baseUrl);
+        url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+        const bridgeToken = String(status?.bridgeToken || '').trim();
+        if (bridgeToken) {
+            url.searchParams.set('token', bridgeToken);
+        }
+        return url.toString();
+    }
+
     async function parseRemoteFleetBinaryFrameMessage(data) {
         let buffer = null;
         if (data instanceof ArrayBuffer) {
@@ -15729,6 +15747,8 @@
         activeRemoteFleetControlPopup = null;
         session.active = false;
         detachRemoteFleetControlBinaryFrameSession(session);
+        closeRemoteFleetControlInputSocket(session, 'close');
+        session.inputCleanup?.();
         if (session.timer) {
             clearTimeout(session.timer);
             session.timer = null;
@@ -15910,34 +15930,268 @@
         }
     }
 
-    function sendRemoteFleetControlInput(session, payload, throttleMove = false) {
-        if (!session?.active || !payload?.type) {
+    function closeRemoteFleetControlInputSocket(session, reason = 'close') {
+        if (!session) {
             return;
         }
 
-        const send = next => {
-            if (!session.active) {
-                return;
+        if (session.inputWsOpenTimer) {
+            clearTimeout(session.inputWsOpenTimer);
+            session.inputWsOpenTimer = null;
+        }
+
+        const ws = session.inputWs;
+        session.inputWs = null;
+        session.inputWsConnecting = false;
+        if (ws && ws.readyState !== 3) {
+            try {
+                ws.close();
+            } catch {
+                // Best-effort input socket cleanup.
             }
-            invokeDotNetAsync('SendRemoteFleetInputFromJs', session.nodeId, session.deviceId, {
-                ...next,
-                controlLeaseId: session.controlLeaseId,
-                issuedAt: new Date().toISOString()
-            }).catch(error => {
+        }
+
+        if (reason === 'close') {
+            session.inputQueue = [];
+        }
+    }
+
+    function createRemoteFleetControlInput(session, payload) {
+        return {
+            ...payload,
+            controlLeaseId: session.controlLeaseId,
+            issuedAt: new Date().toISOString()
+        };
+    }
+
+    function sendRemoteFleetControlInputFallback(session, input) {
+        if (!session?.active || !input?.type) {
+            return;
+        }
+
+        invokeDotNetAsync('SendRemoteFleetInputFromJs', session.nodeId, session.deviceId, {
+            ...input,
+            controlLeaseId: input.controlLeaseId || session.controlLeaseId,
+            issuedAt: input.issuedAt || new Date().toISOString()
+        }).catch(error => {
+            if (session.active) {
                 session.status.textContent = error?.message || 'Input failed';
+            }
+        });
+    }
+
+    function drainRemoteFleetControlInputQueueToFallback(session) {
+        if (!session?.inputQueue?.length) {
+            return;
+        }
+
+        const queued = session.inputQueue.splice(0);
+        queued.forEach(envelope => sendRemoteFleetControlInputFallback(session, envelope.input));
+    }
+
+    function enqueueRemoteFleetControlInput(session, envelope) {
+        if (!session) {
+            return;
+        }
+
+        if (!Array.isArray(session.inputQueue)) {
+            session.inputQueue = [];
+        }
+
+        const inputType = String(envelope?.input?.type || '').toLowerCase();
+        if (inputType === 'pointermove') {
+            for (let i = session.inputQueue.length - 1; i >= 0; i -= 1) {
+                if (String(session.inputQueue[i]?.input?.type || '').toLowerCase() === 'pointermove') {
+                    session.inputQueue.splice(i, 1);
+                }
+            }
+        }
+
+        session.inputQueue.push(envelope);
+        while (session.inputQueue.length > REMOTE_FLEET_CONTROL_INPUT_QUEUE_LIMIT) {
+            const moveIndex = session.inputQueue.findIndex(item =>
+                String(item?.input?.type || '').toLowerCase() === 'pointermove');
+            session.inputQueue.splice(moveIndex >= 0 ? moveIndex : 0, 1);
+        }
+    }
+
+    function flushRemoteFleetControlInputQueue(session) {
+        const ws = session?.inputWs;
+        if (!session?.active || !ws || ws.readyState !== 1 || !session.inputQueue?.length) {
+            return;
+        }
+
+        const queued = session.inputQueue.splice(0);
+        for (const envelope of queued) {
+            if (!sendRemoteFleetControlInputEnvelope(session, envelope)) {
+                enqueueRemoteFleetControlInput(session, envelope);
+                break;
+            }
+        }
+    }
+
+    function sendRemoteFleetControlInputEnvelope(session, envelope) {
+        const ws = session?.inputWs;
+        if (!session?.active || !ws || ws.readyState !== 1) {
+            return false;
+        }
+
+        const inputType = String(envelope?.input?.type || '').toLowerCase();
+        if (inputType === 'pointermove' && Number(ws.bufferedAmount || 0) > 256 * 1024) {
+            window.RuntimeTrace?.emit?.('remote.control.input.drop', {
+                reason: 'ws-buffered',
+                deviceId: session.deviceId,
+                bufferedAmount: Number(ws.bufferedAmount || 0)
             });
+            return true;
+        }
+
+        try {
+            ws.send(JSON.stringify(envelope));
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    function handleRemoteFleetControlInputSocketFailure(session) {
+        if (!session?.active) {
+            return;
+        }
+
+        closeRemoteFleetControlInputSocket(session, 'failed');
+        session.inputWsUnavailableUntil = Date.now() + 1000;
+        drainRemoteFleetControlInputQueueToFallback(session);
+    }
+
+    function ensureRemoteFleetControlInputSocket(session) {
+        if (!session?.active || typeof WebSocket !== 'function') {
+            return false;
+        }
+
+        const ws = session.inputWs;
+        if (ws && (ws.readyState === 0 || ws.readyState === 1)) {
+            return true;
+        }
+
+        if (session.inputWsConnecting === true) {
+            return true;
+        }
+
+        if ((session.inputWsUnavailableUntil || 0) > Date.now()) {
+            return false;
+        }
+
+        const connectToken = `input-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+        session.inputWsConnecting = true;
+        session.inputWsConnectToken = connectToken;
+        getRemoteFleetBridgeStatusForFrames()
+            .then(status => {
+                if (!session.active || session.inputWsConnectToken !== connectToken) {
+                    return;
+                }
+
+                const wsUrl = buildRemoteFleetInputWsUrl(status);
+                if (!wsUrl) {
+                    throw new Error('input-ws-url-unavailable');
+                }
+
+                const inputWs = new WebSocket(wsUrl);
+                session.inputWs = inputWs;
+                inputWs.onopen = () => {
+                    if (!session.active || session.inputWs !== inputWs) {
+                        return;
+                    }
+
+                    session.inputWsConnecting = false;
+                    session.inputWsUnavailableUntil = 0;
+                    if (session.inputWsOpenTimer) {
+                        clearTimeout(session.inputWsOpenTimer);
+                        session.inputWsOpenTimer = null;
+                    }
+                    flushRemoteFleetControlInputQueue(session);
+                };
+                inputWs.onmessage = event => {
+                    try {
+                        const message = JSON.parse(String(event?.data || ''));
+                        if (message?.ok === false && session.active) {
+                            session.status.textContent = message.error || 'Input failed';
+                        }
+                    } catch {
+                        // Ignore input ack parse errors.
+                    }
+                };
+                inputWs.onerror = () => {
+                    if (session.inputWs === inputWs) {
+                        handleRemoteFleetControlInputSocketFailure(session);
+                    }
+                };
+                inputWs.onclose = () => {
+                    if (session.inputWs === inputWs) {
+                        handleRemoteFleetControlInputSocketFailure(session);
+                    }
+                };
+                session.inputWsOpenTimer = setTimeout(() => {
+                    if (session.active && session.inputWs === inputWs && inputWs.readyState === 0) {
+                        handleRemoteFleetControlInputSocketFailure(session);
+                    }
+                }, 900);
+            })
+            .catch(() => {
+                if (!session.active || session.inputWsConnectToken !== connectToken) {
+                    return;
+                }
+
+                session.inputWsConnecting = false;
+                session.inputWsUnavailableUntil = Date.now() + 1000;
+                drainRemoteFleetControlInputQueueToFallback(session);
+            });
+
+        return true;
+    }
+
+    function sendRemoteFleetControlInputNow(session, payload) {
+        if (!session?.active || !payload?.type) {
+            return;
+        }
+
+        const input = createRemoteFleetControlInput(session, payload);
+        const envelope = {
+            type: 'input',
+            nodeId: session.nodeId,
+            deviceId: session.deviceId,
+            requestId: `input-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+            input
         };
 
+        const wsReady = ensureRemoteFleetControlInputSocket(session);
+        if (wsReady && sendRemoteFleetControlInputEnvelope(session, envelope)) {
+            return;
+        }
+
+        if (wsReady) {
+            enqueueRemoteFleetControlInput(session, envelope);
+            return;
+        }
+
+        sendRemoteFleetControlInputFallback(session, input);
+    }
+
+    function sendRemoteFleetControlInput(session, payload, throttleMove = false) {
+        if (!session?.active || !payload?.type) {
+            return;
+        }
+
         if (!throttleMove) {
-            send(payload);
+            sendRemoteFleetControlInputNow(session, payload);
             return;
         }
 
         const now = performance.now();
         const elapsed = now - (session.lastMoveSentAt || 0);
-        if (elapsed >= 32) {
+        if (elapsed >= REMOTE_FLEET_CONTROL_INPUT_MOVE_MS) {
             session.lastMoveSentAt = now;
-            send(payload);
+            sendRemoteFleetControlInputNow(session, payload);
             return;
         }
 
@@ -15952,9 +16206,9 @@
             session.pendingMove = null;
             if (next) {
                 session.lastMoveSentAt = performance.now();
-                send(next);
+                sendRemoteFleetControlInputNow(session, next);
             }
-        }, Math.max(1, 32 - elapsed));
+        }, Math.max(1, REMOTE_FLEET_CONTROL_INPUT_MOVE_MS - elapsed));
     }
 
     function bindRemoteFleetControlInput(session) {
@@ -15965,6 +16219,40 @@
             overlay.addEventListener(eventName, event => event.stopPropagation(), true);
         });
 
+        const shouldIgnoreKeyboardEvent = event =>
+            event?.target?.closest?.('[data-remote-fleet-control-close="true"]');
+
+        const handleKeyboardEvent = (event, type) => {
+            if (!session.active || shouldIgnoreKeyboardEvent(event) || event.__remoteFleetControlHandled === true) {
+                return;
+            }
+
+            event.__remoteFleetControlHandled = true;
+            event.preventDefault();
+            event.stopPropagation();
+            shell.focus({ preventScroll: true });
+            sendRemoteFleetControlInput(session, {
+                type,
+                key: event.key,
+                code: event.code,
+                repeat: event.repeat === true
+            });
+        };
+
+        const handleWindowKeyDown = event => handleKeyboardEvent(event, 'keyDown');
+        const handleWindowKeyUp = event => handleKeyboardEvent(event, 'keyUp');
+        if (typeof window.addEventListener === 'function') {
+            window.addEventListener('keydown', handleWindowKeyDown, true);
+            window.addEventListener('keyup', handleWindowKeyUp, true);
+        }
+        session.inputCleanup = () => {
+            if (typeof window.removeEventListener === 'function') {
+                window.removeEventListener('keydown', handleWindowKeyDown, true);
+                window.removeEventListener('keyup', handleWindowKeyUp, true);
+            }
+            session.inputCleanup = null;
+        };
+
         stage.addEventListener('pointerdown', event => {
             const point = getRemoteFleetControlPoint(event, canvas, false);
             if (!point) {
@@ -16041,35 +16329,8 @@
             event.stopPropagation();
         });
 
-        shell.addEventListener('keydown', event => {
-            if (event.target?.closest?.('[data-remote-fleet-control-close="true"]')) {
-                return;
-            }
-
-            event.preventDefault();
-            event.stopPropagation();
-            sendRemoteFleetControlInput(session, {
-                type: 'keyDown',
-                key: event.key,
-                code: event.code,
-                repeat: event.repeat === true
-            });
-        });
-
-        shell.addEventListener('keyup', event => {
-            if (event.target?.closest?.('[data-remote-fleet-control-close="true"]')) {
-                return;
-            }
-
-            event.preventDefault();
-            event.stopPropagation();
-            sendRemoteFleetControlInput(session, {
-                type: 'keyUp',
-                key: event.key,
-                code: event.code,
-                repeat: event.repeat === true
-            });
-        });
+        shell.addEventListener('keydown', event => handleKeyboardEvent(event, 'keyDown'));
+        shell.addEventListener('keyup', event => handleKeyboardEvent(event, 'keyUp'));
     }
 
     function openRemoteFleetControlPopup(bodyView, nodeModel, deviceId) {
@@ -16233,10 +16494,18 @@
             lastMoveSentAt: 0,
             lastControlFrameAt: 0,
             lastControlFrameSeq: 0,
-            binaryFramePreferred: false
+            binaryFramePreferred: false,
+            inputWs: null,
+            inputWsConnecting: false,
+            inputWsConnectToken: '',
+            inputWsOpenTimer: null,
+            inputWsUnavailableUntil: 0,
+            inputQueue: [],
+            inputCleanup: null
         };
         activeRemoteFleetControlPopup = session;
         bindRemoteFleetControlInput(session);
+        ensureRemoteFleetControlInputSocket(session);
         attachRemoteFleetControlBinaryFrameSession(session, bodyView);
 
         const refresh = async () => {

package/wwwroot/service-worker-assets.js

@@ -1,5 +1,5 @@
 self.assetsManifest = {
-    "version":  "20SB8UIp",
+    "version":  "uSz5Xt0z",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -86,7 +86,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js.backup"
                    },
                    {
-                       "hash":  "sha256-CXwos9ge49EzJij/kELHzhWSDGBSR3fbqqW7hBxARCI=",
+                       "hash":  "sha256-4BdT/RnBOnh3Mm/hTZilg3zo9az6W9oYf8h3br2aDko=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-css3d-manager.js"
                    },
                    {

package/wwwroot/service-worker.js

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