@mindexec/cli 0.2.188 → 0.2.189

package/package.json

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

package/remote-hub.js

@@ -875,7 +875,7 @@ export function createRemoteHub(options = {}) {
     const publicEndpoint = safeString(env.MINDEXEC_REMOTE_PUBLIC_ENDPOINT || env.REMOTE_HUB_PUBLIC_ENDPOINT, 256);
     const publicHost = safeString(env.MINDEXEC_REMOTE_PUBLIC_HOST || env.REMOTE_HUB_PUBLIC_HOST, 128);
     const pairToken = safeString(
-        env.REMOTE_HUB_PAIR_TOKEN || env.MINDEXEC_REMOTE_PAIR_TOKEN || crypto.randomBytes(6).toString('hex'),
+        options.pairToken || env.REMOTE_HUB_PAIR_TOKEN || env.MINDEXEC_REMOTE_PAIR_TOKEN || crypto.randomBytes(6).toString('hex'),
         256);
 
     const devices = new Map();
@@ -1043,7 +1043,9 @@ export function createRemoteHub(options = {}) {
         const routeInfo = getAgentEndpointRouteInfo();
         hostTarget = {
             nodeId,
-            leaseId: activeSameNode && previous?.leaseId ? previous.leaseId : crypto.randomUUID(),
+            leaseId: activeSameNode && previous?.leaseId
+                ? previous.leaseId
+                : (safeString(options.leaseId, 128) || crypto.randomUUID()),
             hostInstanceId,
             endpoint: routeInfo.endpoint,
             endpointCandidates: routeInfo.candidates,

package/scripts/remote-hub-identity-smoke.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, rm } from 'node:fs/promises';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const BRIDGE_TOKEN = 'remote-hub-identity-smoke-token';
+const LOCAL_BRIDGE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function findFreePort() {
+    return await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            server.close(() => resolve(port));
+        });
+    });
+}
+
+async function fetchJson(url, options = {}) {
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            'X-Bridge-Token': BRIDGE_TOKEN,
+            ...(options.headers || {})
+        }
+    });
+    let payload = null;
+    try {
+        payload = await response.json();
+    } catch {
+        // Ignore non-JSON diagnostics.
+    }
+    return { ok: response.ok, status: response.status, payload };
+}
+
+function spawnBridge({ bridgePort, remoteHubPort, workspacePath, authDataRoot, label }) {
+    const child = spawn(process.execPath, ['server.js'], {
+        cwd: LOCAL_BRIDGE_DIR,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        env: {
+            ...process.env,
+            BRIDGE_PORT: String(bridgePort),
+            BRIDGE_TOKEN,
+            BRIDGE_REQUIRE_TOKEN: '1',
+            MINDEXEC_REMOTE_HUB: '1',
+            MINDEXEC_REMOTE_REGISTRY_FOLLOWER: '0',
+            REMOTE_HUB_HOST: '127.0.0.1',
+            REMOTE_HUB_PORT: String(remoteHubPort),
+            WORKSPACE_PATH: workspacePath,
+            MINDEXEC_AUTH_DATA_ROOT: authDataRoot,
+            REMOTE_HUB_PAIR_TOKEN: '',
+            MINDEXEC_REMOTE_PAIR_TOKEN: '',
+            MINDEXEC_BRIDGE_INSTANCE_ID: '',
+            NO_COLOR: '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 = () => `${label} stdout=${stdout}\n${label} stderr=${stderr}`;
+    const stop = async () => {
+        if (child.exitCode === null && !child.killed) {
+            child.kill('SIGTERM');
+            await Promise.race([exitPromise, wait(3000)]);
+            if (child.exitCode === null && !child.killed) {
+                child.kill('SIGKILL');
+            }
+        }
+    };
+
+    return {
+        baseUrl: `http://127.0.0.1:${bridgePort}`,
+        details,
+        stop
+    };
+}
+
+async function waitForStatus(bridge) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 30000) {
+        try {
+            const result = await fetchJson(`${bridge.baseUrl}/api/remote/status`);
+            if (result.ok && result.payload?.started === true) {
+                return result.payload;
+            }
+        } catch {
+            // Bridge still starting.
+        }
+        await wait(100);
+    }
+
+    throw new Error(`Timed out waiting for bridge status.\n${bridge.details()}`);
+}
+
+async function runOnce({ workspacePath, authDataRoot, label }) {
+    const bridgePort = await findFreePort();
+    const remoteHubPort = await findFreePort();
+    const bridge = spawnBridge({ bridgePort, remoteHubPort, workspacePath, authDataRoot, label });
+    try {
+        return await waitForStatus(bridge);
+    } finally {
+        await bridge.stop();
+    }
+}
+
+const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'mindexec-remote-hub-identity-smoke-'));
+try {
+    const workspacePath = path.join(tempRoot, 'workspace');
+    const authDataRoot = path.join(tempRoot, 'auth');
+    await mkdir(workspacePath, { recursive: true });
+    await mkdir(authDataRoot, { recursive: true });
+
+    const first = await runOnce({ workspacePath, authDataRoot, label: 'first' });
+    const second = await runOnce({ workspacePath, authDataRoot, label: 'second' });
+
+    assert.ok(first.pairToken, JSON.stringify(first));
+    assert.ok(first.hostInstanceId, JSON.stringify(first));
+    assert.equal(second.pairToken, first.pairToken);
+    assert.equal(second.hostInstanceId, first.hostInstanceId);
+    assert.match(first.hostInstanceId, /^bridge-[a-f0-9]{32}$/);
+
+    console.log('RemoteHub identity persistence smoke OK');
+} finally {
+    await rm(tempRoot, { recursive: true, force: true });
+}

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

@@ -72,13 +72,13 @@ async function waitFor(predicate, timeoutMs, label) {
     throw new Error(`Timed out waiting for ${label}${lastError ? `: ${lastError.message}` : ''}.`);
 }
 
-function createRegistryTarget({ endpoint, endpointCandidates, leaseId, active = true }) {
+function createRegistryTarget({ endpoint, endpointCandidates, leaseId, active = true, pairToken = PAIR_TOKEN }) {
     return {
         user_id: USER_ID,
         active,
         endpoint,
         endpoint_candidates: endpointCandidates,
-        pair_token: PAIR_TOKEN,
+        pair_token: pairToken,
         lease_id: leaseId,
         node_id: 'remote-registry-follower-node',
         host_instance_id: `host-${leaseId}`,

package/server.js

@@ -8,7 +8,7 @@
 
 import express from 'express';
 import cors from 'cors';
-import { promises as fs, readFileSync, statSync, createReadStream, chmodSync } from 'fs';
+import { promises as fs, readFileSync, statSync, createReadStream, chmodSync, mkdirSync, writeFileSync } from 'fs';
 import path from 'path';
 import { exec, spawn, spawnSync, execFile } from 'child_process';
 import { promisify } from 'util';
@@ -32,10 +32,14 @@ const { normalizePort, releaseBridgePort } = portGuard;
 const app = express();
 const PORT = normalizePort(process.env.BRIDGE_PORT);
 const BRIDGE_ROOT = path.dirname(fileURLToPath(import.meta.url));
-const PACKAGE_INFO = JSON.parse(readFileSync(path.join(BRIDGE_ROOT, 'package.json'), 'utf8'));
+const PACKAGE_INFO = JSON.parse(readFileSync(path.join(BRIDGE_ROOT, 'package.json'), 'utf8'));
 const BRIDGE_PACKAGE_NAME = String(PACKAGE_INFO.name || '@mindexec/cli');
 const BRIDGE_VERSION = String(PACKAGE_INFO.version || '0.1.0');
-const BRIDGE_INSTANCE_ID = String(process.env.MINDEXEC_BRIDGE_INSTANCE_ID || crypto.randomUUID()).trim() || crypto.randomUUID();
+const REMOTE_HUB_IDENTITY_FILE_PREFIX = 'remote-hub-identity';
+const REMOTE_HUB_IDENTITY_SCOPE = createRemoteHubIdentityScope();
+const REMOTE_HUB_IDENTITY = loadOrCreateRemoteHubIdentity(REMOTE_HUB_IDENTITY_SCOPE);
+const BRIDGE_INSTANCE_ID = String(process.env.MINDEXEC_BRIDGE_INSTANCE_ID || REMOTE_HUB_IDENTITY.hostInstanceId || crypto.randomUUID()).trim() || crypto.randomUUID();
+const REMOTE_HUB_PAIR_TOKEN = String(process.env.REMOTE_HUB_PAIR_TOKEN || process.env.MINDEXEC_REMOTE_PAIR_TOKEN || REMOTE_HUB_IDENTITY.pairToken || crypto.randomBytes(18).toString('hex')).trim() || crypto.randomBytes(18).toString('hex');
 const TREE_SITTER_GRAMMAR_DIR = path.join(BRIDGE_ROOT, 'tree-sitter-grammars');
 const VERBOSE_CODEX_TRACE = /^(1|true|yes|on)$/i.test(String(process.env.BRIDGE_VERBOSE_CODEX || ''));
 const COLOR_LOGS_ENABLED = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
@@ -404,22 +408,95 @@ function looksLikeWorkspaceRoot(candidatePath) {
         || pathExistsSync(path.join(normalizedPath, 'MindExecution.Shared'));
 }
 
-function resolveInitialWorkspacePath() {
-    const envWorkspacePath = String(process.env.WORKSPACE_PATH || '').trim();
-    if (envWorkspacePath) {
-        return envWorkspacePath;
-    }
+function resolveInitialWorkspacePath() {
+    const envWorkspacePath = String(process.env.WORKSPACE_PATH || '').trim();
+    if (envWorkspacePath) {
+        return envWorkspacePath;
+    }
 
     const bridgeSiblingWorkspace = path.resolve(BRIDGE_ROOT, '..');
     if (looksLikeWorkspaceRoot(bridgeSiblingWorkspace)) {
         return bridgeSiblingWorkspace;
     }
-
-    return path.join(os.homedir(), 'Documents', 'MindExecution');
-}
-
-// Default workspace path
-const DEFAULT_WORKSPACE = resolveInitialWorkspacePath();
+
+    return path.join(os.homedir(), 'Documents', 'MindExecution');
+}
+
+function createRemoteHubIdentityScope() {
+    const initialWorkspace = path.resolve(resolveInitialWorkspacePath());
+    const user = (() => {
+        try {
+            return os.userInfo().username || '';
+        } catch {
+            return '';
+        }
+    })();
+    return [
+        initialWorkspace.toLowerCase(),
+        os.hostname().toLowerCase(),
+        user.toLowerCase()
+    ].join('\n');
+}
+
+function createRemoteHubIdentityHash(scope) {
+    return crypto
+        .createHash('sha256')
+        .update(String(scope || 'mindexec-remote-hub'))
+        .digest('hex');
+}
+
+function getStableRemoteHubIdentityPath(scope) {
+    const scopeHash = createRemoteHubIdentityHash(scope).slice(0, 16);
+    return path.join(resolveAuthDataRoot(), `${REMOTE_HUB_IDENTITY_FILE_PREFIX}-${scopeHash}.json`);
+}
+
+function createStableRemoteHubInstanceId(scope) {
+    return `bridge-${createRemoteHubIdentityHash(scope).slice(0, 32)}`;
+}
+
+function loadOrCreateRemoteHubIdentity(scope) {
+    const identityPath = getStableRemoteHubIdentityPath(scope);
+    let existing = null;
+    try {
+        existing = JSON.parse(readFileSync(identityPath, 'utf8'));
+    } catch (err) {
+        if (err?.code !== 'ENOENT') {
+            // Ignore corrupt identity files and replace them with a fresh stable shape.
+        }
+    }
+
+    const hostInstanceId = String(existing?.hostInstanceId || '').trim()
+        || createStableRemoteHubInstanceId(scope);
+    const pairToken = String(existing?.pairToken || '').trim()
+        || crypto.randomBytes(18).toString('hex');
+    const next = {
+        version: 1,
+        scopeHash: createRemoteHubIdentityHash(scope).slice(0, 16),
+        hostInstanceId,
+        pairToken
+    };
+    const changed = existing?.version !== next.version
+        || existing?.scopeHash !== next.scopeHash
+        || existing?.hostInstanceId !== next.hostInstanceId
+        || existing?.pairToken !== next.pairToken;
+
+    if (changed) {
+        try {
+            mkdirSync(path.dirname(identityPath), { recursive: true });
+            writeFileSync(identityPath, `${JSON.stringify(next, null, 2)}\n`, {
+                encoding: 'utf8',
+                mode: 0o600
+            });
+        } catch (err) {
+            console.warn(`[RemoteHubIdentity] Failed to persist identity: ${err?.message || err}`);
+        }
+    }
+
+    return next;
+}
+
+// Default workspace path
+const DEFAULT_WORKSPACE = resolveInitialWorkspacePath();
 let workspacePath = DEFAULT_WORKSPACE;
 const browserSessions = new Map();
 let currentBrowserSessionId = null;
@@ -3363,7 +3440,8 @@ const remoteHub = createRemoteHub({
     emitFrame: broadcastRemoteBinaryFrame,
     managerPackage: BRIDGE_PACKAGE_NAME,
     managerVersion: BRIDGE_VERSION,
-    hostInstanceId: BRIDGE_INSTANCE_ID
+    hostInstanceId: BRIDGE_INSTANCE_ID,
+    pairToken: REMOTE_HUB_PAIR_TOKEN
 });
 
 const REMOTE_AGENT_STDIO_TAIL_CHARS = 12000;
@@ -5841,6 +5919,23 @@ function isRemoteRegistryTargetSameAsLocalHost(localHub, target) {
         && localHostInstanceId.toLowerCase() === String(target.hostInstanceId).toLowerCase();
 }
 
+function isRemoteRegistryTargetEndpointLocal(localHub, target) {
+    const localEndpoints = normalizeRemoteManagerEndpointList(
+        localHub?.agentEndpointCandidates,
+        localHub?.agentEndpoint,
+        localHub?.hostTargetEndpointCandidates,
+        localHub?.hostTargetEndpoint);
+    const targetEndpoints = normalizeRemoteManagerEndpointList(
+        target?.endpointCandidates,
+        target?.endpoint);
+    if (localEndpoints.length === 0 || targetEndpoints.length === 0) {
+        return false;
+    }
+
+    const localSet = new Set(localEndpoints.map(endpoint => endpoint.toLowerCase()));
+    return targetEndpoints.some(endpoint => localSet.has(endpoint.toLowerCase()));
+}
+
 async function fetchRemoteRegistryTarget(config, session) {
     const url = new URL('/rest/v1/remote_host_targets', config.url);
     url.searchParams.set('select', '*');
@@ -6609,6 +6704,54 @@ async function runRemoteRegistryFollowerOnce(trigger = 'timer') {
         await ensureRemoteRegistryRealtimeSubscription(config, session, trigger);
         const target = await fetchRemoteRegistryTarget(config, session);
 
+        if (localHub?.hostTargetActive !== true
+            && target?.active === true
+            && !isRemoteRegistryTargetExpired(target)
+            && isRemoteRegistryTargetEndpointLocal(localHub, target)) {
+            const revived = remoteHub.setHostTarget({
+                enabled: true,
+                nodeId: target.nodeId,
+                leaseId: target.leaseId,
+                leaseMs: REMOTE_HOST_TARGET_LEASE_MS
+            });
+            if (revived?.ok === true) {
+                if (isRemoteAgentProcessRunning()) {
+                    await stopRemoteAgentConnection('local-host-target-revived');
+                }
+                const revivedHub = remoteHub.getStatus({ includeSecrets: true });
+                const registry = await publishLocalRemoteHostTargetToRegistry(revivedHub, { takeover: true });
+                updateRemoteRegistryFollowerState({
+                    status: 'skipped',
+                    reason: 'local-monitor-host-revived',
+                    authenticated: true,
+                    lastAttemptAt: attemptedAt,
+                    lastSuccessAt: attemptedAt,
+                    targetEndpoint: registry.endpoint || target.endpoint,
+                    targetEndpointCandidates: registry.endpointCandidates?.length ? registry.endpointCandidates : target.endpointCandidates,
+                    targetLeaseId: revivedHub.hostTargetLeaseId,
+                    targetNodeId: revivedHub.hostTargetNodeId,
+                    lastError: registry.ok || isRemoteHostTargetRenewSoftSkipReason(registry.reason) ? '' : (registry.reason || 'host-target-republish-failed')
+                });
+                await reportRemoteRegistryFollowerSync({
+                    ok: registry.ok !== false,
+                    skipped: true,
+                    reason: registry.ok ? 'local-monitor-host-revived' : `local-monitor-host-revived-${registry.reason || 'registry-publish-failed'}`,
+                    trigger,
+                    authenticated: true,
+                    localHostTargetActive: true,
+                    targetActive: true,
+                    targetEndpoint: registry.endpoint || target.endpoint,
+                    targetEndpointCandidates: registry.endpointCandidates?.length ? registry.endpointCandidates : target.endpointCandidates,
+                    targetLeaseId: revivedHub.hostTargetLeaseId,
+                    targetNodeId: revivedHub.hostTargetNodeId,
+                    targetExpiresAt: revivedHub.hostTargetExpiresAt
+                });
+                scheduleRemoteHostTargetRenewWake('local-host-revived');
+                scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_POLL_MS, 'local-host-revived');
+                return serializeRemoteRegistryFollowerState();
+            }
+        }
+
         if (localHub?.hostTargetActive === true) {
             resetRemoteRegistryInactiveTargetGrace();
             if (target?.active === true

package/wwwroot/_framework/blazor.boot.json

@@ -1,7 +1,7 @@
 {
   "mainAssemblyName": "MindExecution.Web",
   "resources": {
-    "hash": "sha256-wO/y6PhLVnM+OKb9a+DZH6St+JWnCdBxHFafo2120Dc=",
+    "hash": "sha256-e0n1RLLtx0J+Ffwaa005iSuhZrI+q9OH/azLs6RFJdE=",
     "fingerprinting": {
       "Google.Protobuf.9h59ukbel7.dll": "Google.Protobuf.dll",
       "Markdig.d1j7v41cl1.dll": "Markdig.dll",
@@ -132,7 +132,7 @@
       "MindExecution.Plugins.PlanMaster.xt4y5gj8yw.dll": "MindExecution.Plugins.PlanMaster.dll",
       "MindExecution.Plugins.YouTube.kz0lju94md.dll": "MindExecution.Plugins.YouTube.dll",
       "MindExecution.Shared.7rwzquw93z.dll": "MindExecution.Shared.dll",
-      "MindExecution.Web.hsle161c7m.dll": "MindExecution.Web.dll",
+      "MindExecution.Web.7on7otq3do.dll": "MindExecution.Web.dll",
       "dotnet.js": "dotnet.js",
       "dotnet.native.qc8g39g30v.js": "dotnet.native.js",
       "dotnet.native.boem75ye5i.wasm": "dotnet.native.wasm",
@@ -284,7 +284,7 @@
       "MindExecution.Plugins.Concept.3mpew6v5hz.dll": "sha256-K6GVU9mkcEQatq6shNKDO9xtahvaLBOhrIOzYda8lAI=",
       "MindExecution.Plugins.PlanMaster.xt4y5gj8yw.dll": "sha256-Cx47VicQk4brENQ4Y/9SMJ81sawy9AkvnrxuDnqoAYI=",
       "MindExecution.Shared.7rwzquw93z.dll": "sha256-bZ2rx8V2aQu7Ff4nl/mgbEOg3P/3YNjMmFpIXWcu3cQ=",
-      "MindExecution.Web.hsle161c7m.dll": "sha256-0e786DmgqKdqucNj3NloG//KBor6Wqoeci7UHtgdyaA="
+      "MindExecution.Web.7on7otq3do.dll": "sha256-l3+AdCxkmuRdpmgy+hg5tQBsNft43p/QZ1jFKlJAz2A="
     },
     "lazyAssembly": {
       "MindExecution.Plugins.Admin.29mytzdaun.dll": "sha256-2mHPbTPcHCi1xPuk3dNMVWxn42xZFUZ3QFhm3xIV/6E=",

package/wwwroot/service-worker-assets.js

@@ -1,5 +1,5 @@
 self.assetsManifest = {
-    "version":  "gYWza81R",
+    "version":  "2A2jXlS/",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -446,8 +446,8 @@
                        "url":  "_framework/MindExecution.Shared.7rwzquw93z.dll"
                    },
                    {
-                       "hash":  "sha256-0e786DmgqKdqucNj3NloG//KBor6Wqoeci7UHtgdyaA=",
-                       "url":  "_framework/MindExecution.Web.hsle161c7m.dll"
+                       "hash":  "sha256-l3+AdCxkmuRdpmgy+hg5tQBsNft43p/QZ1jFKlJAz2A=",
+                       "url":  "_framework/MindExecution.Web.7on7otq3do.dll"
                    },
                    {
                        "hash":  "sha256-IsZJ91/OW+fHzNqIgEc7Y072ns8z9dGritiSyvR9Wgc=",
@@ -770,7 +770,7 @@
                        "url":  "_framework/Websocket.Client.vapounvmnl.dll"
                    },
                    {
-                       "hash":  "sha256-qmh1kbyeNhh7PgQWPBUrFh5bC+YayDSQBAYA92Yo4VA=",
+                       "hash":  "sha256-/VqlSl0soIWMyeyUaHS8719wDwRJJLAk6Wh9TJo4PVU=",
                        "url":  "_framework/blazor.boot.json"
                    },
                    {

package/wwwroot/service-worker.js

@@ -1,4 +1,4 @@
-/* Manifest version: gYWza81R */
+/* Manifest version: 2A2jXlS/ */
 // Hosted deployments should prefer the network over stale offline caches.
 // This service worker immediately clears old Blazor offline caches and unregisters itself.