@mindexec/cli 0.2.141 → 0.2.143

package/package.json

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

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

@@ -442,6 +442,7 @@ async function loadCss3DManager() {
             this.readyState = MiniWebSocket.CONNECTING;
             this.binaryType = '';
             this.sent = [];
+            this.closeCount = 0;
             webSocketConnections.push(this);
             setTimeout(() => {
                 if (this.readyState !== MiniWebSocket.CONNECTING) return;
@@ -458,6 +459,7 @@ async function loadCss3DManager() {
 
         close() {
             if (this.readyState === MiniWebSocket.CLOSED) return;
+            this.closeCount += 1;
             this.readyState = MiniWebSocket.CLOSED;
             this.onclose?.({ type: 'close' });
         }
@@ -490,6 +492,8 @@ async function loadCss3DManager() {
         Set,
         WeakMap,
         Blob,
+        TextDecoder,
+        TextEncoder,
         requestAnimationFrame: callback => setTimeout(() => callback(Date.now()), 0),
         cancelAnimationFrame: id => clearTimeout(id),
         createImageBitmap: async blob => {
@@ -546,6 +550,18 @@ function wait(ms = 0) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+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);
+    const buffer = new ArrayBuffer(4 + metaBytes.byteLength + payloadBytes.byteLength);
+    const view = new DataView(buffer);
+    view.setUint32(0, metaBytes.byteLength);
+    const bytes = new Uint8Array(buffer);
+    bytes.set(metaBytes, 4);
+    bytes.set(payloadBytes, 4 + metaBytes.byteLength);
+    return buffer;
+}
+
 function buildMonitorNode(devices, hubStatus, latestTaskBatch = null, recentTaskBatches = [], lastError = '') {
     const connected = devices.filter(device => device.Connected).length;
     const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5197';
@@ -935,6 +951,52 @@ try {
         binaryDrawCalls.some(call => call.op === 'clearRect' || call.op === 'fillRect'),
         false,
         'binary Blob frame paint must not clear/fill the canvas before drawing');
+
+    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 wsCountBeforeRerender = diagnostics.webSocketConnections.length;
+    const wsCloseCountBeforeRerender = liveWs.closeCount;
+    const websocketFrameSeq = 10001;
+    liveWs.onmessage?.({
+        data: new Blob([encodeRemoteBinaryFrame({
+            type: 'remote.frame.binary',
+            deviceId: patchTarget.DeviceId,
+            kind: 'live',
+            frameSeq: websocketFrameSeq,
+            streamId: 'render-smoke-ws-live',
+            contentHash: `render-smoke-ws-live-${websocketFrameSeq}`,
+            mimeType: 'image/jpeg',
+            width: 64,
+            height: 36,
+            capturedAt: new Date().toISOString(),
+            receivedAt: new Date().toISOString()
+        })])
+    });
+    await wait(30);
+    assert.equal(
+        patchPreview.dataset.remoteFleetFrameSeq,
+        String(websocketFrameSeq),
+        JSON.stringify(diagnostics.runtimeTrace.slice(-12)));
+
+    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');
+    assert.equal(
+        diagnostics.webSocketConnections.length,
+        wsCountBeforeRerender,
+        'MDM rerender must reuse the active binary frame WebSocket instead of opening a replacement');
+    const rerenderedPatchPreview = bodyView
+        .querySelector(`article[data-device-id="${patchTarget.DeviceId}"]`)
+        ?.querySelector('[data-remote-fleet-device-preview="tile"]');
+    assert.ok(rerenderedPatchPreview);
+    assert.equal(rerenderedPatchPreview.dataset.remoteFleetFrameSeq, String(websocketFrameSeq));
+    assert.equal(rerenderedPatchPreview.querySelector('canvas[data-remote-fleet-frame-canvas="true"]')?.style.display, 'block');
+
     const alternateDevice = devices.find(device =>
         device.Connected === true
         && device.DeviceId !== focusedDevice.DeviceId);

package/scripts/remote-registry-follower-smoke.mjs

@@ -317,6 +317,20 @@ async function waitForManagedAgent(bridge, managerEndpoint, label, timeoutMs = 2
     }, timeoutMs, `${label} managed agent\n${bridge.details()}`);
 }
 
+async function waitForManagedAgentRestart(bridge, managerEndpoint, previousPid, label, timeoutMs = 20000) {
+    return await waitFor(async () => {
+        const result = await fetchJson(`${bridge.baseUrl}/api/remote/agent/status`);
+        const agent = result.payload;
+        return agent?.running === true
+            && agent?.ready === true
+            && String(agent.manager || '') === managerEndpoint
+            && Number(agent.pid || 0) > 0
+            && Number(agent.pid || 0) !== Number(previousPid || 0)
+            ? agent
+            : null;
+    }, timeoutMs, `${label} managed agent restart\n${bridge.details()}`);
+}
+
 async function waitForConnectedDevice(bridge, label) {
     return await waitFor(async () => {
         const result = await fetchJson(`${bridge.baseUrl}/api/remote/devices`);
@@ -324,6 +338,18 @@ async function waitForConnectedDevice(bridge, label) {
     }, 12000, `${label} connected device\n${bridge.details()}`);
 }
 
+function killProcess(pid) {
+    const value = Number(pid || 0);
+    assert.ok(value > 0, `expected positive pid, got ${pid}`);
+    try {
+        process.kill(value, 'SIGTERM');
+    } catch (error) {
+        if (error?.code !== 'ESRCH') {
+            throw error;
+        }
+    }
+}
+
 async function main() {
     const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'mindexec-remote-registry-smoke-'));
     let fakeSupabase = null;
@@ -407,6 +433,14 @@ async function main() {
         assert.equal(secondAgent.leaseId, 'lease-b');
         await waitForConnectedDevice(hostB, 'host-b');
 
+        const secondPid = Number(secondAgent.pid || 0);
+        killProcess(secondPid);
+        const restartedAgent = await waitForManagedAgentRestart(client, hostBEndpoint, secondPid, 'host-b', 12000);
+        assert.equal(restartedAgent.usingNpx, false, JSON.stringify(restartedAgent));
+        assert.match(String(restartedAgent.launcher || ''), /mindexec-remote-fast/i);
+        assert.equal(restartedAgent.leaseId, 'lease-b');
+        await waitForConnectedDevice(hostB, 'host-b after restart');
+
         currentTarget = {
             ...currentTarget,
             active: false,

package/server.js

@@ -3151,6 +3151,7 @@ let remoteAgentSyncReportState = null;
 let remoteAgentSyncReportLogKey = '';
 let remoteAgentSyncReportLogAt = 0;
 let remoteAgentConnectPromise = null;
+const remoteAgentIntentionalStopKeys = new Set();
 const remoteAgentRecentSuccessfulManagers = new Map();
 let remoteAgentRecentSuccessfulManagersLoaded = false;
 let remoteAgentRecentSuccessfulManagersSavePromise = null;
@@ -3656,6 +3657,36 @@ function isRemoteAgentRegistryOwned() {
         && /registry/i.test(String(remoteAgentState.source || ''));
 }
 
+function isRemoteAgentRegistryState(state) {
+    return /registry/i.test(String(state?.source || ''));
+}
+
+function suppressRemoteAgentAutoRetry(connectionKey) {
+    const key = safeRemoteAgentField(connectionKey, 128);
+    if (!key) {
+        return;
+    }
+
+    remoteAgentIntentionalStopKeys.add(key);
+    const timer = setTimeout(() => {
+        remoteAgentIntentionalStopKeys.delete(key);
+    }, 10000);
+    timer?.unref?.();
+}
+
+function maybeRetryRemoteAgentAfterExit(state, reason = 'agent-exited') {
+    if (!state
+        || !REMOTE_REGISTRY_FOLLOWER_ENABLED
+        || isShuttingDown
+        || !isRemoteAgentRegistryState(state)
+        || remoteAgentIntentionalStopKeys.has(String(state.connectionKey || ''))) {
+        return;
+    }
+
+    logWarn('remote', `managed RemoteAgent registry process ended; waking registry follower ${formatKeyValue('reason', reason)} ${formatKeyValue('manager', state.manager || '-')}`);
+    scheduleRemoteRegistryFollower(0, reason);
+}
+
 function isLocalRemoteHostTargetActive() {
     const status = remoteHub.getStatus({ includeSecrets: false });
     return status?.hostTargetActive === true
@@ -3912,6 +3943,7 @@ function resolveNpxCliLauncher() {
 
 async function stopRemoteAgentConnection(reason = 'stopped') {
     const previous = remoteAgentState;
+    suppressRemoteAgentAutoRetry(previous.connectionKey);
     if (previous.proc) {
         try {
             await terminateProcessTree(previous.proc);
@@ -4143,6 +4175,17 @@ function createRemoteAgentAttempt(options = {}) {
                 state.lastError = signal ? `signal:${signal}` : `exit:${code}`;
             }
             attempt.error = attempt.error || state.lastError || `exit:${code ?? 'unknown'}`;
+            if (remoteAgentState === state
+                && remoteAgentState.connectionKey === state.connectionKey) {
+                const serialized = serializeRemoteAgentState();
+                if (state.status === 'failed') {
+                    logWarn('remote', `managed RemoteAgent failed: ${formatRemoteAgentFailureSummary(state)}`);
+                } else {
+                    logEvent('remote', `managed RemoteAgent exited ${formatKeyValue('code', code ?? 0)}`, 'remote');
+                }
+                emitBridgeEvent(state.status === 'exited' ? 'RemoteAgentExited' : 'RemoteAgentFailed', serialized);
+                maybeRetryRemoteAgentAfterExit(state, state.status === 'exited' ? 'agent-exited' : 'agent-failed');
+            }
         });
     } catch (err) {
         attempt.failed = true;

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

@@ -13459,13 +13459,15 @@
     const REMOTE_FLEET_FRAME_CANVAS_MAX_DPR = 2;
     const REMOTE_FLEET_FRAME_BLOB_CACHE_MS = 10000;
     const REMOTE_FLEET_FRAME_BLOB_CACHE_LIMIT = 96;
-    const REMOTE_FLEET_LIVE_FRAME_DECODE_TIMEOUT_MS = 180;
+    const REMOTE_FLEET_LIVE_FRAME_DECODE_TIMEOUT_MS = 700;
     const REMOTE_FLEET_THUMBNAIL_FRAME_DECODE_TIMEOUT_MS = 1200;
     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;
     const REMOTE_FLEET_BINARY_FRAME_CONNECT_GRACE_MS = 1600;
+    const REMOTE_FLEET_BINARY_FRAME_CACHE_MS = 10000;
+    const REMOTE_FLEET_BINARY_FRAME_CACHE_LIMIT = 240;
     const REMOTE_FLEET_AUTO_LIVE_START_MAX_PARALLEL = 8;
     const REMOTE_FLEET_AUTO_LIVE_START_COOLDOWN_MS = 3000;
     const REMOTE_FLEET_TASK_FOLLOW_INITIAL_MS = 250;
@@ -13639,9 +13641,11 @@
         return nodeState;
     }
 
-    function clearRemoteFleetTimers(bodyView) {
+    function clearRemoteFleetTimers(bodyView, options = {}) {
         if (!bodyView) return;
-        releaseRemoteFleetBinaryFrameSocket(bodyView);
+        if (options.keepBinaryFrameSocket !== true) {
+            releaseRemoteFleetBinaryFrameSocket(bodyView);
+        }
         if (bodyView._remoteFleetLiveRefreshTimer) {
             clearInterval(bodyView._remoteFleetLiveRefreshTimer);
             bodyView._remoteFleetLiveRefreshTimer = null;
@@ -13822,6 +13826,57 @@
             .slice(0, 240);
     }
 
+    function pruneRemoteFleetBinaryFrameCache(session) {
+        if (!session?.latestBinaryFrames) {
+            return;
+        }
+
+        const now = getRemoteFleetFrameNow();
+        for (const [deviceId, entry] of session.latestBinaryFrames) {
+            if (!entry
+                || !entry.frame
+                || now - Number(entry.seenAt || 0) > REMOTE_FLEET_BINARY_FRAME_CACHE_MS
+                || session.latestBinaryFrames.size > REMOTE_FLEET_BINARY_FRAME_CACHE_LIMIT) {
+                session.latestBinaryFrames.delete(deviceId);
+            }
+        }
+    }
+
+    function rememberRemoteFleetBinaryFrame(session, frame) {
+        const deviceId = String(frame?.deviceId || '').trim();
+        if (!session || !deviceId || !frame?._remoteFleetPayloadBlob) {
+            return;
+        }
+
+        if (!(session.latestBinaryFrames instanceof Map)) {
+            session.latestBinaryFrames = new Map();
+        }
+
+        pruneRemoteFleetBinaryFrameCache(session);
+        session.latestBinaryFrames.set(deviceId, {
+            seenAt: getRemoteFleetFrameNow(),
+            frame: cloneRemoteFleetFramePatch(frame)
+        });
+    }
+
+    function applyRemoteFleetBinaryFrameCacheToBody(bodyView, session) {
+        if (!bodyView || !(session?.latestBinaryFrames instanceof Map) || session.latestBinaryFrames.size === 0) {
+            return 0;
+        }
+
+        pruneRemoteFleetBinaryFrameCache(session);
+        const patches = [];
+        for (const entry of session.latestBinaryFrames.values()) {
+            if (entry?.frame) {
+                patches.push(cloneRemoteFleetFramePatch(entry.frame));
+            }
+        }
+
+        return patches.length > 0
+            ? applyRemoteFleetFramePatches(bodyView, patches)
+            : 0;
+    }
+
     function refreshRemoteFleetBinaryFrameSubscription(session, force = false) {
         if (!session?.ws || session.ws.readyState !== WebSocket.OPEN) {
             return false;
@@ -13877,7 +13932,11 @@
             refreshRemoteFleetBinaryFrameSubscription(session);
             return true;
         }
+        if (session.wsOpening === true) {
+            return true;
+        }
 
+        session.wsOpening = true;
         try {
             const status = await getRemoteFleetBridgeStatusForFrames();
             const wsUrl = buildRemoteFleetBinaryFrameWsUrl(status);
@@ -13891,6 +13950,7 @@
             session.subscriptionKey = '';
             ws.binaryType = 'arraybuffer';
             ws.onopen = () => {
+                session.wsOpening = false;
                 session.wsOpenedAt = getRemoteFleetFrameNow();
                 window.RuntimeTrace?.emit?.('remote.frame.wsOpen', { nodeId: session.nodeId });
                 refreshRemoteFleetBinaryFrameSubscription(session, true);
@@ -13922,6 +13982,7 @@
                         let applied = 0;
                         const frameAt = getRemoteFleetFrameNow();
                         session.lastBinaryFrameAt = frameAt;
+                        rememberRemoteFleetBinaryFrame(session, frame);
                         session.bodies.forEach(body => {
                             if (document.body.contains(body)) {
                                 const bodyApplied = applyRemoteFleetFramePatches(body, [frame]);
@@ -13975,6 +14036,7 @@
                     });
             };
             ws.onclose = () => {
+                session.wsOpening = false;
                 if (session.ws === ws) {
                     session.ws = null;
                 }
@@ -13990,6 +14052,7 @@
             };
             return true;
         } catch (error) {
+            session.wsOpening = false;
             window.RuntimeTrace?.emit?.('remote.frame.wsOpenFailed', {
                 nodeId: session.nodeId,
                 error: error?.message || String(error || '')
@@ -14014,6 +14077,7 @@
                 reconnectTimer: null,
                 subscriptionTimer: null,
                 subscriptionKey: '',
+                latestBinaryFrames: new Map(),
                 controlSessions: new Set(),
                 getDeviceIds: null
             };
@@ -14031,6 +14095,7 @@
             mode: String(options.mode || 'remote-fast')
         };
         bodyView._remoteFleetBinaryFrameSession = session;
+        applyRemoteFleetBinaryFrameCacheToBody(bodyView, session);
         openRemoteFleetBinaryFrameSocket(session).catch(() => undefined);
         return true;
     }
@@ -16043,7 +16108,7 @@
 
     function renderRemoteFleetDevice(bodyView, nodeModel) {
         if (!bodyView) return;
-        clearRemoteFleetTimers(bodyView);
+        clearRemoteFleetTimers(bodyView, { keepBinaryFrameSocket: true });
 
         const nodeId = String(nodeModel?.id ?? nodeModel?.Id ?? '');
         const device = parseRemoteFleetPinnedDevice(nodeModel);
@@ -16541,7 +16606,7 @@
 
     function renderRemoteFleetMonitor(bodyView, nodeModel) {
         if (!bodyView) return;
-        clearRemoteFleetTimers(bodyView);
+        clearRemoteFleetTimers(bodyView, { keepBinaryFrameSocket: true });
 
         const nodeId = String(nodeModel?.id ?? nodeModel?.Id ?? '');
         const searchState = bodyView.dataset.remoteFleetSearch || '';
@@ -18038,11 +18103,14 @@
                     clearRemoteFleetTimers(bodyView);
                 }
             }, REMOTE_FLEET_LIVE_REFRESH_MS);
-        } else if (autoMonitorState && hasMonitorTargets) {
-            startRemoteFleetFrameLoop(bodyView, REMOTE_FLEET_THUMBNAIL_FRAME_REFRESH_MS, () => refreshRemoteFleetVisibleFrames(true));
-            startRemoteFleetMonitorRefreshTimer(REMOTE_FLEET_MONITOR_REFRESH_MS, 'visible-devices');
-        } else if (autoMonitorState) {
-            startRemoteFleetMonitorRefreshTimer(REMOTE_FLEET_EMPTY_MONITOR_REFRESH_MS, 'empty-discovery');
+        } else {
+            releaseRemoteFleetBinaryFrameSocket(bodyView);
+            if (autoMonitorState && hasMonitorTargets) {
+                startRemoteFleetFrameLoop(bodyView, REMOTE_FLEET_THUMBNAIL_FRAME_REFRESH_MS, () => refreshRemoteFleetVisibleFrames(true));
+                startRemoteFleetMonitorRefreshTimer(REMOTE_FLEET_MONITOR_REFRESH_MS, 'visible-devices');
+            } else if (autoMonitorState) {
+                startRemoteFleetMonitorRefreshTimer(REMOTE_FLEET_EMPTY_MONITOR_REFRESH_MS, 'empty-discovery');
+            }
         }
     }
 

package/wwwroot/service-worker-assets.js

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

package/wwwroot/service-worker.js

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