@mindexec/cli 0.2.395 → 0.2.397

package/package.json

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

package/remote-hub.js

@@ -90,7 +90,8 @@ const REMOTE_FRAME_MODE_ALIASES = new Map([
 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 DUPLICATE_DEVICE_LOG_THROTTLE_MS = 60000;
+const DUPLICATE_DEVICE_RETRY_AFTER_MS = 30000;
 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);
@@ -1060,6 +1061,16 @@ export function createRemoteHub(options = {}) {
     const pairToken = safeString(
         options.pairToken || env.REMOTE_HUB_PAIR_TOKEN || env.MINDEXEC_REMOTE_PAIR_TOKEN || crypto.randomBytes(6).toString('hex'),
         256);
+    const duplicateDeviceLogThrottleMs = clampNumber(
+        env.MINDEXEC_REMOTE_DUPLICATE_DEVICE_LOG_MS || env.REMOTE_HUB_DUPLICATE_DEVICE_LOG_MS,
+        5000,
+        10 * 60 * 1000,
+        DUPLICATE_DEVICE_LOG_THROTTLE_MS);
+    const duplicateDeviceRetryAfterMs = clampNumber(
+        env.MINDEXEC_REMOTE_DUPLICATE_DEVICE_RETRY_MS || env.REMOTE_HUB_DUPLICATE_DEVICE_RETRY_MS,
+        5000,
+        10 * 60 * 1000,
+        DUPLICATE_DEVICE_RETRY_AFTER_MS);
 
     const devices = new Map();
     const taskBatches = new Map();
@@ -1500,7 +1511,7 @@ export function createRemoteHub(options = {}) {
     }
 
     function rejectDuplicateActiveDevice(socket, existing, attemptedSessionId) {
-        const retryAfterMs = Math.max(DUPLICATE_DEVICE_LOG_THROTTLE_MS, Math.min(30000, heartbeatMs));
+        const retryAfterMs = Math.max(heartbeatMs, duplicateDeviceRetryAfterMs);
         writeJsonLine(socket, {
             type: 'disconnect',
             reason: 'duplicate-device-active',
@@ -1512,11 +1523,12 @@ export function createRemoteHub(options = {}) {
         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) {
+        if (nowMs - lastLoggedAt >= duplicateDeviceLogThrottleMs) {
             duplicateDeviceLogAt.set(existing.deviceId, nowMs);
-            logWarn(
+            logEvent(
                 'remote',
-                `duplicate device connection suppressed ${existing.deviceName} (${existing.deviceId}); keeping active session ${existing.sessionId}`);
+                `duplicate device connection suppressed ${existing.deviceName} (${existing.deviceId}); keeping active session ${existing.sessionId}`,
+                'remote');
         }
 
         try {

package/scripts/remote-agent-managed-smoke.mjs

@@ -162,6 +162,7 @@ async function connectManagedAgent(clientBridge, managerEndpoint, staleEndpoint)
     const result = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/connect`, {
         method: 'POST',
         body: JSON.stringify({
+            manager: managerEndpoint,
             managerCandidates: [staleEndpoint, managerEndpoint],
             pairToken: PAIR_TOKEN,
             leaseId: LEASE_ID,
@@ -216,9 +217,9 @@ async function main() {
         assert.equal(firstAgent.ready, true, JSON.stringify(firstAgent));
         assert.equal(firstAgent.usingNpx, false, JSON.stringify(firstAgent));
         assert.match(String(firstAgent.launcher || ''), /mindexec-remote-fast/i);
-        assert.ok(
-            firstConnectMs < 4500,
-            `managed RemoteAgent must race slow endpoint candidates instead of waiting sequentially, got ${firstConnectMs}ms`);
+        assert.equal(firstAgent.manager, managerEndpoint, JSON.stringify(firstAgent));
+        assert.equal(firstAgent.managerCandidates?.[0], managerEndpoint, JSON.stringify(firstAgent.managerCandidates));
+        assert.ok(firstConnectMs < 4500, `managed RemoteAgent selected manager should connect promptly, got ${firstConnectMs}ms`);
 
         const connectedDevice = await waitFor(async () => {
             const result = await fetchJson(`${hostBridge.baseUrl}/api/remote/devices`);
@@ -248,7 +249,30 @@ async function main() {
         assert.equal(secondAgent.usingNpx, false, JSON.stringify(secondAgent));
         assert.match(String(secondAgent.launcher || ''), /mindexec-remote-fast/i);
         assert.equal(secondAgent.managerCandidates?.[0], managerEndpoint, JSON.stringify(secondAgent.managerCandidates));
-        assert.equal(secondAgent.managerCandidates?.[1], staleEndpoint, JSON.stringify(secondAgent.managerCandidates));
+        assert.equal(secondAgent.managerCandidates?.length, 1, JSON.stringify(secondAgent.managerCandidates));
+
+        const duplicateReport = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/sync-report`, {
+            method: 'POST',
+            body: JSON.stringify({
+                ok: false,
+                attempted: true,
+                disconnected: true,
+                authenticated: true,
+                reason: 'connect-failed',
+                error: 'duplicate-device-active',
+                targetActive: true,
+                targetEndpoint: managerEndpoint,
+                targetEndpointCandidates: [managerEndpoint, staleEndpoint],
+                targetLeaseId: LEASE_ID,
+                targetNodeId: 'remote-agent-managed-smoke-node'
+            })
+        });
+        assert.equal(duplicateReport.ok, true, JSON.stringify(duplicateReport.payload));
+        assert.equal(duplicateReport.payload?.wake?.reason, 'duplicate-device-active', JSON.stringify(duplicateReport.payload));
+
+        const duplicateState = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/status`);
+        assert.equal(duplicateState.payload?.ready, true, JSON.stringify(duplicateState.payload));
+        assert.equal(duplicateState.payload?.needsReconnect, false, JSON.stringify(duplicateState.payload));
 
         const staleReport = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/sync-report`, {
             method: 'POST',

package/scripts/remote-hub-smoke.mjs

@@ -602,7 +602,7 @@ try {
     ), 1000);
     assert.equal(duplicateDisconnect.reason, 'duplicate-device-active');
     assert.equal(duplicateDisconnect.activeSessionId, oldSessionId);
-    assert.equal(duplicateDisconnect.retryAfterMs >= 1000, true);
+    assert.equal(duplicateDisconnect.retryAfterMs >= 30000, true);
     await wait(100);
     const duplicateRejectedDevice = hub.listDevices()[0];
     assert.equal(duplicateRejectedDevice.sessionId, oldSessionId);

package/scripts/remote-registry-follower-smoke.mjs

@@ -533,6 +533,37 @@ async function main() {
         const renewStatus = await fetchJson(`${renewHost.baseUrl}/api/status`);
         assert.equal(renewStatus.payload?.remoteHostTargetRenew?.status, 'active', JSON.stringify(renewStatus.payload?.remoteHostTargetRenew));
         assert.equal(renewStatus.payload?.remoteHostTargetRenew?.endpoint, renewPublicEndpoint, JSON.stringify(renewStatus.payload?.remoteHostTargetRenew));
+        const currentLeaseId = currentTarget?.lease_id;
+        const currentHostInstanceId = currentTarget?.host_instance_id;
+        currentTarget = {
+            ...currentTarget,
+            pair_token: 'stale-local-pair-token',
+            lease_id: 'stale-local-lease',
+            host_instance_id: 'stale-local-host-instance',
+            expires_at: new Date(Date.now() + 60_000).toISOString()
+        };
+        const staleLocalResume = await fetchJson(`${renewHost.baseUrl}/api/remote/system/resume`, {
+            method: 'POST',
+            token: BRIDGE_TOKEN,
+            body: JSON.stringify({
+                driftMs: 65000
+            })
+        });
+        assert.equal(staleLocalResume.ok, true, JSON.stringify(staleLocalResume.payload));
+        assert.equal(staleLocalResume.payload?.ok, true, JSON.stringify(staleLocalResume.payload));
+        await waitFor(() => {
+            return currentTarget?.pair_token === PAIR_TOKEN
+                && currentTarget?.lease_id === currentLeaseId
+                && currentTarget?.host_instance_id === currentHostInstanceId
+                ? currentTarget
+                : null;
+        }, 8000, `stale local host target republish\n${renewHost.details()}`);
+        const republishedStatus = await fetchJson(`${renewHost.baseUrl}/api/status`);
+        assert.equal(republishedStatus.payload?.remoteHub?.hostTargetActive, true, JSON.stringify(republishedStatus.payload?.remoteHub));
+        assert.equal(republishedStatus.payload?.remoteHostTargetRenew?.status, 'active', JSON.stringify(republishedStatus.payload?.remoteHostTargetRenew));
+        assert.equal(republishedStatus.payload?.remoteHostTargetRenew?.reason, 'local-monitor-host-republished', JSON.stringify(republishedStatus.payload?.remoteHostTargetRenew));
+        const renewAgent = await fetchJson(`${renewHost.baseUrl}/api/remote/agent/status`);
+        assert.equal(renewAgent.payload?.running, false, JSON.stringify(renewAgent.payload));
 
         const renewClear = await fetchJson(`${renewHost.baseUrl}/api/remote/host-target`, {
             method: 'DELETE',
@@ -584,7 +615,8 @@ async function main() {
         assert.equal(firstAgent.usingNpx, false, JSON.stringify(firstAgent));
         assert.match(String(firstAgent.launcher || ''), /mindexec-remote-fast/i);
         assert.equal(firstAgent.manager, hostAEndpoint);
-        assert.equal(firstAgent.managerCandidates?.[0], staleEndpoint, JSON.stringify(firstAgent.managerCandidates));
+        assert.equal(firstAgent.managerCandidates?.[0], hostAEndpoint, JSON.stringify(firstAgent.managerCandidates));
+        assert.equal(firstAgent.managerCandidates?.length, 1, JSON.stringify(firstAgent.managerCandidates));
         assert.ok(
             fakeSupabase.requests.some(request =>
                 request.method === 'POST'