@mindexec/cli 0.2.92 → 0.2.94

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.92",
+  "version": "0.2.94",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -47,7 +47,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@mindexec/remote": "^0.1.14",
+    "@mindexec/remote": "^0.1.15",
     "@openai/codex-sdk": "^0.137.0",
     "chokidar": "^3.6.0",
     "cors": "^2.8.5",

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

@@ -2732,6 +2732,7 @@ const remoteHub = createRemoteHub({
 });
 
 const REMOTE_AGENT_STDIO_TAIL_CHARS = 12000;
+const REMOTE_AGENT_EARLY_EXIT_MS = 1200;
 const REMOTE_AGENT_DEFAULT_ENGINE = 'auto';
 let remoteAgentState = createRemoteAgentIdleState();
 
@@ -2778,6 +2779,71 @@ function appendRemoteAgentOutput(stream, chunk) {
     remoteAgentState.updatedAt = new Date().toISOString();
 }
 
+function summarizeRemoteAgentOutput(value, maxLength = 700) {
+    const text = String(value || '').replace(/\s+/g, ' ').trim();
+    if (text.length <= maxLength) {
+        return text;
+    }
+
+    return `...${text.slice(text.length - maxLength + 3)}`;
+}
+
+function formatRemoteAgentFailureSummary(agent = remoteAgentState) {
+    const details = [];
+    if (agent.lastError) {
+        details.push(agent.lastError);
+    } else if (agent.signal) {
+        details.push(`signal:${agent.signal}`);
+    } else if (Number.isFinite(agent.exitCode)) {
+        details.push(`exit:${agent.exitCode}`);
+    }
+
+    const stderr = summarizeRemoteAgentOutput(agent.stderrTail);
+    if (stderr) {
+        details.push(`stderr=${stderr}`);
+    }
+
+    const stdout = summarizeRemoteAgentOutput(agent.stdoutTail);
+    if (stdout) {
+        details.push(`stdout=${stdout}`);
+    }
+
+    return details.join(' | ') || 'remote-agent-failed';
+}
+
+function waitForRemoteAgentEarlyExit(child, settleMs = REMOTE_AGENT_EARLY_EXIT_MS) {
+    return new Promise(resolve => {
+        if (!child || child.exitCode !== null || child.killed) {
+            resolve(true);
+            return;
+        }
+
+        let settled = false;
+        let timer = null;
+        const cleanup = () => {
+            if (timer) {
+                clearTimeout(timer);
+            }
+            child.off('exit', onExit);
+            child.off('error', onError);
+        };
+        const finish = value => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            resolve(value);
+        };
+        const onExit = () => finish(true);
+        const onError = () => finish(true);
+
+        child.once('exit', onExit);
+        child.once('error', onError);
+        timer = setTimeout(() => finish(false), settleMs);
+    });
+}
+
 function normalizeRemoteAgentEngine(value) {
     const engine = String(value || REMOTE_AGENT_DEFAULT_ENGINE).trim().toLowerCase();
     if (engine === 'fast' || engine === 'csharp' || engine === 'c#') {
@@ -2888,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() };
     }
 
@@ -2961,6 +3029,7 @@ async function startRemoteAgentConnection(options = {}) {
         remoteAgentState.status = 'failed';
         remoteAgentState.lastError = err?.message || String(err);
         remoteAgentState.updatedAt = new Date().toISOString();
+        logWarn('remote', `managed RemoteAgent failed: ${formatRemoteAgentFailureSummary()}`);
         emitBridgeEvent('RemoteAgentFailed', serializeRemoteAgentState());
     });
     child.once('exit', (code, signal) => {
@@ -2972,6 +3041,11 @@ async function startRemoteAgentConnection(options = {}) {
         if (code !== 0 && !remoteAgentState.lastError) {
             remoteAgentState.lastError = signal ? `signal:${signal}` : `exit:${code}`;
         }
+        if (remoteAgentState.status === 'failed') {
+            logWarn('remote', `managed RemoteAgent failed: ${formatRemoteAgentFailureSummary()}`);
+        } else {
+            logEvent('remote', `managed RemoteAgent exited ${formatKeyValue('code', code ?? 0)}`, 'remote');
+        }
         emitBridgeEvent(remoteAgentState.status === 'exited' ? 'RemoteAgentExited' : 'RemoteAgentFailed', serializeRemoteAgentState());
     });
 
@@ -2981,6 +3055,13 @@ async function startRemoteAgentConnection(options = {}) {
         'remote');
     emitBridgeEvent('RemoteAgentStarted', serializeRemoteAgentState());
 
+    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() };
+    }
+
     return { ok: true, alreadyRunning: false, agent: serializeRemoteAgentState() };
 }
 
@@ -7537,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);