@mindexec/cli 0.2.160 → 0.2.162

package/package.json

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

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

@@ -291,6 +291,8 @@ function spawnBridge({ bridgePort, remoteHubPort, workspacePath, authRoot, label
             MINDEXEC_REMOTE_REGISTRY_FOLLOWER: follower ? '1' : '0',
             MINDEXEC_REMOTE_REGISTRY_POLL_MS: '10000',
             MINDEXEC_REMOTE_REGISTRY_FAST_RETRY_MS: '250',
+            MINDEXEC_REMOTE_REGISTRY_INACTIVE_STOP_COUNT: '2',
+            MINDEXEC_REMOTE_REGISTRY_INACTIVE_GRACE_MS: '500',
             MINDEXEC_REMOTE_REGISTRY_REALTIME_RECONNECT_MS: '250',
             MINDEXEC_REMOTE_REGISTRY_REALTIME_DEBOUNCE_MS: '100',
             MINDEXEC_REMOTE_HOST_TARGET_RENEW_MS: '5000',
@@ -575,6 +577,28 @@ async function main() {
         assert.equal(secondAgent.leaseId, 'lease-b');
         await waitForConnectedDevice(hostB, 'host-b');
 
+        await wait(250);
+        currentTarget = null;
+        fakeSupabase.broadcastChange('DELETE');
+        await waitFor(async () => {
+            const status = await fetchJson(`${client.baseUrl}/api/status`);
+            const agent = await fetchJson(`${client.baseUrl}/api/remote/agent/status`);
+            return status.payload?.remoteRegistryFollower?.reason === 'no-active-target-agent-kept'
+                && agent.payload?.running === true
+                && String(agent.payload?.manager || '') === hostBEndpoint
+                ? { status: status.payload.remoteRegistryFollower, agent: agent.payload }
+                : null;
+        }, 4000, `transient no-active-target keeps managed agent\n${client.details()}`);
+
+        currentTarget = createRegistryTarget({
+            endpoint: hostBEndpoint,
+            endpointCandidates: [hostBEndpoint],
+            leaseId: 'lease-b'
+        });
+        fakeSupabase.broadcastChange('INSERT');
+        const restoredAgent = await waitForManagedAgent(client, hostBEndpoint, 'host-b after transient missing target', 9000);
+        assert.equal(Number(restoredAgent.pid || 0), Number(secondAgent.pid || 0), JSON.stringify(restoredAgent));
+
         const secondPid = Number(secondAgent.pid || 0);
         killProcess(secondPid);
         const restartedAgent = await waitForManagedAgentRestart(client, hostBEndpoint, secondPid, 'host-b', 12000);
@@ -589,6 +613,8 @@ async function main() {
             expires_at: new Date(Date.now() - 1000).toISOString()
         };
         fakeSupabase.broadcastChange('UPDATE');
+        await wait(700);
+        fakeSupabase.broadcastChange('UPDATE');
 
         await waitFor(async () => {
             const result = await fetchJson(`${client.baseUrl}/api/remote/agent/status`);

package/server.js

@@ -3360,6 +3360,8 @@ const REMOTE_REGISTRY_FOLLOWER_ENABLED = !/^(0|false|no|off)$/i.test(String(proc
 const REMOTE_REGISTRY_FOLLOWER_POLL_MS = Math.max(1500, Number(process.env.MINDEXEC_REMOTE_REGISTRY_POLL_MS || 5000) || 5000);
 const REMOTE_REGISTRY_FOLLOWER_FAST_RETRY_MS = Math.max(500, Number(process.env.MINDEXEC_REMOTE_REGISTRY_FAST_RETRY_MS || 1200) || 1200);
 const REMOTE_REGISTRY_FOLLOWER_MISSING_SESSION_STOP_COUNT = 3;
+const REMOTE_REGISTRY_FOLLOWER_INACTIVE_STOP_COUNT = Math.max(2, Number(process.env.MINDEXEC_REMOTE_REGISTRY_INACTIVE_STOP_COUNT || 8) || 8);
+const REMOTE_REGISTRY_FOLLOWER_INACTIVE_GRACE_MS = Math.max(500, Number(process.env.MINDEXEC_REMOTE_REGISTRY_INACTIVE_GRACE_MS || 60000) || 60000);
 const REMOTE_REGISTRY_REALTIME_ENABLED = REMOTE_REGISTRY_FOLLOWER_ENABLED
     && !/^(0|false|no|off)$/i.test(String(process.env.MINDEXEC_REMOTE_REGISTRY_REALTIME || 'true'));
 const REMOTE_REGISTRY_REALTIME_HEARTBEAT_MS = Math.max(10000, Number(process.env.MINDEXEC_REMOTE_REGISTRY_REALTIME_HEARTBEAT_MS || 25000) || 25000);
@@ -3391,6 +3393,8 @@ let remoteRegistryFollowerTimer = null;
 let remoteRegistryFollowerInFlight = false;
 let remoteRegistryFollowerStarted = false;
 let remoteRegistryFollowerConsecutiveMissingSession = 0;
+let remoteRegistryFollowerConsecutiveInactiveTarget = 0;
+let remoteRegistryFollowerInactiveTargetFirstAt = 0;
 let remoteRegistryRealtimeSocket = null;
 let remoteRegistryRealtimeSessionKey = '';
 let remoteRegistryRealtimeTopic = '';
@@ -3532,6 +3536,9 @@ function createRemoteAgentSyncReport(body = {}) {
         targetLeaseId: safeRemoteAgentField(body.targetLeaseId || body.TargetLeaseId, 128),
         targetNodeId: safeRemoteAgentField(body.targetNodeId || body.TargetNodeId, 128),
         targetExpiresAt: safeRemoteAgentField(body.targetExpiresAt || body.TargetExpiresAt, 80),
+        inactiveCount: Number(body.inactiveCount ?? body.InactiveCount ?? 0) || 0,
+        inactiveElapsedMs: Number(body.inactiveElapsedMs ?? body.InactiveElapsedMs ?? 0) || 0,
+        agentKept: body.agentKept === true || body.AgentKept === true,
         updatedAt: new Date().toISOString()
     };
 }
@@ -3954,6 +3961,39 @@ function maybeRetryRemoteAgentAfterExit(state, reason = 'agent-exited') {
     scheduleRemoteRegistryFollower(0, reason);
 }
 
+function resetRemoteRegistryInactiveTargetGrace() {
+    remoteRegistryFollowerConsecutiveInactiveTarget = 0;
+    remoteRegistryFollowerInactiveTargetFirstAt = 0;
+}
+
+function rememberRemoteRegistryInactiveTarget(reason = 'no-active-target') {
+    const now = Date.now();
+    remoteRegistryFollowerConsecutiveInactiveTarget += 1;
+    if (!remoteRegistryFollowerInactiveTargetFirstAt) {
+        remoteRegistryFollowerInactiveTargetFirstAt = now;
+    }
+
+    const elapsedMs = Math.max(0, now - remoteRegistryFollowerInactiveTargetFirstAt);
+    const agentRunning = isRemoteAgentRegistryOwned();
+    const confirmedInactive = remoteRegistryFollowerConsecutiveInactiveTarget >= REMOTE_REGISTRY_FOLLOWER_INACTIVE_STOP_COUNT
+        && elapsedMs >= REMOTE_REGISTRY_FOLLOWER_INACTIVE_GRACE_MS;
+
+    if (agentRunning && !confirmedInactive) {
+        logEvent(
+            'remote',
+            `registry target temporarily inactive; keeping managed RemoteAgent ${formatKeyValue('reason', reason)} ${formatKeyValue('count', remoteRegistryFollowerConsecutiveInactiveTarget)} ${formatKeyValue('elapsedMs', elapsedMs)}`,
+            'remote');
+    }
+
+    return {
+        count: remoteRegistryFollowerConsecutiveInactiveTarget,
+        elapsedMs,
+        agentRunning,
+        confirmedInactive,
+        agentKept: agentRunning && !confirmedInactive
+    };
+}
+
 function isLocalRemoteHostTargetActive() {
     const status = remoteHub.getStatus({ includeSecrets: false });
     return status?.hostTargetActive === true
@@ -4208,9 +4248,11 @@ function resolveNpxCliLauncher() {
     return '';
 }
 
-async function stopRemoteAgentConnection(reason = 'stopped') {
+async function stopRemoteAgentConnection(reason = 'stopped', options = {}) {
     const previous = remoteAgentState;
-    suppressRemoteAgentAutoRetry(previous.connectionKey);
+    if (options.suppressRetry !== false) {
+        suppressRemoteAgentAutoRetry(previous.connectionKey);
+    }
     if (previous.proc) {
         try {
             await terminateProcessTree(previous.proc);
@@ -4753,7 +4795,13 @@ function serializeRemoteRegistryFollowerState() {
     return {
         ...remoteRegistryFollowerState,
         pollMs: REMOTE_REGISTRY_FOLLOWER_POLL_MS,
-        fastRetryMs: REMOTE_REGISTRY_FOLLOWER_FAST_RETRY_MS
+        fastRetryMs: REMOTE_REGISTRY_FOLLOWER_FAST_RETRY_MS,
+        inactiveStopCount: REMOTE_REGISTRY_FOLLOWER_INACTIVE_STOP_COUNT,
+        inactiveGraceMs: REMOTE_REGISTRY_FOLLOWER_INACTIVE_GRACE_MS,
+        inactiveCount: remoteRegistryFollowerConsecutiveInactiveTarget,
+        inactiveElapsedMs: remoteRegistryFollowerInactiveTargetFirstAt
+            ? Math.max(0, Date.now() - remoteRegistryFollowerInactiveTargetFirstAt)
+            : 0
     };
 }
 
@@ -5499,7 +5547,11 @@ function buildRemoteHostTargetRegistryPayload(hub) {
     const hostInstanceId = safeRemoteAgentField(hub?.hostTargetHostInstanceId || hub?.hostInstanceId, 128);
     const nodeId = safeRemoteAgentField(hub?.hostTargetNodeId, 128);
     const activatedAt = safeRemoteAgentField(hub?.hostTargetActivatedAt, 80) || new Date().toISOString();
-    const expiresAt = safeRemoteAgentField(hub?.hostTargetExpiresAt, 80) || new Date(Date.now() + REMOTE_HOST_TARGET_LEASE_MS).toISOString();
+    const rawExpiresAt = safeRemoteAgentField(hub?.hostTargetExpiresAt, 80);
+    const rawExpiresAtMs = Date.parse(rawExpiresAt || '');
+    const expiresAt = Number.isFinite(rawExpiresAtMs) && rawExpiresAtMs > Date.now() + 5000
+        ? rawExpiresAt
+        : new Date(Date.now() + REMOTE_HOST_TARGET_LEASE_MS).toISOString();
 
     if (!pairToken || !leaseId || !hostInstanceId || !nodeId) {
         return {
@@ -5710,7 +5762,7 @@ async function reconcileRemoteAfterSystemResume(trigger = 'timer-drift', driftMs
         closeRemoteRegistryRealtime('system-resume');
 
         if (wasRegistryAgentRunning) {
-            await stopRemoteAgentConnection('system-resume-reconnect');
+            await stopRemoteAgentConnection('system-resume-reconnect', { suppressRetry: false });
         }
 
         if (isLocalHost) {
@@ -6001,6 +6053,7 @@ async function runRemoteRegistryFollowerOnce(trigger = 'timer') {
         const target = await fetchRemoteRegistryTarget(config, session);
 
         if (localHub?.hostTargetActive === true) {
+            resetRemoteRegistryInactiveTargetGrace();
             if (target?.active === true
                 && !isRemoteRegistryTargetExpired(target)
                 && !isRemoteRegistryTargetSameAsLocalHost(localHub, target)) {
@@ -6064,32 +6117,50 @@ async function runRemoteRegistryFollowerOnce(trigger = 'timer') {
         }
 
         if (!target?.active || isRemoteRegistryTargetExpired(target)) {
-            if (isRemoteAgentRegistryOwned()) {
+            const inactiveReason = target
+                ? 'registry-inactive'
+                : 'no-active-target';
+            const inactive = rememberRemoteRegistryInactiveTarget(inactiveReason);
+            if (inactive.confirmedInactive && isRemoteAgentRegistryOwned()) {
                 await stopRemoteAgentConnection('registry-inactive');
             }
+            const keptManager = inactive.agentKept ? safeRemoteAgentField(remoteAgentState.manager, 160) : '';
+            const keptCandidates = inactive.agentKept ? normalizeRemoteManagerEndpointList(remoteAgentState.managerCandidates, remoteAgentState.manager) : [];
             updateRemoteRegistryFollowerState({
-                status: 'idle',
-                reason: 'no-active-target',
+                status: inactive.agentKept ? 'waiting' : 'idle',
+                reason: inactive.agentKept ? `${inactiveReason}-agent-kept` : inactiveReason,
                 authenticated: true,
                 lastAttemptAt: attemptedAt,
                 lastSuccessAt: attemptedAt,
-                targetEndpoint: '',
-                targetEndpointCandidates: [],
-                targetLeaseId: '',
-                targetNodeId: '',
+                targetEndpoint: keptManager,
+                targetEndpointCandidates: keptCandidates,
+                targetLeaseId: inactive.agentKept ? safeRemoteAgentField(remoteAgentState.leaseId, 128) : '',
+                targetNodeId: inactive.agentKept ? safeRemoteAgentField(remoteAgentState.nodeId, 128) : '',
+                inactiveCount: inactive.count,
+                inactiveElapsedMs: inactive.elapsedMs,
+                agentKept: inactive.agentKept,
                 lastError: ''
             });
             await reportRemoteRegistryFollowerSync({
                 ok: true,
                 skipped: true,
-                reason: 'no-active-target',
+                reason: inactive.agentKept ? `${inactiveReason}-agent-kept` : inactiveReason,
                 trigger,
-                authenticated: true
+                authenticated: true,
+                targetEndpoint: keptManager,
+                targetEndpointCandidates: keptCandidates,
+                targetLeaseId: inactive.agentKept ? remoteAgentState.leaseId : '',
+                targetNodeId: inactive.agentKept ? remoteAgentState.nodeId : '',
+                inactiveCount: inactive.count,
+                inactiveElapsedMs: inactive.elapsedMs,
+                agentKept: inactive.agentKept
             });
             scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_POLL_MS, 'no-target');
             return serializeRemoteRegistryFollowerState();
         }
 
+        resetRemoteRegistryInactiveTargetGrace();
+
         if (isRemoteRegistryTargetSameAsLocalHost(localHub, target)) {
             updateRemoteRegistryFollowerState({
                 status: 'skipped',