@mindexec/cli 0.2.24 → 0.2.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -20,11 +20,11 @@
   "scripts": {
     "start": "node launch-bridge.cjs",
     "dev": "node launch-bridge.cjs --watch",
-    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs",
-    "test:remote": "node scripts/remote-hub-smoke.mjs",
-    "test:remote:scale": "node scripts/remote-hub-scale-smoke.mjs",
-    "test:remote:render": "node scripts/remote-fleet-render-smoke.mjs",
-    "test:remote:http": "node scripts/remote-http-smoke.mjs",
+    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs",
+    "test:remote": "node scripts/remote-hub-smoke.mjs",
+    "test:remote:scale": "node scripts/remote-hub-scale-smoke.mjs",
+    "test:remote:render": "node scripts/remote-fleet-render-smoke.mjs",
+    "test:remote:http": "node scripts/remote-http-smoke.mjs",
     "pack:dry": "npm pack --dry-run",
     "setup:grammars": "node scripts/setup-tree-sitter-grammars.mjs",
     "postinstall": "npm run setup:grammars"

package/remote-hub.js

@@ -15,6 +15,7 @@ const RECENT_TASK_LIMIT = 12;
 const RECENT_TASK_BATCH_LIMIT = 16;
 const REMOTE_PROTOCOL_VERSION = 1;
 const MAX_SYNTHETIC_DEVICES = 1000;
+const DEFAULT_HOST_TARGET_LEASE_MS = 30000;
 const SYNTHETIC_FRAME_DATA_URL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
 
 function isEnabledValue(value, fallback = true) {
@@ -219,9 +220,129 @@ export function createRemoteHub(options = {}) {
     let started = false;
     let boundPort = requestedPort;
     let lastError = '';
+    let hostTarget = null;
+
+    function getAgentEndpoint() {
+        return `${host}:${boundPort || requestedPort}`;
+    }
+
+    function getActiveHostTarget() {
+        if (!hostTarget) {
+            return null;
+        }
+
+        const expiresMs = Date.parse(hostTarget.expiresAt || '');
+        if (Number.isFinite(expiresMs) && expiresMs <= Date.now()) {
+            const expiredTarget = hostTarget;
+            hostTarget = null;
+            emitRemoteEvent('RemoteHostTargetExpired', null, {
+                hostTarget: {
+                    ...expiredTarget,
+                    active: false
+                }
+            });
+            return null;
+        }
+
+        return hostTarget;
+    }
+
+    function serializeHostTarget(target = getActiveHostTarget()) {
+        if (!target) {
+            return {
+                active: false,
+                nodeId: '',
+                leaseId: '',
+                endpoint: '',
+                activatedAt: '',
+                updatedAt: '',
+                expiresAt: ''
+            };
+        }
+
+        return {
+            active: true,
+            nodeId: target.nodeId,
+            leaseId: target.leaseId,
+            endpoint: target.endpoint,
+            activatedAt: target.activatedAt,
+            updatedAt: target.updatedAt,
+            expiresAt: target.expiresAt
+        };
+    }
+
+    function setHostTarget(options = {}) {
+        const enabled = options.enabled !== false;
+        const nodeId = safeString(options.nodeId, 128);
+        if (!enabled) {
+            const previous = getActiveHostTarget();
+            if (!previous) {
+                return {
+                    ok: true,
+                    active: false,
+                    hostTarget: serializeHostTarget(null)
+                };
+            }
+
+            if (nodeId && previous.nodeId && nodeId !== previous.nodeId) {
+                return {
+                    ok: false,
+                    error: 'host-target-node-mismatch',
+                    active: true,
+                    hostTarget: serializeHostTarget(previous)
+                };
+            }
+
+            hostTarget = null;
+            emitRemoteEvent('RemoteHostTargetCleared', null, {
+                hostTarget: {
+                    ...serializeHostTarget(previous),
+                    active: false
+                }
+            });
+            return {
+                ok: true,
+                active: false,
+                hostTarget: serializeHostTarget(null)
+            };
+        }
+
+        if (!nodeId) {
+            return {
+                ok: false,
+                error: 'missing-node-id',
+                active: false,
+                hostTarget: serializeHostTarget()
+            };
+        }
+
+        const now = new Date();
+        const leaseMs = clampNumber(options.leaseMs, 5000, 10 * 60 * 1000, DEFAULT_HOST_TARGET_LEASE_MS);
+        const previous = getActiveHostTarget();
+        const activeSameNode = previous?.nodeId === nodeId;
+        hostTarget = {
+            nodeId,
+            leaseId: activeSameNode && previous?.leaseId ? previous.leaseId : crypto.randomUUID(),
+            endpoint: getAgentEndpoint(),
+            activatedAt: activeSameNode && previous?.activatedAt ? previous.activatedAt : now.toISOString(),
+            updatedAt: now.toISOString(),
+            expiresAt: new Date(now.getTime() + leaseMs).toISOString()
+        };
+
+        emitRemoteEvent('RemoteHostTargetSet', null, {
+            hostTarget: serializeHostTarget(hostTarget),
+            replacedNodeId: previous && previous.nodeId !== nodeId ? previous.nodeId : ''
+        });
+        return {
+            ok: true,
+            active: true,
+            hostTarget: serializeHostTarget(hostTarget)
+        };
+    }
 
     function getStatus({ includeSecrets = false } = {}) {
         const connectedDevices = [...devices.values()].filter(device => device.connected).length;
+        const activeHostTarget = serializeHostTarget();
         return {
             enabled,
             started,
@@ -234,13 +355,20 @@ export function createRemoteHub(options = {}) {
             managerPackage,
             managerVersion,
             agentPackage: '@mindexec/remote',
-            agentEndpoint: `${host}:${boundPort || requestedPort}`,
+            agentEndpoint: getAgentEndpoint(),
             pairToken: includeSecrets ? pairToken : undefined,
             pairTokenPreview: maskToken(pairToken),
             deviceCount: devices.size,
             connectedDeviceCount: connectedDevices,
             canvasDeviceListMode: 'all-devices',
             canvasPagination: 'none',
+            hostTargetActive: activeHostTarget.active,
+            hostTargetNodeId: activeHostTarget.nodeId,
+            hostTargetLeaseId: activeHostTarget.leaseId,
+            hostTargetEndpoint: activeHostTarget.endpoint,
+            hostTargetActivatedAt: activeHostTarget.activatedAt,
+            hostTargetUpdatedAt: activeHostTarget.updatedAt,
+            hostTargetExpiresAt: activeHostTarget.expiresAt,
             externalExposure: host === '0.0.0.0' || host === '::',
             lastError
         };
@@ -1690,6 +1818,7 @@ export function createRemoteHub(options = {}) {
         sendCommand,
         requestAgentTask,
         requestAgentTaskBatch,
+        setHostTarget,
         requestThumbnail,
         startLiveStream,
         stopLiveStream,

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

@@ -416,6 +416,9 @@ function buildMonitorNode(devices, hubStatus, latestTaskBatch = null, recentTask
     const connected = devices.filter(device => device.Connected).length;
     const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5197';
     const pairToken = hubStatus.pairToken || 'render-smoke-token';
+    const hostTargetState = hubStatus.hostTargetActive
+        ? (hubStatus.hostTargetNodeId === 'remote-fleet-render-smoke' ? 'hosting' : 'other-monitor')
+        : 'inactive';
     return {
         id: 'remote-fleet-render-smoke',
         contentType: 'memo',
@@ -434,6 +437,13 @@ function buildMonitorNode(devices, hubStatus, latestTaskBatch = null, recentTask
             RemoteFleetDeviceCount: String(devices.length),
             RemoteFleetConnectedDeviceCount: String(connected),
             RemoteFleetCanvasPagination: 'none',
+            RemoteFleetHostTargetState: hostTargetState,
+            RemoteFleetHostTargetNodeId: hubStatus.hostTargetNodeId || '',
+            RemoteFleetHostTargetLeaseId: hubStatus.hostTargetLeaseId || '',
+            RemoteFleetHostTargetEndpoint: hubStatus.hostTargetEndpoint || endpoint,
+            RemoteFleetHostTargetActivatedAtUtc: hubStatus.hostTargetActivatedAt || '',
+            RemoteFleetHostTargetUpdatedAtUtc: hubStatus.hostTargetUpdatedAt || '',
+            RemoteFleetHostTargetExpiresAtUtc: hubStatus.hostTargetExpiresAt || '',
             RemoteFleetDevicesJson: JSON.stringify(devices),
             RemoteFleetLatestTaskBatchJson: latestTaskBatch ? JSON.stringify(latestTaskBatch) : '',
             RemoteFleetRecentTaskBatchesJson: JSON.stringify(recentTaskBatches),
@@ -547,7 +557,6 @@ try {
     const rawDevices = hub.listDevices();
     const devices = rawDevices.map(projectDevice);
     const connectedCount = devices.filter(device => device.Connected).length;
-    const offlineCount = devices.length - connectedCount;
     const aiCount = devices.filter(device => device.Connected && device.AiAssistEnabled).length;
     const focusedDevice = devices.find(device => device.Connected && device.LiveStreamActive)
         || devices.find(device => device.Connected);
@@ -645,31 +654,112 @@ try {
                 };
             }
 
+            if (methodName === 'SetRemoteFleetHostFromJs') {
+                return {
+                    success: true,
+                    active: args[1] === true
+                };
+            }
+
             return { success: true };
         }
     };
     manager.setModuleForTest({ dotNetHelper });
 
+    const nodeShell = document.createElement('div');
+    nodeShell.setAttribute('class', 'map-node-remote-fleet map-node-memo');
+    const header = document.createElement('div');
+    header.setAttribute('class', 'map-node-memo__header');
+    const iconWrap = document.createElement('div');
+    iconWrap.setAttribute('class', 'map-node-memo__icon-wrap');
+    const iconButton = document.createElement('button');
+    iconButton.setAttribute('class', 'map-node-memo__icon-button');
+    iconWrap.appendChild(iconButton);
+    const titleWrap = document.createElement('div');
+    titleWrap.setAttribute('class', 'map-node-memo__title-wrap');
+    titleWrap.textContent = 'Remote Fleet Monitor';
+    header.appendChild(iconWrap);
+    header.appendChild(titleWrap);
     const bodyView = document.createElement('div');
     bodyView.dataset.remoteFleetAutoMonitor = 'false';
     bodyView.dataset.remoteFleetFocusDeviceId = focusedDevice.DeviceId;
-    document.body.appendChild(bodyView);
+    nodeShell.appendChild(header);
+    nodeShell.appendChild(bodyView);
+    document.body.appendChild(nodeShell);
 
     manager.renderRemoteFleetMonitorForTest(bodyView, buildMonitorNode(devices, hub.getStatus({ includeSecrets: true }), latestTaskBatch, recentTaskBatches));
 
     let cards = bodyView.querySelectorAll('article[data-device-id]');
     assert.equal(cards.length, SYNTHETIC_COUNT);
-    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${SYNTHETIC_COUNT}/${SYNTHETIC_COUNT}`);
-    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="pin-device"]').length, SYNTHETIC_COUNT);
-    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="task-device"]').length, connectedCount);
-    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="thumbnail-device"]').length, devices.filter(device => device.Connected && device.ThumbnailEnabled).length);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]'), null);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-search="true"]'), null);
+    assert.equal(bodyView.querySelectorAll('select').length, 0);
+    assert.ok(bodyView.querySelector('[data-remote-fleet-device-grid="true"]'));
+    const initialDetailPanel = bodyView.querySelector('[data-remote-fleet-detail-panel="true"]');
+    assert.equal(initialDetailPanel?.dataset.deviceId, focusedDevice.DeviceId);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="pin-device"]').length, 1);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="task-device"]').length, 0);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="thumbnail-device"]').length, focusedDevice.Connected && focusedDevice.ThumbnailEnabled ? 1 : 0);
+    assert.ok(initialDetailPanel?.textContent.includes('Seen'));
+    assert.ok(initialDetailPanel?.textContent.includes('Uptime'));
+    assert.ok(initialDetailPanel?.textContent.includes('Mem'));
+    assert.ok(initialDetailPanel?.textContent.includes('Load'));
+    assert.ok(cards[0]?.querySelector('[data-remote-fleet-device-preview="tile"]'));
+    assert.equal(/\b(Seen|Uptime|Mem|Load)\b/.test(cards[0]?.textContent || ''), false);
+    const alternateDevice = devices.find(device => device.DeviceId !== focusedDevice.DeviceId);
+    assert.ok(alternateDevice);
+    const alternateCard = Array.from(cards).find(card => card.dataset.deviceId === alternateDevice.DeviceId);
+    assert.ok(alternateCard);
+    alternateCard.dispatchEvent({ type: 'click' });
+    assert.equal(bodyView.dataset.remoteFleetSelectedDeviceId, alternateDevice.DeviceId);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-detail-panel="true"]')?.dataset.deviceId, alternateDevice.DeviceId);
     const livePanel = bodyView.querySelector('[data-remote-fleet-live-panel="true"]');
     assert.equal(livePanel?.dataset.deviceId, focusedDevice.DeviceId);
-    assert.equal(bodyView.querySelector('[data-remote-fleet-action="task-visible"]')?.disabled, false);
-    assert.ok(bodyView.textContent.includes('all devices, no paging'));
-    assert.match(bodyView.querySelector('[data-remote-fleet-manager-version="true"]')?.textContent || '', /^@mindexec\/cli render-smoke-manager - 127\.0\.0\.1:\d+$/);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="task-visible"]'), null);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="task-connected"]'), null);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-task-input="true"]'), null);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-ai-toggle="true"]'), null);
+    assert.equal(bodyView.textContent.includes('all devices, no paging'), false);
+    assert.equal(bodyView.textContent.includes('Host: Inactive'), false);
+    assert.equal(bodyView.textContent.includes('No screen'), false);
+    assert.equal(bodyView.textContent.includes('@mindexec/cli'), false);
+    assert.equal(nodeShell.querySelector('[data-remote-fleet-host-indicator="true"]')?.dataset.remoteFleetHostActive, 'false');
+    const initialHostButton = nodeShell.querySelector('[data-remote-fleet-action="set-host"]');
+    assert.equal(initialHostButton?.textContent, 'Set Host');
+    initialHostButton.dispatchEvent({ type: 'click' });
+    await wait();
+    const setHostCall = dotNetCalls.find(call => call.methodName === 'SetRemoteFleetHostFromJs');
+    assert.ok(setHostCall);
+    assert.equal(setHostCall.args[0], 'remote-fleet-render-smoke');
+    assert.equal(setHostCall.args[1], true);
+
+    hub.setHostTarget({
+        nodeId: 'remote-fleet-render-smoke',
+        enabled: true,
+        leaseMs: 30000
+    });
+    manager.renderRemoteFleetMonitorForTest(bodyView, buildMonitorNode(devices, hub.getStatus({ includeSecrets: true }), latestTaskBatch, recentTaskBatches));
+    assert.equal(bodyView.textContent.includes('Host: Active'), false);
+    assert.equal(nodeShell.querySelector('[data-remote-fleet-host-indicator="true"]')?.dataset.remoteFleetHostActive, 'true');
+    assert.equal(nodeShell.querySelector('[data-remote-fleet-action="set-host"]')?.textContent, 'Set Host');
+    const stopHostButton = nodeShell.querySelector('[data-remote-fleet-action="stop-host"]');
+    assert.ok(stopHostButton);
+    const stopHostStart = dotNetCalls.length;
+    stopHostButton.dispatchEvent({ type: 'click' });
+    await wait();
+    const stopHostCall = dotNetCalls
+        .slice(stopHostStart)
+        .find(call => call.methodName === 'SetRemoteFleetHostFromJs');
+    assert.ok(stopHostCall);
+    assert.equal(stopHostCall.args[0], 'remote-fleet-render-smoke');
+    assert.equal(stopHostCall.args[1], false);
+
     assert.ok(livePanel?.textContent.includes('RemoteFast 20 fps'), livePanel?.textContent || bodyView.textContent);
-    assert.ok(bodyView.querySelector('code')?.textContent.includes('npx @mindexec/remote connect'));
+    assert.equal(bodyView.querySelector('code'), null);
+    assert.equal(bodyView.textContent.includes('npx @mindexec/remote connect'), false);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="copy-command"]'), null);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="refresh"]'), null);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-auto-toggle="true"]'), null);
     assert.ok(bodyView.textContent.includes('synthetic-render-ai'));
     assert.ok(bodyView.textContent.includes('Task timed out waiting for the agent response.'));
     const batchSummary = bodyView.querySelector('[data-remote-fleet-task-batch="true"]');
@@ -691,91 +781,30 @@ try {
     assert.equal(bodyView.dataset.remoteFleetTaskFollowKey, 'render-smoke-batch');
     assert.ok(Number(bodyView.dataset.remoteFleetTaskFollowTicks || '0') >= 1);
 
-    const searchInput = bodyView.querySelector('[data-remote-fleet-search="true"]');
-    searchInput.value = 'synthetic pc 0001';
-    searchInput.dispatchEvent({ type: 'input' });
-    cards = bodyView.querySelectorAll('article[data-device-id]');
-    assert.equal(cards.filter(card => card.style.display !== 'none').length, 1);
-    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `1/${SYNTHETIC_COUNT}`);
-
-    const selects = bodyView.querySelectorAll('select');
-    assert.equal(selects.length, 4);
-    const [filterSelect, , groupSelect] = selects;
-    searchInput.value = '';
-    searchInput.dispatchEvent({ type: 'input' });
-    filterSelect.value = 'offline';
-    filterSelect.dispatchEvent({ type: 'change' });
-    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${offlineCount}/${SYNTHETIC_COUNT}`);
-
-    filterSelect.value = 'ai';
-    filterSelect.dispatchEvent({ type: 'change' });
-    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${aiCount}/${SYNTHETIC_COUNT}`);
-
-    filterSelect.value = 'all';
-    filterSelect.dispatchEvent({ type: 'change' });
-    groupSelect.value = 'status';
-    groupSelect.dispatchEvent({ type: 'change' });
-    assert.equal(bodyView.dataset.remoteFleetGroup, 'status');
-    assert.ok(bodyView.querySelectorAll('[data-remote-fleet-group-header="true"]').length >= 2);
-    assert.equal(bodyView.querySelectorAll('article[data-device-id]').length, SYNTHETIC_COUNT);
-
-    const taskInput = bodyView.querySelector('[data-remote-fleet-task-input="true"]');
-    const sendVisibleButton = bodyView.querySelector('[data-remote-fleet-action="task-visible"]');
-    assert.ok(taskInput);
-    assert.ok(sendVisibleButton);
-    taskInput.value = 'Dispatch smoke partial failure';
-    sendVisibleButton.dispatchEvent({ type: 'click' });
-    await wait();
-    const batchCall = dotNetCalls.find(call => call.methodName === 'DispatchRemoteFleetTaskBatchFromJs');
-    assert.ok(batchCall);
-    const batchTargetIds = Array.isArray(batchCall.args[1]) ? batchCall.args[1] : [];
-    assert.equal(batchTargetIds.length, connectedCount);
     const feedback = bodyView.querySelector('[data-remote-fleet-task-feedback="true"]');
     assert.ok(feedback);
-    assert.equal(feedback.style.display, 'block');
-    assert.match(feedback.textContent, new RegExp(`Queued ${connectedCount - 1}/${connectedCount} visible remote task\\(s\\); 1 failed`));
-    assert.match(feedback.textContent, /device-ai-assist-unavailable/);
-
-    const activeSelects = bodyView.querySelectorAll('select');
-    assert.equal(activeSelects.length, 4);
-    const [aiFilterSelect] = activeSelects;
-    const aiToggle = bodyView.querySelector('[data-remote-fleet-ai-toggle="true"]');
-    assert.ok(aiToggle);
-    aiFilterSelect.value = 'ai';
-    aiFilterSelect.dispatchEvent({ type: 'change' });
-    aiToggle.checked = true;
-    aiToggle.dispatchEvent({ type: 'change' });
-    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${aiCount}/${SYNTHETIC_COUNT}`);
-    assert.equal(sendVisibleButton.disabled, false);
-    taskInput.value = 'Dispatch visible AI smoke';
-    const aiDispatchCallStart = dotNetCalls.length;
-    sendVisibleButton.dispatchEvent({ type: 'click' });
-    await wait();
-    const aiBatchCall = dotNetCalls
-        .slice(aiDispatchCallStart)
-        .find(call => call.methodName === 'DispatchRemoteFleetTaskBatchFromJs');
-    assert.ok(aiBatchCall);
-    const aiTargetIds = Array.isArray(aiBatchCall.args[1]) ? aiBatchCall.args[1] : [];
-    const expectedAiTargetIds = devices
-        .filter(device => device.Connected && device.AiAssistEnabled)
-        .map(device => device.DeviceId)
-        .sort();
-    assert.deepEqual([...aiTargetIds].sort(), expectedAiTargetIds);
-    assert.equal(aiBatchCall.args[3], true);
-
-    const sendConnectedButton = bodyView.querySelector('[data-remote-fleet-action="task-connected"]');
-    assert.ok(sendConnectedButton);
-    taskInput.value = 'Dispatch all AI smoke';
-    const allAiDispatchCallStart = dotNetCalls.length;
-    sendConnectedButton.dispatchEvent({ type: 'click' });
-    await wait();
-    const allAiCall = dotNetCalls
-        .slice(allAiDispatchCallStart)
-        .find(call => call.methodName === 'DispatchRemoteFleetTaskFromJs');
-    assert.ok(allAiCall);
-    assert.equal(allAiCall.args[1], '');
-    assert.equal(allAiCall.args[3], true);
-    assert.match(feedback.textContent, new RegExp(`Queued ${aiCount}/${aiCount} AI task\\(s\\)`));
+
+    assert.equal(bodyView.querySelector('[data-remote-fleet-ai-toggle="true"]'), null);
+    assert.equal(dotNetCalls.some(call =>
+        call.methodName === 'DispatchRemoteFleetTaskBatchFromJs'
+        || call.methodName === 'DispatchRemoteFleetTaskFromJs'), false);
+
+    const emptyShell = document.createElement('div');
+    emptyShell.setAttribute('class', 'map-node-remote-fleet map-node-memo');
+    const emptyHeader = document.createElement('div');
+    emptyHeader.setAttribute('class', 'map-node-memo__header');
+    emptyHeader.appendChild(document.createElement('div'));
+    emptyHeader.appendChild(document.createElement('div'));
+    const emptyBody = document.createElement('div');
+    emptyShell.appendChild(emptyHeader);
+    emptyShell.appendChild(emptyBody);
+    document.body.appendChild(emptyShell);
+    manager.renderRemoteFleetMonitorForTest(emptyBody, buildMonitorNode([], hub.getStatus({ includeSecrets: true })));
+    assert.equal(emptyBody.querySelectorAll('[data-remote-fleet-empty-screen="true"]').length, 6);
+    assert.equal(emptyBody.textContent.includes('No devices connected yet.'), false);
+    assert.equal(emptyBody.textContent.includes('Select a screen'), false);
+    assert.equal(emptyBody.textContent.includes('No screen'), false);
+    assert.equal(emptyBody.textContent.includes('Endpoint 127.0.0.1'), false);
 
     const deviceBody = document.createElement('div');
     document.body.appendChild(deviceBody);