open-agents-ai 0.184.49 → 0.184.50

package/dist/index.js

@@ -5292,6 +5292,8 @@ var init_nexus = __esm({
 import { NexusClient } from 'open-agents-nexus';
 import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync, appendFileSync, watch as fsWatch } from 'node:fs';
 import { join } from 'node:path';
+import { homedir, hostname } from 'node:os';
+import { createHash, createHmac } from 'node:crypto';
 
 const nexusDir = process.argv[2];
 const agentName = process.argv[3] || ('oa-node-' + process.pid);
@@ -5316,7 +5318,7 @@ writeFileSync(pidFile, String(process.pid));
 
 // Use GLOBAL identity key so all OA instances on this machine share one peerId.
 // Fallback to project-scoped key if global doesn't exist.
-const globalKeyDir = join(require('os').homedir(), '.open-agents');
+const globalKeyDir = join(homedir(), '.open-agents');
 const globalKeyPath = join(globalKeyDir, 'identity.key');
 const projectKeyPath = join(nexusDir, 'identity.key');
 const keyPath = existsSync(globalKeyPath) ? globalKeyPath : projectKeyPath;
@@ -7248,19 +7250,33 @@ try {
 try { process.stdout.on('error', function(e) { if (e.code !== 'EPIPE') throw e; }); } catch {}
 try { process.stderr.on('error', function(e) { if (e.code !== 'EPIPE') throw e; }); } catch {}
 
-// Crash protection \u2014 prevent unhandled errors from killing the daemon
+// Crash protection \u2014 prevent unhandled errors from killing the daemon.
+// EPIPE/ECONNRESET/ETIMEDOUT are transient network errors \u2014 always swallow.
+// The daemon MUST stay alive through any non-fatal error.
+var TRANSIENT_CODES = ['EPIPE', 'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'EHOSTUNREACH', 'ENETUNREACH', 'EAI_AGAIN'];
+function isTransientError(err) {
+  if (!err) return false;
+  var code = err.code || '';
+  var msg = err.message || String(err);
+  return TRANSIENT_CODES.some(function(c) { return code === c || msg.includes(c); });
+}
 process.on('uncaughtException', (err) => {
+  if (isTransientError(err)) {
+    dlog('Swallowed transient uncaughtException: ' + (err.code || err.message || err));
+    return; // keep daemon alive
+  }
   var errMsg = err && err.message ? err.message : String(err);
-  // EPIPE means parent closed the pipe \u2014 not a real error, just ignore
-  if (err && err.code === 'EPIPE') return;
-  if (errMsg.includes('EPIPE')) return;
-  try { console.error('Nexus daemon uncaughtException:', errMsg); } catch {}
+  try { dlog('uncaughtException (non-transient): ' + errMsg); } catch {}
   writeStatus({ error: 'uncaughtException: ' + errMsg });
+  // Do NOT exit \u2014 keep daemon alive even for non-transient errors
 });
 process.on('unhandledRejection', (reason) => {
+  if (isTransientError(reason)) {
+    dlog('Swallowed transient unhandledRejection: ' + (reason?.code || reason?.message || reason));
+    return;
+  }
   var msg = reason instanceof Error ? reason.message : String(reason);
-  if (msg.includes('EPIPE')) return;
-  try { console.error('Nexus daemon unhandledRejection:', msg); } catch {}
+  try { dlog('unhandledRejection (non-transient): ' + msg); } catch {}
   // Do NOT exit \u2014 keep daemon alive
 });
 
@@ -7705,7 +7721,7 @@ process.on('unhandledRejection', (reason) => {
               const _cLatency = Date.now() - _cStart;
               // Sign response for accountability (HMAC-SHA256 with peerId)
               const _cSigData = _cData.queryId + ':' + _cContent.slice(0, 200) + ':' + _cModel + ':' + _cLatency;
-              const _cSig = require('crypto').createHmac('sha256', nexus.peerId).update(_cSigData).digest('hex').slice(0, 32);
+              const _cSig = createHmac('sha256', nexus.peerId).update(_cSigData).digest('hex').slice(0, 32);
               // Scan inbound query for leaked secrets (defense-in-depth)
               const _cSecretPatterns = [/sk-[a-zA-Z0-9]{20,}/g, /ghp_[a-zA-Z0-9]{36,}/g, /AKIA[0-9A-Z]{16}/g];
               for (const _cPat of _cSecretPatterns) {
@@ -7718,7 +7734,7 @@ process.on('unhandledRejection', (reason) => {
                 content: _cContent,
                 model: _cModel,
                 provider: nexus.peerId,
-                agentName: nexus.agentName || ('oa-' + require('os').hostname().slice(0, 12)),
+                agentName: nexus.agentName || ('oa-' + hostname().slice(0, 12)),
                 latencyMs: _cLatency,
                 usage: _cResult.eval_count ? { inputTokens: _cResult.prompt_eval_count || 0, outputTokens: _cResult.eval_count || 0 } : undefined,
                 signature: _cSig,
@@ -8023,7 +8039,7 @@ process.on('unhandledRejection', (reason) => {
           var _esTopIds = _esFiltered.map(function(m) { return m.id; }).sort().join(',');
 
           // SHA-256 hash of top-10 IDs for compact comparison
-          var _esHash = require('crypto').createHash('sha256').update(_esTopIds).digest('hex').slice(0, 16);
+          var _esHash = createHash('sha256').update(_esTopIds).digest('hex').slice(0, 16);
 
           _epochCounter++;
           var _esAnnouncement = {
@@ -8078,6 +8094,9 @@ process.on('unhandledRejection', (reason) => {
   }
 })();
 
+// Ignore SIGPIPE \u2014 broken pipe from network writes should NOT kill daemon
+try { process.on('SIGPIPE', function() { dlog('SIGPIPE received \u2014 ignored'); }); } catch {}
+
 // Graceful shutdown
 process.on('SIGTERM', async () => {
   for (const [, room] of rooms) { try { await room.leave(); } catch {} }
@@ -8511,8 +8530,36 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         }
         return `Daemon did not respond within ${Math.round(timeoutMs / 1e3)}s. It may still be processing.`;
       }
+      /** Check if daemon process is alive. Returns PID if alive, 0 if dead. */
+      isDaemonAlive() {
+        const pid = this.getDaemonPid();
+        if (!pid)
+          return 0;
+        try {
+          process.kill(pid, 0);
+          return pid;
+        } catch {
+          return 0;
+        }
+      }
+      /** Auto-restart daemon if it crashed. Called before every command. */
+      async ensureDaemonAlive() {
+        if (this.isDaemonAlive())
+          return;
+        const statusFile = join14(this.nexusDir, "status.json");
+        if (!existsSync11(statusFile))
+          return;
+        try {
+          const status = JSON.parse(readFileSync8(statusFile, "utf8"));
+          if (status.agentName) {
+            await this.doConnect({ agent_name: status.agentName, agent_type: status.agentType || "general" });
+          }
+        } catch {
+        }
+      }
       /** Public interface for daemon commands — used by NexusAgenticBackend */
       async sendCommand(action, args, timeoutMs) {
+        await this.ensureDaemonAlive();
         return this.sendDaemonCmd(action, args, timeoutMs);
       }
       /** Get the nexus data directory path */

package/package.json

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