@mindexec/cli 0.2.24 → 0.2.26

package/scripts/remote-http-smoke.mjs

@@ -51,11 +51,11 @@ async function fetchJson(url, options = {}) {
     };
 }
 
-async function waitForBridge(baseUrl, getFailureDetails) {
+async function waitForBridge(baseUrl, getFailureDetails, bridgeToken = BRIDGE_TOKEN) {
     const startedAt = Date.now();
     while (Date.now() - startedAt < 30000) {
         try {
-            const result = await fetchJson(`${baseUrl}/api/remote/status`, { token: BRIDGE_TOKEN });
+            const result = await fetchJson(`${baseUrl}/api/remote/status`, { token: bridgeToken });
             if (result.ok && result.payload?.started === true) {
                 return result.payload;
             }
@@ -70,49 +70,96 @@ async function waitForBridge(baseUrl, getFailureDetails) {
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const bridgeRoot = path.resolve(__dirname, '..');
-const bridgePort = await findFreePort();
-const remoteHubPort = await findFreePort();
-const baseUrl = `http://127.0.0.1:${bridgePort}`;
-
-const child = spawn(process.execPath, ['server.js'], {
-    cwd: bridgeRoot,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    windowsHide: true,
-    env: {
+
+function spawnBridge({
+    bridgePort,
+    remoteHubPort,
+    bridgeToken = BRIDGE_TOKEN,
+    pairToken = PAIR_TOKEN,
+    syntheticFleetEnabled = false
+}) {
+    const env = {
         ...process.env,
         BRIDGE_PORT: String(bridgePort),
-        BRIDGE_TOKEN,
+        BRIDGE_TOKEN: bridgeToken,
         BRIDGE_REQUIRE_TOKEN: '1',
         MINDEXEC_REMOTE_HUB: '1',
         REMOTE_HUB_HOST: '127.0.0.1',
         REMOTE_HUB_PORT: String(remoteHubPort),
-        REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN,
-        MINDEXEC_REMOTE_SYNTHETIC_FLEET: '1',
+        REMOTE_HUB_PAIR_TOKEN: pairToken,
         NO_COLOR: '1'
+    };
+
+    delete env.MINDEXEC_REMOTE_SYNTHETIC_FLEET;
+    delete env.REMOTE_HUB_SYNTHETIC_FLEET;
+    if (syntheticFleetEnabled) {
+        env.MINDEXEC_REMOTE_SYNTHETIC_FLEET = '1';
     }
-});
-
-let stdout = '';
-let stderr = '';
-child.stdout.on('data', chunk => {
-    stdout += chunk.toString();
-});
-child.stderr.on('data', chunk => {
-    stderr += chunk.toString();
-});
-
-const exitPromise = new Promise(resolve => child.once('exit', resolve));
-const details = () => `stdout=${stdout}\nstderr=${stderr}`;
-
-try {
-    const status = await waitForBridge(baseUrl, details);
+
+    const child = spawn(process.execPath, ['server.js'], {
+        cwd: bridgeRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        env
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => {
+        stdout += chunk.toString();
+    });
+    child.stderr.on('data', chunk => {
+        stderr += chunk.toString();
+    });
+
+    const exitPromise = new Promise(resolve => child.once('exit', resolve));
+    const details = () => `stdout=${stdout}\nstderr=${stderr}`;
+    const stop = async () => {
+        if (child.exitCode === null && !child.killed) {
+            child.kill('SIGTERM');
+            await Promise.race([
+                exitPromise,
+                wait(5000)
+            ]);
+            if (child.exitCode === null && !child.killed) {
+                child.kill('SIGKILL');
+            }
+        }
+    };
+
+    return {
+        baseUrl: `http://127.0.0.1:${bridgePort}`,
+        bridgePort,
+        remoteHubPort,
+        bridgeToken,
+        pairToken,
+        child,
+        details,
+        stop
+    };
+}
+
+async function runSyntheticEnabledSmoke() {
+    const bridgePort = await findFreePort();
+    const remoteHubPort = await findFreePort();
+    const bridge = spawnBridge({
+        bridgePort,
+        remoteHubPort,
+        syntheticFleetEnabled: true
+    });
+    const { baseUrl } = bridge;
+    const details = bridge.details;
+
+    try {
+    const status = await waitForBridge(baseUrl, details, bridge.bridgeToken);
     assert.equal(status.started, true);
     assert.equal(status.port, remoteHubPort);
     assert.equal(status.managerPackage, '@mindexec/cli');
-    assert.equal(status.managerVersion, '0.2.24');
+    assert.equal(status.managerVersion, '0.2.25');
     assert.equal(status.agentPackage, '@mindexec/remote');
     assert.equal(status.canvasPagination, 'none');
     assert.equal(status.canvasDeviceListMode, 'all-devices');
+    assert.equal(status.hostTargetActive, false);
     assert.equal(status.pairToken, PAIR_TOKEN);
 
     const unauthorizedStatus = await fetchJson(`${baseUrl}/api/remote/status`);
@@ -124,6 +171,58 @@ try {
     });
     assert.equal(unauthorizedDelete.status, 401);
 
+    const unauthorizedHost = await fetchJson(`${baseUrl}/api/remote/host-target`, {
+        method: 'POST',
+        body: JSON.stringify({
+            nodeId: 'remote-fleet-host-unauthorized',
+            enabled: true
+        })
+    });
+    assert.equal(unauthorizedHost.status, 401);
+
+    const setHost = await fetchJson(`${baseUrl}/api/remote/host-target`, {
+        method: 'POST',
+        token: BRIDGE_TOKEN,
+        body: JSON.stringify({
+            nodeId: 'remote-fleet-monitor-a',
+            enabled: true,
+            leaseMs: 30000
+        })
+    });
+    assert.equal(setHost.ok, true, JSON.stringify(setHost.payload));
+    assert.equal(setHost.payload?.ok, true);
+    assert.equal(setHost.payload?.active, true);
+    assert.equal(setHost.payload?.hostTarget?.nodeId, 'remote-fleet-monitor-a');
+    assert.equal(setHost.payload?.hostTarget?.endpoint, `127.0.0.1:${remoteHubPort}`);
+
+    const hostStatus = await fetchJson(`${baseUrl}/api/remote/status`, { token: BRIDGE_TOKEN });
+    assert.equal(hostStatus.ok, true, JSON.stringify(hostStatus.payload));
+    assert.equal(hostStatus.payload?.hostTargetActive, true);
+    assert.equal(hostStatus.payload?.hostTargetNodeId, 'remote-fleet-monitor-a');
+    assert.equal(hostStatus.payload?.hostTargetEndpoint, `127.0.0.1:${remoteHubPort}`);
+
+    const clearHostMismatch = await fetchJson(`${baseUrl}/api/remote/host-target`, {
+        method: 'DELETE',
+        token: BRIDGE_TOKEN,
+        body: JSON.stringify({
+            nodeId: 'remote-fleet-monitor-b'
+        })
+    });
+    assert.equal(clearHostMismatch.ok, true, JSON.stringify(clearHostMismatch.payload));
+    assert.equal(clearHostMismatch.payload?.ok, false);
+    assert.equal(clearHostMismatch.payload?.error, 'host-target-node-mismatch');
+
+    const clearHost = await fetchJson(`${baseUrl}/api/remote/host-target`, {
+        method: 'DELETE',
+        token: BRIDGE_TOKEN,
+        body: JSON.stringify({
+            nodeId: 'remote-fleet-monitor-a'
+        })
+    });
+    assert.equal(clearHost.ok, true, JSON.stringify(clearHost.payload));
+    assert.equal(clearHost.payload?.ok, true);
+    assert.equal(clearHost.payload?.active, false);
+
     const seed = await fetchJson(`${baseUrl}/api/remote/synthetic/seed`, {
         method: 'POST',
         token: BRIDGE_TOKEN,
@@ -283,14 +382,93 @@ try {
 
     console.log(`RemoteHub HTTP smoke OK (${SYNTHETIC_COUNT} synthetic devices, bridge ${bridgePort}, remote ${remoteHubPort})`);
 } finally {
-    if (child.exitCode === null && !child.killed) {
-        child.kill('SIGTERM');
-        await Promise.race([
-            exitPromise,
-            wait(5000)
-        ]);
-        if (child.exitCode === null && !child.killed) {
-            child.kill('SIGKILL');
-        }
+    await bridge.stop();
+}
+}
+
+async function runSyntheticDisabledSmoke() {
+    const bridgePort = await findFreePort();
+    const remoteHubPort = await findFreePort();
+    const bridgeToken = `${BRIDGE_TOKEN}-disabled`;
+    const pairToken = `${PAIR_TOKEN}-disabled`;
+    const bridge = spawnBridge({
+        bridgePort,
+        remoteHubPort,
+        bridgeToken,
+        pairToken,
+        syntheticFleetEnabled: false
+    });
+    const { baseUrl } = bridge;
+
+    try {
+        const status = await waitForBridge(baseUrl, bridge.details, bridge.bridgeToken);
+        assert.equal(status.started, true);
+        assert.equal(status.port, remoteHubPort);
+        assert.equal(status.pairToken, pairToken);
+        assert.equal(status.canvasPagination, 'none');
+        assert.equal(status.canvasDeviceListMode, 'all-devices');
+        assert.equal(status.hostTargetActive, false);
+
+        const seedDenied = await fetchJson(`${baseUrl}/api/remote/synthetic/seed`, {
+            method: 'POST',
+            token: bridge.bridgeToken,
+            body: JSON.stringify({
+                count: 3,
+                replace: true
+            })
+        });
+        assert.equal(seedDenied.status, 403);
+        assert.equal(seedDenied.payload?.ok, false);
+        assert.equal(seedDenied.payload?.error, 'synthetic-fleet-disabled');
+
+        const clearDenied = await fetchJson(`${baseUrl}/api/remote/synthetic`, {
+            method: 'DELETE',
+            token: bridge.bridgeToken
+        });
+        assert.equal(clearDenied.status, 403);
+        assert.equal(clearDenied.payload?.ok, false);
+        assert.equal(clearDenied.payload?.error, 'synthetic-fleet-disabled');
+
+        const devicesResult = await fetchJson(`${baseUrl}/api/remote/devices`, { token: bridge.bridgeToken });
+        assert.equal(devicesResult.ok, true, JSON.stringify(devicesResult.payload));
+        assert.equal(devicesResult.payload?.total, 0);
+        assert.equal(devicesResult.payload?.pagination, 'none');
+        assert.equal(devicesResult.payload?.canvasDeviceListMode, 'all-devices');
+        assert.equal(devicesResult.payload?.devices?.length, 0);
+
+        const emptyBatch = await fetchJson(`${baseUrl}/api/remote/tasks`, {
+            method: 'POST',
+            token: bridge.bridgeToken,
+            body: JSON.stringify({
+                allConnected: true,
+                title: 'HTTP smoke no target batch',
+                instruction: 'This should not queue because no remote devices are connected.',
+                approvalLevel: 'task-only'
+            })
+        });
+        assert.equal(emptyBatch.ok, true, JSON.stringify(emptyBatch.payload));
+        assert.equal(emptyBatch.payload?.ok, false);
+        assert.equal(emptyBatch.payload?.total, 0);
+        assert.equal(emptyBatch.payload?.queued, 0);
+        assert.equal(emptyBatch.payload?.error, 'no-target-devices');
+
+        const hostTarget = await fetchJson(`${baseUrl}/api/remote/host-target`, {
+            method: 'POST',
+            token: bridge.bridgeToken,
+            body: JSON.stringify({
+                nodeId: 'disabled-synthetic-host',
+                enabled: true
+            })
+        });
+        assert.equal(hostTarget.ok, true, JSON.stringify(hostTarget.payload));
+        assert.equal(hostTarget.payload?.ok, true);
+        assert.equal(hostTarget.payload?.active, true);
+
+        console.log(`RemoteHub HTTP safety smoke OK (synthetic disabled, bridge ${bridgePort}, remote ${remoteHubPort})`);
+    } finally {
+        await bridge.stop();
     }
 }
+
+await runSyntheticEnabledSmoke();
+await runSyntheticDisabledSmoke();

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,