@mindexec/cli 0.2.93 → 0.2.94

package/package.json

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

package/remote-hub.js

@@ -77,10 +77,72 @@ function isPrivateIPv4(value) {
         || (parts[0] === 192 && parts[1] === 168);
 }
 
-function getReachableIPv4Candidates() {
+function isPreferredPhysicalInterfaceName(value) {
+    const name = String(value || '').toLowerCase();
+    return /(^|[\s_\-()])((wi[\s_\-]?fi)|wifi|wireless|wlan|ethernet|lan|이더넷|en\d+|eth\d+)(?=$|[\s_\-()])/i.test(name);
+}
+
+function isVirtualInterfaceName(value) {
+    const name = String(value || '').toLowerCase();
+    return /virtual|vethernet|hyper-v|hyperv|vmware|virtualbox|vbox|docker|wsl|container|bluetooth|loopback|npcap|isatap|teredo/i.test(name);
+}
+
+function getIPv4LastOctet(value) {
+    const parts = String(value || '').split('.').map(part => Number(part));
+    if (parts.length !== 4 || parts.some(part => !Number.isInteger(part))) {
+        return -1;
+    }
+
+    return parts[3];
+}
+
+function scoreReachableIPv4Candidate(candidate) {
+    const address = String(candidate?.address || '');
+    const name = String(candidate?.name || '');
+    let score = 0;
+
+    if (isPrivateIPv4(address)) {
+        score += 1000;
+    }
+
+    if (/^192\.168\./.test(address)) {
+        score += 90;
+    } else if (/^10\./.test(address)) {
+        score += 80;
+    } else if (/^172\.(1[6-9]|2\d|3[0-1])\./.test(address)) {
+        score += 70;
+    }
+
+    if (isPreferredPhysicalInterfaceName(name)) {
+        score += 500;
+    }
+
+    if (isVirtualInterfaceName(name)) {
+        score -= 1200;
+    }
+
+    if (/^169\.254\./.test(address)) {
+        score -= 2000;
+    }
+
+    const lastOctet = getIPv4LastOctet(address);
+    if (lastOctet === 1) {
+        score -= 60;
+    } else if (lastOctet === 0 || lastOctet === 255) {
+        score -= 100;
+    }
+
+    if (candidate?.mac && candidate.mac === '00:00:00:00:00:00') {
+        score -= 50;
+    }
+
+    return score;
+}
+
+function getReachableIPv4CandidateEntries() {
     const candidates = [];
     const interfaces = os.networkInterfaces();
-    for (const entries of Object.values(interfaces)) {
+    for (const [name, entries] of Object.entries(interfaces)) {
         for (const entry of entries || []) {
             if (entry?.family !== 'IPv4' || entry.internal) {
                 continue;
@@ -91,13 +153,28 @@ function getReachableIPv4Candidates() {
                 continue;
             }
 
-            candidates.push(address);
+            candidates.push({
+                address,
+                name: safeString(name, 128),
+                mac: safeString(entry.mac, 32),
+                score: 0,
+                virtual: isVirtualInterfaceName(name),
+                preferred: isPreferredPhysicalInterfaceName(name)
+            });
         }
     }
 
     return candidates
-        .sort((left, right) => Number(isPrivateIPv4(right)) - Number(isPrivateIPv4(left)))
-        .filter((address, index, all) => all.indexOf(address) === index);
+        .map(candidate => ({
+            ...candidate,
+            score: scoreReachableIPv4Candidate(candidate)
+        }))
+        .sort((left, right) => right.score - left.score || left.address.localeCompare(right.address))
+        .filter((candidate, index, all) => all.findIndex(item => item.address === candidate.address) === index);
+}
+
+function getReachableIPv4Candidates() {
+    return getReachableIPv4CandidateEntries().map(candidate => candidate.address);
 }
 
 function getReachableIPv4Address() {
@@ -409,7 +486,8 @@ export function createRemoteHub(options = {}) {
     }
 
     function getAgentEndpointRouteInfo() {
-        const candidates = getReachableIPv4Candidates();
+        const candidateDetails = getReachableIPv4CandidateEntries();
+        const candidates = candidateDetails.map(candidate => candidate.address);
         const endpoint = getAgentEndpoint();
         const wildcardWithoutReachableAddress =
             !publicEndpoint
@@ -424,7 +502,8 @@ export function createRemoteHub(options = {}) {
             port: parsed?.port || 0,
             accountRouteReady: reason === 'ok',
             reason,
-            candidates
+            candidates,
+            candidateDetails
         };
     }
 
@@ -574,6 +653,7 @@ export function createRemoteHub(options = {}) {
             agentEndpointAccountRouteReady: routeInfo.accountRouteReady,
             agentEndpointRouteReason: routeInfo.reason,
             agentEndpointCandidates: routeInfo.candidates,
+            agentEndpointCandidateDetails: routeInfo.candidateDetails,
             pairToken: includeSecrets ? pairToken : undefined,
             pairTokenPreview: maskToken(pairToken),
             deviceCount: devices.size,

package/server.js

@@ -2954,10 +2954,12 @@ async function startRemoteAgentConnection(options = {}) {
     const engine = normalizeRemoteAgentEngine(options.engine);
 
     if (!manager) {
+        logWarn('remote', 'managed RemoteAgent connect rejected: invalid manager endpoint');
         return { ok: false, error: 'invalid-manager-endpoint', agent: serializeRemoteAgentState() };
     }
 
     if (!pairToken) {
+        logWarn('remote', `managed RemoteAgent connect rejected: missing pair token ${formatKeyValue('manager', manager)}`);
         return { ok: false, error: 'missing-pair-token', agent: serializeRemoteAgentState() };
     }
 
@@ -3056,6 +3058,7 @@ async function startRemoteAgentConnection(options = {}) {
     const exitedEarly = await waitForRemoteAgentEarlyExit(child);
     if (exitedEarly) {
         const error = formatRemoteAgentFailureSummary();
+        logWarn('remote', `managed RemoteAgent exited during startup ${formatKeyValue('manager', manager)} ${formatKeyValue('error', error)}`);
         return { ok: false, error, agent: serializeRemoteAgentState() };
     }
 
@@ -7615,14 +7618,18 @@ app.get('/api/remote/agent/status', (req, res) => {
 app.post('/api/remote/agent/connect', async (req, res) => {
     res.setHeader('Cache-Control', 'no-store');
     try {
+        const requestedManager = normalizeRemoteManagerEndpoint(req.body?.manager || req.body?.managerEndpoint);
         const result = await startRemoteAgentConnection({
-            manager: req.body?.manager || req.body?.managerEndpoint,
+            manager: requestedManager,
             pairToken: req.body?.pairToken || req.body?.pair,
             leaseId: req.body?.leaseId,
             nodeId: req.body?.nodeId,
             engine: req.body?.engine,
             source: req.body?.source || 'registry'
         });
+        if (!result.ok) {
+            logWarn('remote', `managed RemoteAgent connect failed ${formatKeyValue('manager', requestedManager || 'invalid')} ${formatKeyValue('error', result.error || 'unknown')}`);
+        }
         res.status(result.ok ? 200 : 400).json(result);
     } catch (err) {
         logError('remote', 'managed RemoteAgent connect failed.', err);