@mindexec/cli 0.2.24 → 0.2.25

package/scripts/remote-hub-smoke.mjs

@@ -47,6 +47,7 @@ try {
         socket.once('connect', resolve);
         socket.once('error', reject);
     });
+    socket.on('error', () => { });
 
     writeJsonLine(socket, {
         type: 'hello',
@@ -306,7 +307,145 @@ try {
     assert.equal(lateTimeoutDevice.latestTask.resultSummary, 'task-timeout');
     assert.equal(lateTimeoutDevice.counters.taskResultsReceived, 4);
 
+    const timeoutBatch = hub.requestAgentTaskBatch(['smoke-device'], {
+        instruction: 'This batch item intentionally times out before a late result arrives.',
+        title: 'Timeout batch'
+    });
+    assert.equal(timeoutBatch.ok, true);
+    assert.equal(timeoutBatch.total, 1);
+    assert.equal(timeoutBatch.queued, 1);
+    assert.equal(timeoutBatch.batch?.pending, 1);
+    const timeoutBatchItem = timeoutBatch.results.find(result => result.deviceId === 'smoke-device');
+    assert.ok(timeoutBatchItem?.commandId);
+    assert.ok(timeoutBatchItem?.taskId);
+
+    const timedOutBatch = await waitFor(() => {
+        const latest = hub.getLatestTaskBatch();
+        return latest?.batchId === timeoutBatch.batchId
+            && latest.timedOut === 1
+            && latest.pending === 0
+            ? latest
+            : null;
+    }, 1000);
+    assert.equal(timedOutBatch.status, 'completed-with-failures');
+    assert.equal(timedOutBatch.failed, 1);
+    assert.equal(timedOutBatch.results[0]?.status, 'failed');
+    assert.equal(timedOutBatch.results[0]?.error, 'task-timeout');
+
+    writeJsonLine(socket, {
+        type: 'command.result',
+        commandId: timeoutBatchItem.commandId,
+        result: {
+            kind: 'agent.task',
+            taskId: timeoutBatchItem.taskId,
+            status: 'completed',
+            summary: 'This late batch timeout result must be ignored.',
+            completedAt: new Date().toISOString()
+        }
+    });
+    await wait(100);
+    const lateTimedOutBatch = hub.getLatestTaskBatch();
+    const lateTimedOutDevice = hub.listDevices()[0];
+    assert.equal(lateTimedOutBatch.batchId, timeoutBatch.batchId);
+    assert.equal(lateTimedOutBatch.status, 'completed-with-failures');
+    assert.equal(lateTimedOutBatch.completed, 0);
+    assert.equal(lateTimedOutBatch.failed, 1);
+    assert.equal(lateTimedOutBatch.timedOut, 1);
+    assert.equal(lateTimedOutBatch.results[0]?.status, 'failed');
+    assert.equal(lateTimedOutBatch.results[0]?.error, 'task-timeout');
+    assert.equal(lateTimedOutDevice.latestTask.taskId, timeoutBatchItem.taskId);
+    assert.equal(lateTimedOutDevice.latestTask.status, 'failed');
+    assert.equal(lateTimedOutDevice.latestTask.error, 'task-timeout');
+    assert.equal(lateTimedOutDevice.latestTask.resultSummary, 'task-timeout');
+    assert.equal(lateTimedOutDevice.counters.taskResultsReceived, 5);
+    assert.equal(lateTimedOutDevice.counters.taskResultsFailed, 2);
+    assert.equal(lateTimedOutDevice.counters.taskResultsTimedOut, 2);
+
+    const staleSessionTask = hub.requestAgentTask('smoke-device', {
+        instruction: 'This old session task must not survive reconnect.',
+        title: 'Reconnect stale task'
+    });
+    assert.equal(staleSessionTask.ok, true);
+    const oldSessionId = lateTimedOutDevice.sessionId;
+    const replacementSocket = net.createConnection({ host: '127.0.0.1', port: status.port });
+    replacementSocket.setEncoding('utf8');
+    await new Promise((resolve, reject) => {
+        replacementSocket.once('connect', resolve);
+        replacementSocket.once('error', reject);
+    });
+    replacementSocket.on('error', () => { });
+    writeJsonLine(replacementSocket, {
+        type: 'hello',
+        pairToken: 'smoke-token',
+        deviceId: 'smoke-device',
+        deviceName: 'Smoke Device Reconnected',
+        hostname: 'smoke-host-reconnected',
+        platform: process.platform,
+        arch: process.arch,
+        pid: process.pid,
+        agentVersion: '0.0.0-smoke-reconnected',
+        capabilities: {
+            status: true,
+            thumbnail: false,
+            control: false,
+            liveStream: true,
+            computerAgent: true,
+            taskDispatch: true,
+            aiAssist: true,
+            aiModel: 'fake-ai'
+        }
+    });
+    writeJsonLine(replacementSocket, {
+        type: 'status',
+        status: {
+            uptimeSec: 2,
+            totalMem: 4,
+            freeMem: 3
+        }
+    });
+
+    const reconnectedDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current.length === 1
+            && current[0]?.deviceName === 'Smoke Device Reconnected'
+            && current[0]?.status?.uptimeSec === 2
+            ? current[0]
+            : null;
+    });
+    assert.notEqual(reconnectedDevice.sessionId, oldSessionId);
+    assert.equal(reconnectedDevice.connected, true);
+    assert.equal(reconnectedDevice.latestTask, null);
+    assert.equal(reconnectedDevice.counters.taskResultsReceived, 0);
+
+    writeJsonLine(socket, {
+        type: 'status',
+        status: {
+            uptimeSec: 999,
+            totalMem: 999,
+            freeMem: 0
+        }
+    });
+    writeJsonLine(socket, {
+        type: 'command.result',
+        commandId: staleSessionTask.commandId,
+        result: {
+            kind: 'agent.task',
+            taskId: staleSessionTask.taskId,
+            status: 'completed',
+            summary: 'This old-session result must not mutate the reconnected device.',
+            completedAt: new Date().toISOString()
+        }
+    });
+    await wait(100);
+    const staleSessionIgnoredDevice = hub.listDevices()[0];
+    assert.equal(staleSessionIgnoredDevice.sessionId, reconnectedDevice.sessionId);
+    assert.equal(staleSessionIgnoredDevice.deviceName, 'Smoke Device Reconnected');
+    assert.equal(staleSessionIgnoredDevice.status.uptimeSec, 2);
+    assert.equal(staleSessionIgnoredDevice.latestTask, null);
+    assert.equal(staleSessionIgnoredDevice.counters.taskResultsReceived, 0);
+
     socket.destroy();
+    replacementSocket.destroy();
     await waitFor(() => hub.listDevices()[0]?.connected === false);
     console.log('RemoteHub smoke OK');
 } finally {

package/server.js

@@ -6978,6 +6978,23 @@ app.get('/api/remote/devices', (req, res) => {
     });
 });
 
+app.post('/api/remote/host-target', (req, res) => {
+    res.setHeader('Cache-Control', 'no-store');
+    res.json(remoteHub.setHostTarget({
+        enabled: req.body?.enabled !== false,
+        nodeId: req.body?.nodeId,
+        leaseMs: req.body?.leaseMs
+    }));
+});
+
+app.delete('/api/remote/host-target', (req, res) => {
+    res.setHeader('Cache-Control', 'no-store');
+    res.json(remoteHub.setHostTarget({
+        enabled: false,
+        nodeId: req.body?.nodeId
+    }));
+});
+
 function isSyntheticRemoteFleetEnabled() {
     return /^(1|true|yes|on)$/i.test(String(
         process.env.MINDEXEC_REMOTE_SYNTHETIC_FLEET

package/wwwroot/_content/MindExecution.Shared/js/mind-map-core.js

@@ -6280,7 +6280,24 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
 
             const x = Number(moduleInstance.cursorPosition?.x ?? moduleInstance.camera?.position?.x ?? 0);
             const y = Number(moduleInstance.cursorPosition?.y ?? moduleInstance.camera?.position?.y ?? 0);
-            return await moduleInstance.dotNetHelper.invokeMethodAsync('AddRemoteFleetMonitorNodeFromJs', x, y);
+            const result = await moduleInstance.dotNetHelper.invokeMethodAsync('AddRemoteFleetMonitorNodeFromJs', x, y);
+            const nodeId = String(result?.nodeId ?? result?.NodeId ?? '').trim();
+            if (nodeId) {
+                const alreadyExists = result?.alreadyExists === true || result?.AlreadyExists === true;
+                const focusExistingMonitor = () => window.mindMap?.focusNode?.(nodeId, {
+                    selectNode: true,
+                    preferReadableZoom: true,
+                    highlightSearchFocus: alreadyExists
+                }) === true;
+                if (!focusExistingMonitor()) {
+                    setTimeout(focusExistingMonitor, 120);
+                }
+                window.RuntimeTrace?.emit?.('remote.monitor.focused', {
+                    nodeId,
+                    alreadyExists
+                });
+            }
+            return result;
         },
         // ▼▼▼ [Perf] Expose nodeObjectsById for will-change optimization ▼▼▼
         getNodeObjectsById: () => moduleInstance?.nodeObjectsById || null,