open-agents-ai 0.103.68 → 0.103.70

package/dist/index.js

@@ -12130,6 +12130,26 @@ const blockedPeers = [];
 // Both peers connect to wss://demo.nats.io:8443, so NATS request/reply bridges the gap.
 var _natsConn = null;
 var _natsCodec = null;
+var _tokensByRequest = {};
+
+// Check if an error is a connectivity/dial failure (should trigger NATS fallback)
+// vs an application-level error (auth rejected, capability not found \u2014 no point retrying via NATS)
+function isDialFailure(errMsg) {
+  var appErrors = ['unauthorized', 'capability not found', 'not registered', 'auth rejected'];
+  var lower = errMsg.toLowerCase();
+  for (var i = 0; i < appErrors.length; i++) {
+    if (lower.includes(appErrors[i])) return false;
+  }
+  // Any network/transport error should fall back to NATS
+  return lower.includes('multiaddrs failed') || lower.includes('econnrefused') ||
+    lower.includes('etimedout') || lower.includes('dial to peer') ||
+    lower.includes('no route') || lower.includes('circuit relay') ||
+    lower.includes('stream was reset') || lower.includes('timeout') ||
+    lower.includes('connection reset') || lower.includes('ehostunreach') ||
+    lower.includes('enetunreach') || lower.includes('peer not reachable') ||
+    lower.includes('dial error') || lower.includes('aborted') ||
+    lower.includes('connection refused');
+}
 
 function writeStatus(extra = {}) {
   const caps = typeof nexus.getRegisteredCapabilities === 'function'
@@ -12293,7 +12313,7 @@ async function handleCmd(cmd) {
           var qpcErrMsg = qpcErr.message || String(qpcErr);
           dlog('query_peer_caps: ERROR ' + qpcErrMsg);
           // NATS fallback for peer cap discovery across NAT
-          if (_natsConn && _natsCodec && qpcErrMsg.includes('multiaddrs failed')) {
+          if (_natsConn && _natsCodec && isDialFailure(qpcErrMsg)) {
             dlog('query_peer_caps: trying NATS relay fallback');
             try {
               var _qpcNatsSubject = 'nexus.invoke.' + String(qpcPeerId);
@@ -12341,8 +12361,8 @@ async function handleCmd(cmd) {
         } catch (invokeErr) {
           var invokeErrMsg = invokeErr.message || String(invokeErr);
           dlog('invoke_capability: ERROR ' + invokeErrMsg);
-          // NATS fallback \u2014 if direct dial failed (NAT), retry via NATS relay
-          if (_natsConn && _natsCodec && invokeErrMsg.includes('multiaddrs failed')) {
+          // NATS fallback \u2014 if direct dial failed (NAT/timeout/refused), retry via NATS relay
+          if (_natsConn && _natsCodec && isDialFailure(invokeErrMsg)) {
             dlog('invoke_capability: trying NATS relay fallback for ' + peerId.slice(0, 20));
             try {
               var _icNatsSubject = 'nexus.invoke.' + peerId;
@@ -12420,8 +12440,8 @@ async function handleCmd(cmd) {
           } catch (riErr) {
             var riErrMsg = riErr.message || String(riErr);
             dlog('remote_infer: ERROR (explicit peer) ' + riErrMsg);
-            // NATS fallback \u2014 if direct dial failed (NAT/firewall), retry via NATS relay
-            if (_natsConn && _natsCodec && riErrMsg.includes('multiaddrs failed')) {
+            // NATS fallback \u2014 if direct dial failed (NAT/firewall/timeout), retry via NATS relay
+            if (_natsConn && _natsCodec && isDialFailure(riErrMsg)) {
               dlog('remote_infer: trying NATS relay fallback for ' + riTargetPeer.slice(0, 20));
               try {
                 var _riNatsSubject = 'nexus.invoke.' + riTargetPeer;
@@ -12488,6 +12508,36 @@ async function handleCmd(cmd) {
           }
           dlog('remote_infer: auto-discover took ' + (Date.now() - discStart) + 'ms');
 
+          // If libp2p auto-discover failed, try NATS relay against discovered peers from cache
+          if (!riResult && _natsConn && _natsCodec) {
+            try {
+              var _dpFile = join(nexusDir, 'discovered-peers.json');
+              if (existsSync(_dpFile)) {
+                var _dpData = JSON.parse(readFileSync(_dpFile, 'utf8'));
+                var _dpPeers = Object.keys(_dpData).filter(function(p) { return p.startsWith('12D3KooW'); });
+                dlog('remote_infer: trying NATS relay on ' + _dpPeers.length + ' cached peers');
+                for (var _dpi = 0; _dpi < _dpPeers.length && !riResult; _dpi++) {
+                  var _dpPid = _dpPeers[_dpi];
+                  try {
+                    var _dpSubject = 'nexus.invoke.' + _dpPid;
+                    var _dpPayload = JSON.stringify({ capability: riCapName, input: riData, from: nexus.peerId || '' });
+                    var _dpResp = await _natsConn.request(_dpSubject, _natsCodec.encode(_dpPayload), { timeout: 180000 });
+                    var _dpResult = JSON.parse(_natsCodec.decode(_dpResp.data));
+                    if (_dpResult && !_dpResult.error) {
+                      riResult = _dpResult;
+                      riTargetPeer = _dpPid;
+                      dlog('remote_infer: SUCCESS via NATS relay peer ' + _dpPid.slice(0, 20));
+                    }
+                  } catch (_dpErr) {
+                    dlog('remote_infer: NATS peer ' + _dpPid.slice(0, 20) + ' failed: ' + (_dpErr.message || _dpErr));
+                  }
+                }
+              }
+            } catch (_dpCacheErr) {
+              dlog('remote_infer: NATS discovery cache error: ' + (_dpCacheErr.message || _dpCacheErr));
+            }
+          }
+
           if (!riResult) {
             writeResp(id, { ok: false, output: 'No peer found with capability: ' + riCapName + '. Ensure a provider is running expose with model ' + riModel });
             return;
@@ -13100,6 +13150,12 @@ async function handleCmd(cmd) {
         // Register system_metrics capability \u2014 returns CPU/GPU/memory utilization
         if (typeof nexus.registerCapability === 'function') {
           nexus.registerCapability('system_metrics', async (request, stream) => {
+            // Stream safety wrapper \u2014 prevents unguarded writes after consumer disconnects
+            var smStreamClosed = false;
+            async function smWrite(msg) {
+              if (smStreamClosed) return;
+              try { await stream.write(msg); } catch { smStreamClosed = true; }
+            }
             // Collect input via stream data events (auth_key arrives in invoke.chunk, NOT invoke.open)
             var smDataChunks = [];
             var smInputDone = false;
@@ -13113,7 +13169,7 @@ async function handleCmd(cmd) {
             });
 
             // Accept invocation so consumer sends data
-            await stream.write({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: true });
+            await smWrite({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: true });
 
             // Wait briefly for data (auth key arrives in chunk)
             var smWait = 0;
@@ -13138,9 +13194,9 @@ async function handleCmd(cmd) {
               }
               if (smAuthKey !== exposeAuthKey) {
                 dlog('system_metrics: auth REJECTED from ' + (request.from || 'unknown'));
-                await stream.write({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'error', data: 'Unauthorized' });
-                await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
-                stream.close();
+                await smWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'error', data: 'Unauthorized' });
+                await smWrite({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
+                try { stream.close(); } catch {}
                 return;
               }
               dlog('system_metrics: auth OK');
@@ -13175,13 +13231,13 @@ async function handleCmd(cmd) {
                 gpu: gpuInfo,
                 timestamp: new Date().toISOString(),
               };
-              await stream.write({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'result', data: JSON.stringify(metricsPayload) });
-              await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: JSON.stringify(metricsPayload).length } });
+              await smWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'result', data: JSON.stringify(metricsPayload) });
+              await smWrite({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: JSON.stringify(metricsPayload).length } });
             } catch (me) {
-              await stream.write({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'error', data: 'metrics error: ' + me.message });
-              await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
+              await smWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'error', data: 'metrics error: ' + me.message });
+              await smWrite({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
             }
-            stream.close();
+            try { stream.close(); } catch {}
           });
           dlog('system_metrics capability registered');
         }
@@ -13380,7 +13436,6 @@ process.on('unhandledRejection', (reason) => {
     // The nexus library fires this hook AFTER handler returns, so it has the correct
     // peerId from connection context. We stash token data per requestId so the hook
     // can merge them into one complete record written to metering.jsonl.
-    var _tokensByRequest = {};
     try {
       if (nexus.metering && typeof nexus.metering.addHook === 'function') {
         nexus.metering.addHook(function(record) {
@@ -13532,25 +13587,39 @@ process.on('unhandledRejection', (reason) => {
                 continue;
               }
 
-              // Create mock stream handle that captures the handler's output
+              // Create mock stream handle that captures the handler's output.
+              // Uses retroactive delivery: if handler registers onData after data is
+              // already queued, deliver immediately. Eliminates timing race.
               var _nResults = [];
-              var _nHandleDone = false;
+              var _nDataCbs = [];
+              var _nDataDelivered = false;
               var _nHandle = {
                 write: async function(msg) {
                   if (msg && msg.type === 'invoke.event') _nResults.push(msg);
-                  if (msg && msg.type === 'invoke.done') _nHandleDone = true;
                 },
                 onData: function(cb) {
-                  // Deliver input data asynchronously after handler registers its listener
-                  setTimeout(function() {
+                  if (_nDataDelivered) {
+                    // Data already flushed \u2014 deliver retroactively
                     try {
                       cb({ type: 'invoke.chunk', data: _nInputStr, seq: 0 });
                       cb({ type: 'invoke.done' });
                     } catch {}
-                  }, 5);
+                  } else {
+                    _nDataCbs.push(cb);
+                  }
                 },
                 close: function() {},
               };
+              // Flush input data to any registered onData listeners after 50ms
+              setTimeout(function() {
+                _nDataDelivered = true;
+                for (var _di = 0; _di < _nDataCbs.length; _di++) {
+                  try {
+                    _nDataCbs[_di]({ type: 'invoke.chunk', data: _nInputStr, seq: 0 });
+                    _nDataCbs[_di]({ type: 'invoke.done' });
+                  } catch {}
+                }
+              }, 50);
 
               var _nRequest = {
                 type: 'invoke.open',
@@ -13803,7 +13872,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               result = await this.sendDaemonCmd("query_peer_caps", args, 2e4);
               break;
             case "invoke_capability":
-              result = await this.sendDaemonCmd("invoke_capability", args, 1e5);
+              result = await this.sendDaemonCmd("invoke_capability", args, 32e4);
               break;
             case "store_content":
               result = await this.sendDaemonCmd("store_content", args);
@@ -14899,7 +14968,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         } else {
           daemonArgs.prompt = prompt;
         }
-        const result = await this.sendDaemonCmd("remote_infer", daemonArgs, 12e4);
+        const result = await this.sendDaemonCmd("remote_infer", daemonArgs, 32e4);
         let peerUsed = args.target_peer || "auto-selected";
         try {
           const parsed = JSON.parse(result);
@@ -35530,12 +35599,6 @@ async function handleUpdate(subcommand, ctx) {
   process.stdout.write("\n");
   const checkSpinner = startInlineSpinner(`Checking for updates ${c2.dim(`(current: v${currentVersion})`)}`);
   const info = await checkForUpdate(currentVersion, true);
-  if (!info) {
-    checkSpinner.stop(`You're on the latest version (v${currentVersion}).`);
-    process.stdout.write("\n");
-    return;
-  }
-  checkSpinner.stop(`Update available: v${info.currentVersion} \u2192 v${c2.bold(c2.green(info.latestVersion))}`);
   const { exec: exec3, execSync: es2 } = await import("node:child_process");
   let needsSudo = false;
   try {
@@ -35548,21 +35611,6 @@ async function handleUpdate(subcommand, ctx) {
     }
   } catch {
   }
-  if (needsSudo) {
-    renderInfo("Global npm directory requires elevated permissions.");
-    renderInfo("You'll be asked for your password once \u2014 it covers all update steps.");
-    process.stdout.write("\n");
-    try {
-      es2("sudo -v", { stdio: "inherit", timeout: 6e4 });
-    } catch {
-      renderWarning("Could not acquire sudo credentials. Try: sudo npm i -g open-agents-ai");
-      return;
-    }
-  }
-  const sudoPrefix = needsSudo ? "sudo " : "";
-  const installSpinner = startInlineSpinner("Installing update");
-  const installCmd = `${sudoPrefix}npm install -g open-agents-ai@latest --prefer-online`;
-  let installOk = false;
   let installError = "";
   const runInstall2 = (cmd) => new Promise((resolve31) => {
     const child = exec3(cmd, { timeout: 18e4 }, (err, _stdout, stderr) => {
@@ -35572,35 +35620,84 @@ async function handleUpdate(subcommand, ctx) {
     });
     child.stdout?.resume();
   });
-  installOk = await runInstall2(installCmd);
-  if (!installOk && /ENOTEMPTY|errno -39/i.test(installError)) {
-    installSpinner.stop("Cleaning stale npm temp files...");
+  if (needsSudo) {
+    renderInfo("Global npm directory requires elevated permissions.");
+    renderInfo("You'll be asked for your password once \u2014 it covers all update steps.");
+    process.stdout.write("\n");
     try {
-      const prefix = es2("npm prefix -g", { encoding: "utf8", timeout: 5e3 }).trim();
-      const globalModules = prefix.endsWith("/lib") ? prefix + "/node_modules" : prefix + "/lib/node_modules";
-      es2(`${sudoPrefix}find "${globalModules}" -maxdepth 1 -name ".open-agents-ai-*" -type d -exec rm -rf {} + 2>/dev/null || true`, { timeout: 15e3 });
-      es2(`${sudoPrefix}rm -rf "${globalModules}/open-agents-ai" 2>/dev/null || true`, { timeout: 15e3 });
+      es2("sudo -v", { stdio: "inherit", timeout: 6e4 });
     } catch {
+      renderWarning("Could not acquire sudo credentials. Try: sudo npm i -g open-agents-ai");
+      return;
     }
-    const retrySpinner = startInlineSpinner("Retrying install");
-    installError = "";
+  }
+  const sudoPrefix = needsSudo ? "sudo " : "";
+  let primaryUpdated = false;
+  if (!info) {
+    checkSpinner.stop(`Primary package up to date (v${currentVersion}).`);
+  } else {
+    checkSpinner.stop(`Update available: v${info.currentVersion} \u2192 v${c2.bold(c2.green(info.latestVersion))}`);
+    const installSpinner = startInlineSpinner("Installing update");
+    const installCmd = `${sudoPrefix}npm install -g open-agents-ai@latest --prefer-online`;
+    let installOk = false;
     installOk = await runInstall2(installCmd);
+    if (!installOk && /ENOTEMPTY|errno -39/i.test(installError)) {
+      installSpinner.stop("Cleaning stale npm temp files...");
+      try {
+        const prefix = es2("npm prefix -g", { encoding: "utf8", timeout: 5e3 }).trim();
+        const globalModules = prefix.endsWith("/lib") ? prefix + "/node_modules" : prefix + "/lib/node_modules";
+        es2(`${sudoPrefix}find "${globalModules}" -maxdepth 1 -name ".open-agents-ai-*" -type d -exec rm -rf {} + 2>/dev/null || true`, { timeout: 15e3 });
+        es2(`${sudoPrefix}rm -rf "${globalModules}/open-agents-ai" 2>/dev/null || true`, { timeout: 15e3 });
+      } catch {
+      }
+      const retrySpinner = startInlineSpinner("Retrying install");
+      installError = "";
+      installOk = await runInstall2(installCmd);
+      if (!installOk) {
+        retrySpinner.stop("Retry failed.");
+      } else {
+        retrySpinner.stop(`Update installed (v${info.latestVersion}).`);
+      }
+    }
     if (!installOk) {
-      retrySpinner.stop("Retry failed.");
-    } else {
-      retrySpinner.stop(`Update installed (v${info.latestVersion}).`);
+      installSpinner.stop("Update install failed.");
+      const errPreview = installError.split("\n").filter((l) => l.trim()).slice(-3).join("\n    ");
+      if (errPreview)
+        renderWarning(`Error:
+    ${errPreview}`);
+      renderWarning(`Try manually: ${sudoPrefix}npm i -g open-agents-ai`);
+      return;
     }
+    installSpinner.stop(`Update installed (v${info.latestVersion}).`);
+    primaryUpdated = true;
   }
-  if (!installOk) {
-    installSpinner.stop("Update install failed.");
-    const errPreview = installError.split("\n").filter((l) => l.trim()).slice(-3).join("\n    ");
-    if (errPreview)
-      renderWarning(`Error:
-    ${errPreview}`);
-    renderWarning(`Try manually: ${sudoPrefix}npm i -g open-agents-ai`);
+  const depsSpinner = startInlineSpinner("Checking subordinate dependencies");
+  let depsUpdated = false;
+  try {
+    const prefix = es2("npm prefix -g", { encoding: "utf8", timeout: 5e3 }).trim();
+    const globalModules = prefix.endsWith("/lib") ? prefix + "/node_modules" : prefix + "/lib/node_modules";
+    const { existsSync: fe, readFileSync: rf } = await import("node:fs");
+    const { join: pj } = await import("node:path");
+    const pkgPath = pj(globalModules, "open-agents-ai", "package.json");
+    if (fe(pkgPath)) {
+      const pkg = JSON.parse(rf(pkgPath, "utf8"));
+      const allDeps = { ...pkg.dependencies || {}, ...pkg.optionalDependencies || {} };
+      const depNames = Object.keys(allDeps);
+      if (depNames.length > 0) {
+        const updateCmd = `${sudoPrefix}npm update --prefer-online --prefix "${pj(globalModules, "open-agents-ai")}" 2>/dev/null || true`;
+        const updateOk = await runInstall2(updateCmd);
+        if (updateOk)
+          depsUpdated = true;
+      }
+    }
+  } catch {
+  }
+  depsSpinner.stop(depsUpdated ? "Dependencies updated to latest." : "Dependencies checked.");
+  if (!primaryUpdated && !depsUpdated) {
+    renderInfo("Everything is up to date \u2014 no changes needed.");
+    process.stdout.write("\n");
     return;
   }
-  installSpinner.stop(`Update installed (v${info.latestVersion}).`);
   const rebuildSpinner = startInlineSpinner("Rebuilding native modules");
   const rebuildOk = await new Promise((resolve31) => {
     const child = exec3(`${sudoPrefix}npm rebuild -g open-agents-ai 2>/dev/null || true`, { timeout: 12e4 }, () => resolve31(true));
@@ -47499,6 +47596,16 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
         });
       }
     }
+    try {
+      const autoNexus = new NexusTool(repoRoot);
+      autoNexus.execute({ action: "connect" }).then((r) => {
+        if (r.success && r.output.includes("Connected")) {
+          writeContent(() => renderInfo("Nexus P2P network connected."));
+        }
+      }).catch(() => {
+      });
+    } catch {
+    }
     try {
       const oaDir = join50(repoRoot, ".oa");
       const reconnected = await ExposeGateway.checkAndReconnect(oaDir, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.103.68",
+  "version": "0.103.70",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",