open-agents-ai 0.103.50 → 0.103.52

package/dist/index.js

@@ -13579,9 +13579,19 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         }
       }
       async sendDaemonCmd(action, args, timeoutMs = 15e3) {
-        const pid = this.getDaemonPid();
-        if (!pid)
-          throw new Error("Nexus daemon not running. Use action 'connect' first.");
+        let pid = this.getDaemonPid();
+        if (!pid) {
+          try {
+            await this.doConnect({
+              agent_name: "open-agents-node",
+              agent_type: "general"
+            });
+            pid = this.getDaemonPid();
+          } catch {
+          }
+          if (!pid)
+            throw new Error("Nexus daemon not running. Use action 'connect' first.");
+        }
         const cmdId = randomBytes6(8).toString("hex");
         const cmdFile = join30(this.nexusDir, "cmd.json");
         const respFile = join30(this.nexusDir, "resp.json");
@@ -20732,11 +20742,13 @@ var NexusAgenticBackend;
 var init_nexusBackend = __esm({
   "packages/orchestrator/dist/nexusBackend.js"() {
     "use strict";
-    NexusAgenticBackend = class {
+    NexusAgenticBackend = class _NexusAgenticBackend {
       sendFn;
       model;
       targetPeer;
       authKey;
+      consecutiveFailures = 0;
+      static MAX_CONSECUTIVE_FAILURES = 3;
       constructor(sendFn, model, targetPeer, authKey) {
         this.sendFn = sendFn;
         this.model = model;
@@ -20744,6 +20756,11 @@ var init_nexusBackend = __esm({
         this.authKey = authKey || "";
       }
       async chatCompletion(request) {
+        if (this.consecutiveFailures >= _NexusAgenticBackend.MAX_CONSECUTIVE_FAILURES) {
+          const err = new Error(`Remote peer unreachable after ${this.consecutiveFailures} attempts. Use /endpoint to switch to a local model or reconnect.`);
+          err.fatal = true;
+          throw err;
+        }
         const daemonArgs = {
           model: this.model,
           messages: JSON.stringify(request.messages),
@@ -20757,16 +20774,25 @@ var init_nexusBackend = __esm({
         if (this.authKey) {
           daemonArgs.auth_key = this.authKey;
         }
-        const rawResult = await this.sendFn("remote_infer", daemonArgs, request.timeoutMs || 12e4);
+        let rawResult;
+        try {
+          rawResult = await this.sendFn("remote_infer", daemonArgs, request.timeoutMs || 12e4);
+        } catch (sendErr) {
+          this.consecutiveFailures++;
+          throw sendErr;
+        }
         let parsed;
         try {
           parsed = JSON.parse(rawResult);
         } catch {
+          this.consecutiveFailures++;
           throw new Error(rawResult.slice(0, 500));
         }
         if (parsed.success === false) {
+          this.consecutiveFailures++;
           throw new Error(`Remote inference failed: ${parsed.output || rawResult}`);
         }
+        this.consecutiveFailures = 0;
         const invokeResult = parsed.result;
         let responseData = null;
         if (typeof invokeResult === "string") {
@@ -28811,10 +28837,21 @@ ${this.formatConnectionInfo()}`);
                     continue;
                   try {
                     const record = JSON.parse(line);
-                    if (record.tokens) {
-                      this._stats.totalTokensIn += record.tokens.input || 0;
-                      this._stats.totalTokensOut += record.tokens.output || 0;
+                    const recInputBytes = record.inputBytes || 0;
+                    const recOutputBytes = record.outputBytes || 0;
+                    const recTotalTokens = typeof record.tokens === "number" ? record.tokens : typeof record.tokens === "object" && record.tokens ? (record.tokens.input || 0) + (record.tokens.output || 0) : 0;
+                    const totalBytes = recInputBytes + recOutputBytes;
+                    let tokIn = 0;
+                    let tokOut = 0;
+                    if (recTotalTokens > 0 && totalBytes > 0) {
+                      tokIn = Math.round(recTotalTokens * (recInputBytes / totalBytes));
+                      tokOut = recTotalTokens - tokIn;
+                    } else if (recTotalTokens > 0) {
+                      tokIn = Math.round(recTotalTokens / 2);
+                      tokOut = recTotalTokens - tokIn;
                     }
+                    this._stats.totalTokensIn += tokIn;
+                    this._stats.totalTokensOut += tokOut;
                     const peerId = record.from || record.peerId || "unknown";
                     const shortPeer = peerId.length > 16 ? peerId.slice(0, 16) + "..." : peerId;
                     let user = this._stats.users.get(shortPeer);
@@ -28833,12 +28870,10 @@ ${this.formatConnectionInfo()}`);
                     }
                     user.requests++;
                     user.lastSeen = Date.now();
-                    if (record.tokens) {
-                      user.tokensIn += record.tokens.input || 0;
-                      user.tokensOut += record.tokens.output || 0;
-                    }
-                    if (record.model || record.capability) {
-                      const modelName = record.model || record.capability.replace("inference:", "") || "unknown";
+                    user.tokensIn += tokIn;
+                    user.tokensOut += tokOut;
+                    if (record.model || record.capability || record.service) {
+                      const modelName = record.model || (record.capability || record.service || "").replace("inference:", "") || "unknown";
                       this._stats.modelUsage.set(modelName, (this._stats.modelUsage.get(modelName) ?? 0) + 1);
                       let mm = user.models.get(modelName);
                       if (!mm) {
@@ -28847,10 +28882,8 @@ ${this.formatConnectionInfo()}`);
                       }
                       mm.requests++;
                       mm.lastUsed = Date.now();
-                      if (record.tokens) {
-                        mm.tokensIn += record.tokens.input || 0;
-                        mm.tokensOut += record.tokens.output || 0;
-                      }
+                      mm.tokensIn += tokIn;
+                      mm.tokensOut += tokOut;
                     }
                   } catch {
                   }
@@ -33836,12 +33869,12 @@ async function handleSlashCommand(input, ctx) {
         return "handled";
       }
       if (arg === "status") {
-        const info = ctx.getExposeInfo?.();
-        if (info) {
-          process.stdout.write("\n" + info.stats + "\n\n");
-        } else {
+        const gateway = ctx.getExposeGateway?.();
+        if (!gateway) {
           renderWarning("No active expose gateway.");
+          return "handled";
         }
+        await showExposeDashboard(gateway, ctx.rl);
         return "handled";
       }
       if (arg === "config") {
@@ -35292,6 +35325,254 @@ async function switchModel(query, ctx, local = false) {
     renderError(`Failed to switch model: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
+function fmtDashTokens(n) {
+  if (n < 1e3)
+    return String(n);
+  if (n < 1e6)
+    return `${(n / 1e3).toFixed(1)}K`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+function fmtUptime(ms) {
+  const sec = Math.floor(ms / 1e3);
+  if (sec < 60)
+    return `${sec}s`;
+  if (sec < 3600)
+    return `${Math.floor(sec / 60)}m ${sec % 60}s`;
+  return `${Math.floor(sec / 3600)}h ${Math.floor(sec % 3600 / 60)}m`;
+}
+function getLocalSystemMetrics() {
+  const os = __require("node:os");
+  const cpus2 = os.cpus();
+  const loads = os.loadavg();
+  const totalMem = os.totalmem();
+  const freeMem = os.freemem();
+  const usedMem = totalMem - freeMem;
+  const result = {
+    cpuModel: cpus2[0]?.model?.trim() ?? "unknown",
+    cpuCores: cpus2.length,
+    cpuUtil: Math.min(100, Math.round(loads[0] / cpus2.length * 100)),
+    memTotalGB: Math.round(totalMem / (1024 * 1024 * 1024) * 10) / 10,
+    memUsedGB: Math.round(usedMem / (1024 * 1024 * 1024) * 10) / 10,
+    memUtil: Math.round(usedMem / totalMem * 100),
+    gpuAvailable: false,
+    gpuName: "",
+    gpuUtil: 0,
+    vramUsedMB: 0,
+    vramTotalMB: 0,
+    vramUtil: 0
+  };
+  try {
+    const { execSync: execSync29 } = __require("node:child_process");
+    const smiOut = execSync29("nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 3e3 });
+    const line = smiOut.trim().split("\n")[0];
+    if (line) {
+      const parts = line.split(",").map((s) => s.trim());
+      result.gpuAvailable = true;
+      result.gpuUtil = parseInt(parts[0] || "0", 10) || 0;
+      result.vramUsedMB = parseInt(parts[1] || "0", 10) || 0;
+      result.vramTotalMB = parseInt(parts[2] || "0", 10) || 0;
+      result.gpuName = parts[3] || "";
+      result.vramUtil = result.vramTotalMB > 0 ? Math.round(result.vramUsedMB / result.vramTotalMB * 100) : 0;
+    }
+  } catch {
+  }
+  return result;
+}
+async function showExposeDashboard(gateway, rl) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  if (!stdin.isTTY) {
+    if (typeof gateway.formatStats === "function") {
+      stdout.write("\n" + gateway.formatStats() + "\n\n");
+    }
+    return;
+  }
+  let lastRenderedLines = 0;
+  let refreshTimer = null;
+  const hadRawMode = stdin.isRaw;
+  let sysMetrics = getLocalSystemMetrics();
+  const savedListeners = rl ? stdin.listeners("data").slice() : [];
+  if (rl) {
+    rl.pause();
+    for (const fn of savedListeners)
+      stdin.removeListener("data", fn);
+  }
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdout.write("\x1B[?25l");
+  function buildDashboard() {
+    const s = gateway.stats ?? gateway._stats;
+    if (!s)
+      return ["  No stats available.", "", "  Press Escape or 'q' to close."];
+    const lines = [];
+    const now = Date.now();
+    const uptime = fmtUptime(now - (s.startedAt || now));
+    const statusColor = s.status === "active" ? c2.green : s.status === "error" ? c2.red : c2.yellow;
+    lines.push("");
+    lines.push(`  ${c2.bold("Expose Dashboard")}  ${statusColor("\u25CF")} ${statusColor(s.status || "unknown")}  ${c2.dim(`uptime ${uptime}`)}`);
+    lines.push(`  ${c2.dim("\u2500".repeat(60))}`);
+    const activeConns = s.activeConnections || 0;
+    const totalReqs = s.totalRequests || 0;
+    const errors = s.errors || 0;
+    const tokIn = s.totalTokensIn || 0;
+    const tokOut = s.totalTokensOut || 0;
+    lines.push(`  ${c2.cyan("Requests")}  ${c2.bold(String(totalReqs))}  ${c2.dim("|")}  ${c2.cyan("Active")}  ${activeConns > 0 ? c2.green(c2.bold(String(activeConns))) : c2.dim("0")}  ${c2.dim("|")}  ${c2.cyan("Errors")}  ${errors > 0 ? c2.red(String(errors)) : c2.dim("0")}`);
+    lines.push(`  ${c2.cyan("Tokens")}    ${c2.dim("in:")}${c2.bold(fmtDashTokens(tokIn))}  ${c2.dim("out:")}${c2.bold(fmtDashTokens(tokOut))}  ${c2.dim("total:")}${fmtDashTokens(tokIn + tokOut)}`);
+    if (s.budgetTokensTotal > 0) {
+      const pct = Math.round(s.budgetTokensRemaining / s.budgetTokensTotal * 100);
+      const budgetColor = pct > 50 ? c2.green : pct > 20 ? c2.yellow : c2.red;
+      const barLen = 20;
+      const filledLen = Math.round(pct / 100 * barLen);
+      const bar = budgetColor("\u2588".repeat(filledLen)) + c2.dim("\u2591".repeat(barLen - filledLen));
+      lines.push(`  ${c2.cyan("Budget")}    ${bar} ${budgetColor(`${pct}%`)} ${c2.dim(`(${fmtDashTokens(s.budgetTokensRemaining)}/${fmtDashTokens(s.budgetTokensTotal)})`)}`);
+    }
+    const sys = sysMetrics;
+    lines.push("");
+    lines.push(`  ${c2.bold("System")}`);
+    const cpuColor = sys.cpuUtil > 80 ? c2.red : sys.cpuUtil > 50 ? c2.yellow : c2.green;
+    const memColor = sys.memUtil > 80 ? c2.red : sys.memUtil > 50 ? c2.yellow : c2.green;
+    lines.push(`  ${c2.cyan("CPU")}   ${cpuColor(sys.cpuUtil + "%")} ${c2.dim(`(${sys.cpuCores} cores, ${sys.cpuModel.slice(0, 40)})`)}`);
+    lines.push(`  ${c2.cyan("RAM")}   ${memColor(sys.memUtil + "%")} ${c2.dim(`(${sys.memUsedGB}/${sys.memTotalGB} GB)`)}`);
+    if (sys.gpuAvailable) {
+      const gpuColor = sys.gpuUtil > 80 ? c2.red : sys.gpuUtil > 50 ? c2.yellow : c2.green;
+      const vramColor = sys.vramUtil > 80 ? c2.red : sys.vramUtil > 50 ? c2.yellow : c2.green;
+      lines.push(`  ${c2.cyan("GPU")}   ${gpuColor(sys.gpuUtil + "%")} ${c2.dim(`(${sys.gpuName.trim()})`)}`);
+      lines.push(`  ${c2.cyan("VRAM")}  ${vramColor(sys.vramUtil + "%")} ${c2.dim(`(${sys.vramUsedMB}/${sys.vramTotalMB} MB)`)}`);
+    }
+    const modelEntries = s.modelUsage ? Array.from(s.modelUsage.entries()).filter(([m]) => !DASH_INTERNAL.has(m)) : [];
+    if (modelEntries.length > 0) {
+      lines.push("");
+      lines.push(`  ${c2.bold("Models")}`);
+      for (const [model, count] of modelEntries) {
+        let mIn = 0, mOut = 0;
+        if (s.users) {
+          for (const user of s.users.values()) {
+            const mm = user.models?.get?.(model);
+            if (mm) {
+              mIn += mm.tokensIn || 0;
+              mOut += mm.tokensOut || 0;
+            }
+          }
+        }
+        const bar = count > 0 ? c2.green("\u25AE".repeat(Math.min(count, 20))) : "";
+        lines.push(`  ${c2.cyan(model.padEnd(35))} ${c2.bold(String(count).padStart(4))} req  ${c2.dim(`in:${fmtDashTokens(mIn).padStart(6)} out:${fmtDashTokens(mOut).padStart(6)}`)}  ${bar}`);
+      }
+    }
+    const users = s.users ? Array.from(s.users.values()) : [];
+    if (users.length > 0) {
+      lines.push("");
+      lines.push(`  ${c2.bold("Connected Peers")} (${users.length})`);
+      for (const user of users) {
+        const ageSec = Math.floor((now - (user.firstSeen || now)) / 1e3);
+        const ageStr = ageSec < 60 ? `${ageSec}s` : ageSec < 3600 ? `${Math.floor(ageSec / 60)}m` : `${Math.floor(ageSec / 3600)}h${Math.floor(ageSec % 3600 / 60)}m`;
+        const lastSec = Math.floor((now - (user.lastSeen || now)) / 1e3);
+        const lastStr = lastSec < 5 ? c2.green("now") : lastSec < 60 ? `${lastSec}s ago` : `${Math.floor(lastSec / 60)}m ago`;
+        const activeStr = (user.activeRequests || 0) > 0 ? c2.green(` \u25CF ${user.activeRequests} active`) : "";
+        lines.push(`  ${c2.bold(user.ip || "unknown")}${activeStr}`);
+        lines.push(`    ${c2.dim("session")} ${ageStr}  ${c2.dim("last")} ${lastStr}  ${c2.dim("reqs")} ${user.requests || 0}  ${c2.dim("tok")} ${c2.cyan("in:")}${fmtDashTokens(user.tokensIn || 0)} ${c2.cyan("out:")}${fmtDashTokens(user.tokensOut || 0)}`);
+        const userModels = user.models ? Array.from(user.models.entries()).filter(([m]) => !DASH_INTERNAL.has(m)) : [];
+        for (const [m, mm] of userModels) {
+          lines.push(`    ${c2.dim("\u2514")} ${c2.cyan(m)} ${c2.dim(`${mm.requests || 0}req ${fmtDashTokens((mm.tokensIn || 0) + (mm.tokensOut || 0))}tok`)}`);
+        }
+      }
+    }
+    lines.push("");
+    lines.push(`  ${c2.dim("Press Escape or 'q' to close  \u2502  Live \u25CF updates every 2s")}`);
+    lines.push("");
+    return lines;
+  }
+  function render() {
+    sysMetrics = getLocalSystemMetrics();
+    const lines = buildDashboard();
+    if (lastRenderedLines > 0) {
+      stdout.write(`\x1B[${lastRenderedLines}A`);
+      for (let i = 0; i < lastRenderedLines; i++) {
+        stdout.write("\x1B[2K\n");
+      }
+      stdout.write(`\x1B[${lastRenderedLines}A`);
+    }
+    stdout.write(lines.join("\n") + "\n");
+    lastRenderedLines = lines.length;
+  }
+  function cleanup() {
+    if (refreshTimer) {
+      clearInterval(refreshTimer);
+      refreshTimer = null;
+    }
+    gateway.removeListener?.("stats", onStats);
+    if (lastRenderedLines > 0) {
+      stdout.write(`\x1B[${lastRenderedLines}A`);
+      for (let i = 0; i < lastRenderedLines; i++) {
+        stdout.write("\x1B[2K\n");
+      }
+      stdout.write(`\x1B[${lastRenderedLines}A`);
+    }
+    stdout.write("\x1B[?25h");
+    stdin.setRawMode(hadRawMode ?? false);
+    stdin.removeListener("data", onKey);
+    if (rl) {
+      for (const fn of savedListeners)
+        stdin.on("data", fn);
+      rl.resume();
+    }
+  }
+  function onStats() {
+    render();
+  }
+  function onKey(chunk) {
+    const key = chunk.toString();
+    if (key === "\x1B" || key === "q" || key === "Q") {
+      cleanup();
+      return;
+    }
+    if (key === "") {
+      cleanup();
+      return;
+    }
+  }
+  if (typeof gateway.on === "function") {
+    gateway.on("stats", onStats);
+  }
+  refreshTimer = setInterval(render, 2e3);
+  render();
+  stdin.on("data", onKey);
+  return new Promise((resolve31) => {
+    const origCleanup = cleanup;
+    function wrappedCleanup() {
+      origCleanup();
+      resolve31();
+    }
+    stdin.removeListener("data", onKey);
+    function onKeyWrapped(chunk) {
+      const key = chunk.toString();
+      if (key === "\x1B" || key === "q" || key === "Q" || key === "") {
+        if (refreshTimer) {
+          clearInterval(refreshTimer);
+          refreshTimer = null;
+        }
+        gateway.removeListener?.("stats", onStats);
+        if (lastRenderedLines > 0) {
+          stdout.write(`\x1B[${lastRenderedLines}A`);
+          for (let i = 0; i < lastRenderedLines; i++) {
+            stdout.write("\x1B[2K\n");
+          }
+          stdout.write(`\x1B[${lastRenderedLines}A`);
+        }
+        stdout.write("\x1B[?25h");
+        stdin.setRawMode(hadRawMode ?? false);
+        stdin.removeListener("data", onKeyWrapped);
+        if (rl) {
+          for (const fn of savedListeners)
+            stdin.on("data", fn);
+          rl.resume();
+        }
+        resolve31();
+      }
+    }
+    stdin.on("data", onKeyWrapped);
+  });
+}
+var DASH_INTERNAL;
 var init_commands = __esm({
   "packages/cli/dist/tui/commands.js"() {
     "use strict";
@@ -35307,6 +35588,7 @@ var init_commands = __esm({
     init_listen();
     init_dist();
     init_tui_select();
+    DASH_INTERNAL = /* @__PURE__ */ new Set(["system_metrics", "__list_capabilities"]);
   }
 });
 
@@ -44207,15 +44489,34 @@ var init_status_bar = __esm({
       }
       /** Expose gateway status — shown after capability emojis */
       _expose = null;
+      /** Blink state for expose icon during active inference */
+      _exposeBlinkOn = true;
+      _exposeBlinkTimer = null;
       /** Update expose gateway status */
       setExposeStatus(status) {
         this._expose = status;
+        if (status.activeConnections > 0 && !this._exposeBlinkTimer) {
+          this._exposeBlinkTimer = setInterval(() => {
+            this._exposeBlinkOn = !this._exposeBlinkOn;
+            if (this.active)
+              this.renderFooterPreserveCursor();
+          }, 500);
+        } else if (status.activeConnections === 0 && this._exposeBlinkTimer) {
+          clearInterval(this._exposeBlinkTimer);
+          this._exposeBlinkTimer = null;
+          this._exposeBlinkOn = true;
+        }
         if (this.active)
           this.renderFooterPreserveCursor();
       }
       /** Clear expose gateway status */
       clearExposeStatus() {
         this._expose = null;
+        if (this._exposeBlinkTimer) {
+          clearInterval(this._exposeBlinkTimer);
+          this._exposeBlinkTimer = null;
+          this._exposeBlinkOn = true;
+        }
         if (this.active)
           this.renderFooterPreserveCursor();
       }
@@ -44674,7 +44975,7 @@ var init_status_bar = __esm({
         }
         if (this._expose) {
           const INTERNAL_CAPS = /* @__PURE__ */ new Set(["system_metrics", "__list_capabilities"]);
-          const statusEmoji = this._expose.status === "active" ? "\u{1F7E2}" : this._expose.status === "error" ? "\u{1F534}" : "\u{1F7E0}";
+          const statusEmoji = this._expose.activeConnections > 0 ? this._exposeBlinkOn ? "\u{1F7E2}" : "\u26AB" : this._expose.status === "active" ? "\u{1F7E2}" : this._expose.status === "error" ? "\u{1F534}" : "\u{1F7E0}";
           const models = Array.from(this._expose.modelUsage.keys()).filter((m2) => !INTERNAL_CAPS.has(m2));
           const modelParams = models.map((mdl) => {
             const pm = mdl.match(/(\d+[bBmM])/);
@@ -47277,6 +47578,10 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         stats: infos[0].stats
       };
     },
+    /** Get the raw expose gateway instance for live dashboard */
+    getExposeGateway() {
+      return p2pGateway ?? tunnelGateway ?? null;
+    },
     // ── Nexus daemon connect ──────────────────────────────────────────────
     async nexusConnect() {
       const nexusTool = new NexusTool(repoRoot);

package/package.json

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