@mindexec/cli 0.2.23 → 0.2.25

package/package.json

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

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) {
@@ -205,6 +206,8 @@ export function createRemoteHub(options = {}) {
         50,
         30 * 60 * 1000,
         DEFAULT_AGENT_TASK_TIMEOUT_MS);
+    const managerPackage = safeString(options.managerPackage ?? env.MINDEXEC_MANAGER_PACKAGE ?? '@mindexec/cli', 128);
+    const managerVersion = safeString(options.managerVersion ?? env.MINDEXEC_MANAGER_VERSION ?? '', 64);
     const pairToken = safeString(
         env.REMOTE_HUB_PAIR_TOKEN || env.MINDEXEC_REMOTE_PAIR_TOKEN || crypto.randomBytes(6).toString('hex'),
         256);
@@ -217,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,
@@ -229,14 +352,23 @@ export function createRemoteHub(options = {}) {
             protocolVersion: REMOTE_PROTOCOL_VERSION,
             heartbeatMs,
             taskTimeoutMs,
+            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
         };
@@ -1686,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',
@@ -426,12 +429,21 @@ function buildMonitorNode(devices, hubStatus, latestTaskBatch = null, recentTask
             RemoteFleetLastRefreshAtUtc: new Date().toISOString(),
             RemoteFleetHubStatus: 'online',
             RemoteFleetHubEndpoint: endpoint,
+            RemoteFleetManagerPackage: hubStatus.managerPackage || '@mindexec/cli',
+            RemoteFleetManagerVersion: hubStatus.managerVersion || 'render-smoke-manager',
             RemoteFleetAgentPackage: '@mindexec/remote',
             RemoteFleetPairTokenPreview: '<pair-token>',
             RemoteFleetConnectCommand: `npx @mindexec/remote connect --manager ${endpoint} --pair ${pairToken}`,
             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),
@@ -452,6 +464,8 @@ function buildDeviceNode(device, hubStatus) {
             RemoteFleetLastRefreshAtUtc: new Date().toISOString(),
             RemoteFleetHubStatus: 'online',
             RemoteFleetHubEndpoint: endpoint,
+            RemoteFleetManagerPackage: hubStatus.managerPackage || '@mindexec/cli',
+            RemoteFleetManagerVersion: hubStatus.managerVersion || 'render-smoke-manager',
             RemoteFleetAgentPackage: '@mindexec/remote',
             RemoteFleetPinnedDeviceId: device.DeviceId,
             RemoteFleetPinnedDeviceJson: JSON.stringify(device),
@@ -495,6 +509,8 @@ function createThreeStub() {
 }
 
 const hub = createRemoteHub({
+    managerPackage: '@mindexec/cli',
+    managerVersion: 'render-smoke-manager',
     env: {
         MINDEXEC_REMOTE_HUB: '1',
         REMOTE_HUB_HOST: '127.0.0.1',
@@ -639,6 +655,13 @@ try {
                 };
             }
 
+            if (methodName === 'SetRemoteFleetHostFromJs') {
+                return {
+                    success: true,
+                    active: args[1] === true
+                };
+            }
+
             return { success: true };
         }
     };
@@ -654,15 +677,69 @@ try {
     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.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.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.ok(bodyView.textContent.includes('all devices, no paging'));
+    assert.equal(bodyView.querySelector('[data-remote-fleet-host-state="true"]')?.textContent.includes('Host: Inactive'), true);
+    const initialHostButton = bodyView.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.querySelector('[data-remote-fleet-host-state="true"]')?.textContent.includes('Host: Active'), true);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="set-host"]')?.textContent, 'Hosting');
+    const stopHostButton = bodyView.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.match(bodyView.querySelector('[data-remote-fleet-manager-version="true"]')?.textContent || '', /^@mindexec\/cli render-smoke-manager - 127\.0\.0\.1:\d+$/);
     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"]');
@@ -712,63 +789,20 @@ try {
     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/);
+    assert.equal(feedback.style.display, 'none');
 
     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);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-ai-toggle="true"]'), null);
     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(dotNetCalls.some(call =>
+        call.methodName === 'DispatchRemoteFleetTaskBatchFromJs'
+        || call.methodName === 'DispatchRemoteFleetTaskFromJs'), false);
 
     const deviceBody = document.createElement('div');
     document.body.appendChild(deviceBody);