@mindexec/cli 0.2.393 → 0.2.394

package/package.json

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

package/remote-hub.js

@@ -23,6 +23,8 @@ const RECENT_LIVE_FRAME_CACHE_MAX_BYTES = 24 * 1024 * 1024;
 const REMOTE_PROTOCOL_VERSION = 1;
 const MAX_SYNTHETIC_DEVICES = 1000;
 const DEFAULT_HOST_TARGET_LEASE_MS = 30000;
+const DUPLICATE_DEVICE_ACTIVE_REJECT_MS = 15000;
+const DUPLICATE_DEVICE_LOG_THROTTLE_MS = 5000;
 const SYNTHETIC_FRAME_DATA_URL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
 const SYNTHETIC_FRAME_PAYLOAD = Buffer.from(SYNTHETIC_FRAME_DATA_URL.split(',')[1], 'base64');
 const SYNTHETIC_FRAME_HASH = crypto.createHash('sha256').update(SYNTHETIC_FRAME_PAYLOAD).digest('hex').slice(0, 16);
@@ -882,6 +884,7 @@ export function createRemoteHub(options = {}) {
     const taskBatches = new Map();
     const sockets = new Map();
     const allSockets = new Set();
+    const duplicateDeviceLogAt = new Map();
     let server = null;
     let started = false;
     let boundPort = requestedPort;
@@ -1281,6 +1284,63 @@ export function createRemoteHub(options = {}) {
         existing.socket.destroy();
     }
 
+    function getDeviceActivityMs(device) {
+        return Math.max(
+            Date.parse(device?.lastSeenAt || '') || 0,
+            Date.parse(device?.lastStatusAt || '') || 0,
+            Date.parse(device?.connectedAt || '') || 0
+        );
+    }
+
+    function isDeviceConnectionFresh(device, nowMs = Date.now()) {
+        if (!device?.connected || !device.socket || device.socket.destroyed) {
+            return false;
+        }
+
+        const lastActivityMs = getDeviceActivityMs(device);
+        if (!lastActivityMs) {
+            return true;
+        }
+
+        const freshnessMs = Math.max(DUPLICATE_DEVICE_ACTIVE_REJECT_MS, heartbeatMs * 3);
+        return nowMs - lastActivityMs <= freshnessMs;
+    }
+
+    function rejectDuplicateActiveDevice(socket, existing, attemptedSessionId) {
+        const retryAfterMs = Math.max(DUPLICATE_DEVICE_LOG_THROTTLE_MS, Math.min(30000, heartbeatMs));
+        writeJsonLine(socket, {
+            type: 'disconnect',
+            reason: 'duplicate-device-active',
+            retryAfterMs,
+            activeSessionId: existing.sessionId,
+            attemptedSessionId
+        });
+
+        existing.counters.duplicateConnectionsRejected = (existing.counters.duplicateConnectionsRejected || 0) + 1;
+        const nowMs = Date.now();
+        const lastLoggedAt = duplicateDeviceLogAt.get(existing.deviceId) || 0;
+        if (nowMs - lastLoggedAt >= DUPLICATE_DEVICE_LOG_THROTTLE_MS) {
+            duplicateDeviceLogAt.set(existing.deviceId, nowMs);
+            logWarn(
+                'remote',
+                `duplicate device connection suppressed ${existing.deviceName} (${existing.deviceId}); keeping active session ${existing.sessionId}`);
+        }
+
+        try {
+            socket.end?.();
+        } catch {
+            // Best-effort graceful close before hard destroy.
+        }
+
+        setTimeout(() => {
+            try {
+                socket.destroy?.();
+            } catch {
+                // Ignore destroy failures.
+            }
+        }, 25).unref?.();
+    }
+
     function clearSyntheticFleet() {
         let removed = 0;
         for (const [deviceId, device] of devices.entries()) {
@@ -1470,9 +1530,16 @@ export function createRemoteHub(options = {}) {
     }
 
     function attachDevice(socket, hello) {
-        const now = new Date().toISOString();
+        const nowMs = Date.now();
+        const now = new Date(nowMs).toISOString();
         const sessionId = crypto.randomUUID();
         const deviceId = normalizeDeviceId(hello.deviceId);
+        const existing = devices.get(deviceId);
+
+        if (isDeviceConnectionFresh(existing, nowMs)) {
+            rejectDuplicateActiveDevice(socket, existing, sessionId);
+            return null;
+        }
 
         closeExistingDeviceSocket(deviceId, sessionId);
 
@@ -2116,8 +2183,13 @@ export function createRemoteHub(options = {}) {
                 return;
             }
 
+            const device = attachDevice(socket, message);
+            if (!device) {
+                return;
+            }
+
             state.authenticated = true;
-            state.device = attachDevice(socket, message);
+            state.device = device;
             return;
         }
 

package/scripts/remote-fast-live-rate-smoke.mjs

@@ -85,6 +85,9 @@ function spawnBridge({ bridgePort, remoteHubPort, workspacePath, label, traceFra
             BRIDGE_REQUIRE_TOKEN: '1',
             MINDEXEC_REMOTE_HUB: '1',
             MINDEXEC_REMOTE_TRACE_FRAMES: traceFrames ? '1' : '',
+            MINDEXEC_REMOTE_REGISTRY_FOLLOWER: '0',
+            MINDEXEC_REMOTE_REGISTRY_REALTIME: '0',
+            MINDEXEC_REMOTE_HOST_TARGET_AUTO_RENEW: '0',
             REMOTE_HUB_HOST: '127.0.0.1',
             REMOTE_HUB_PORT: String(remoteHubPort),
             REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN,

package/scripts/remote-hub-smoke.mjs

@@ -515,6 +515,78 @@ try {
     });
     assert.equal(staleSessionTask.ok, true);
     const oldSessionId = lateTimedOutDevice.sessionId;
+
+    const duplicateSocket = net.createConnection({ host: '127.0.0.1', port: status.port });
+    duplicateSocket.setEncoding('utf8');
+    const duplicateMessages = [];
+    let duplicateBuffer = '';
+    await new Promise((resolve, reject) => {
+        duplicateSocket.once('connect', resolve);
+        duplicateSocket.once('error', reject);
+    });
+    duplicateSocket.on('error', () => { });
+    duplicateSocket.on('data', chunk => {
+        duplicateBuffer += chunk;
+        let lineBreakIndex = duplicateBuffer.indexOf('\n');
+        while (lineBreakIndex >= 0) {
+            const line = duplicateBuffer.slice(0, lineBreakIndex).trim();
+            duplicateBuffer = duplicateBuffer.slice(lineBreakIndex + 1);
+            if (line) {
+                duplicateMessages.push(JSON.parse(line));
+            }
+            lineBreakIndex = duplicateBuffer.indexOf('\n');
+        }
+    });
+    writeJsonLine(duplicateSocket, {
+        type: 'hello',
+        pairToken: 'smoke-token',
+        deviceId: 'smoke-device',
+        deviceName: 'Smoke Device Duplicate',
+        hostname: 'smoke-host-duplicate',
+        platform: process.platform,
+        arch: process.arch,
+        pid: process.pid,
+        agentVersion: '0.0.0-smoke-duplicate',
+        capabilities: {
+            status: true,
+            thumbnail: false,
+            control: false,
+            liveStream: true,
+            computerAgent: true,
+            taskDispatch: true,
+            aiAssist: false
+        }
+    });
+
+    const duplicateDisconnect = await waitFor(() => (
+        duplicateMessages.find(message => message?.type === 'disconnect')
+    ), 1000);
+    assert.equal(duplicateDisconnect.reason, 'duplicate-device-active');
+    assert.equal(duplicateDisconnect.activeSessionId, oldSessionId);
+    assert.equal(duplicateDisconnect.retryAfterMs >= 1000, true);
+    await wait(100);
+    const duplicateRejectedDevice = hub.listDevices()[0];
+    assert.equal(duplicateRejectedDevice.sessionId, oldSessionId);
+    assert.equal(duplicateRejectedDevice.deviceName, 'Smoke Device');
+    assert.equal(duplicateRejectedDevice.connected, true);
+    assert.equal(duplicateRejectedDevice.counters.duplicateConnectionsRejected, 1);
+    assert.equal(duplicateRejectedDevice.latestTask.taskId, staleSessionTask.taskId);
+    duplicateSocket.destroy();
+
+    socket.destroy();
+    const disconnectedDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current.length === 1
+            && current[0]?.sessionId === oldSessionId
+            && current[0]?.connected === false
+            ? current[0]
+            : null;
+    });
+    assert.equal(disconnectedDevice.latestTask.status, 'failed');
+    assert.equal(
+        ['device-disconnected', 'task-timeout'].includes(disconnectedDevice.latestTask.error),
+        true);
+
     const replacementSocket = net.createConnection({ host: '127.0.0.1', port: status.port });
     replacementSocket.setEncoding('utf8');
     await new Promise((resolve, reject) => {
@@ -565,25 +637,6 @@ try {
     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);
@@ -592,7 +645,6 @@ try {
     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');