nexus-agents 2.71.0 → 2.72.1

package/dist/{chunk-OF7CYMMA.js → chunk-DA5UDQYW.js}

@@ -1,6 +1,6 @@
 import {
   getErrorMessage
-} from "./chunk-7OBFO4GF.js";
+} from "./chunk-O4KUCF5S.js";
 
 // src/cli/setup-config.ts
 import { copyFileSync, existsSync, writeFileSync } from "fs";
@@ -74,4 +74,4 @@ function ensureBackup(outputPath) {
 export {
   runConfigInitSync
 };
-//# sourceMappingURL=chunk-OF7CYMMA.js.map
+//# sourceMappingURL=chunk-DA5UDQYW.js.map

package/dist/{chunk-XATH462F.js → chunk-ES6GFP35.js}

@@ -1,7 +1,7 @@
 import {
   CliCircuitBreaker,
   DEFAULT_CIRCUIT_BREAKER_CONFIG
-} from "./chunk-U3HZQTUF.js";
+} from "./chunk-TQFRPFMG.js";
 import {
   CLI_SUBPROCESS_TIMEOUTS,
   CLI_TIMEOUTS,
@@ -26,7 +26,7 @@ import {
   getTimeProvider,
   isRateLimitText,
   ok
-} from "./chunk-7OBFO4GF.js";
+} from "./chunk-O4KUCF5S.js";
 
 // src/cli-adapters/subprocess-adapter.ts
 import { spawn } from "child_process";
@@ -617,6 +617,96 @@ function sanitizeOutput(text) {
   return result;
 }
 
+// src/cli-adapters/cli-error-envelope.ts
+function isClaudeErrorEnvelope(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const obj = v;
+  return obj.type === "result" && obj.is_error === true;
+}
+function unwrapCodexEnvelope(parsed) {
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const obj = parsed;
+  if (typeof obj.error === "string" && obj.error !== "") return obj.error;
+  if (obj.is_error === true && typeof obj.message === "string" && obj.message !== "") {
+    return obj.message;
+  }
+  return null;
+}
+var LOGIN_HINTS = {
+  claude: "claude /login",
+  codex: "codex login",
+  gemini: "gemini",
+  opencode: "opencode auth login"
+};
+var NOT_AUTH_PATTERNS = [
+  /not logged in/i,
+  /please run \/?login/i,
+  /authentication (?:required|expired|failed)/i,
+  /invalid (?:api ?key|credentials)/i,
+  /unauthorized/i,
+  // #2455 ask 1: catch "API key expired" / "API key revoked" / "API key
+  // missing" — the bare /invalid api key/ pattern misses these. Architects
+  // explicitly ruled OUT `permission denied` (that's authz, not authn —
+  // routing to /login is the wrong fix).
+  /api[- ]?key (?:expired|revoked|missing)/i,
+  // Token expiry/revocation as a standalone signal, not co-occurring with
+  // "unauthorized" — some upstreams emit "Token expired. Please re-auth."
+  // without the unauthorized keyword.
+  /token (?:expired|revoked)/i
+];
+function classifyMessage(message) {
+  for (const re of NOT_AUTH_PATTERNS) {
+    if (re.test(message)) return { code: "NOT_AUTHENTICATED", auth: true };
+  }
+  return { code: "EXECUTION_ERROR", auth: false };
+}
+function parseCliErrorEnvelope(stdout, cliName) {
+  const trimmed = stdout.trim();
+  if (trimmed === "" || !trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return tryLastLine(trimmed, cliName);
+  }
+  let message;
+  if (isClaudeErrorEnvelope(parsed) && typeof parsed.result === "string") {
+    message = parsed.result;
+  } else {
+    const codex = unwrapCodexEnvelope(parsed);
+    if (codex !== null) message = codex;
+  }
+  if (message === void 0 || message === "") return null;
+  return buildParsedError(message, cliName);
+}
+function tryLastLine(stdout, cliName) {
+  const lines = stdout.split("\n").filter((l) => l.trim() !== "");
+  if (lines.length < 2) return null;
+  const last = lines.at(-1);
+  if (last === void 0) return null;
+  if (!last.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(last);
+    if (isClaudeErrorEnvelope(parsed) && typeof parsed.result === "string") {
+      return buildParsedError(parsed.result, cliName);
+    }
+  } catch {
+  }
+  return null;
+}
+function buildParsedError(message, cliName) {
+  const firstLine = (message.split("\n")[0] ?? message).trim().slice(0, 240);
+  const { code, auth } = classifyMessage(firstLine);
+  if (auth) {
+    return {
+      message: firstLine,
+      code,
+      hint: `Run \`${LOGIN_HINTS[cliName]}\` to authenticate, then retry.`
+    };
+  }
+  return { message: firstLine, code };
+}
+
 // src/cli-adapters/subprocess-adapter.ts
 var PLAINTEXT_FALLBACK_MIN_LENGTH = 30;
 function tryPlaintextFallback(stdout) {
@@ -801,7 +891,8 @@ var SubprocessCliAdapter = class extends BaseCliAdapter {
       stdoutBytes: 0,
       stderrBytes: 0,
       stdoutTruncated: false,
-      stderrTruncated: false
+      stderrTruncated: false,
+      firstByteTime: null
     };
     const resolveOnce = (result) => {
       if (!state.resolved) {
@@ -809,17 +900,7 @@ var SubprocessCliAdapter = class extends BaseCliAdapter {
         resolve(result);
       }
     };
-    if (child.stdout !== null) {
-      child.stdout.on("data", (data) => {
-        appendBuffered(state, "stdout", data);
-        onProgress?.();
-      });
-    }
-    if (child.stderr !== null) {
-      child.stderr.on("data", (data) => {
-        appendBuffered(state, "stderr", data);
-      });
-    }
+    this.attachStdoutHandlers(child, state, onProgress);
     child.on("error", (error) => {
       resolveOnce(this.handleSubprocessError(error));
     });
@@ -829,10 +910,57 @@ var SubprocessCliAdapter = class extends BaseCliAdapter {
     }, timeoutMs);
     child.on("close", (code) => {
       clearTimeout(timeoutId);
+      this.logTimingBreakdown(state, startTime, code);
       resolveOnce(this.classifyCloseResult(code, state, startTime));
     });
     return state;
   }
+  /** Attach stdout/stderr data handlers + capture first-byte time (#2472). */
+  attachStdoutHandlers(child, state, onProgress) {
+    if (child.stdout !== null) {
+      child.stdout.on("data", (data) => {
+        if (state.firstByteTime === null && data.length > 0) {
+          state.firstByteTime = getTimeProvider().now();
+        }
+        appendBuffered(state, "stdout", data);
+        onProgress?.();
+      });
+    }
+    if (child.stderr !== null) {
+      child.stderr.on("data", (data) => {
+        appendBuffered(state, "stderr", data);
+      });
+    }
+  }
+  /**
+   * Log spawn-latency vs streaming breakdown at info level (#2472). Emits
+   * one structured event per subprocess invocation, queryable via the
+   * existing trace JSONL infrastructure. The breakdown lets operators
+   * identify whether a slow run was caused by:
+   *   - High spawn-latency: model gateway took its time before producing
+   *     the first token (cold-start, queueing, network jitter).
+   *   - High streaming-time: response body was large or generation slow.
+   *   - Total approaches the timeout cap with no first-byte: hung process.
+   *
+   * Structured fields chosen so existing query_trace tooling can group by
+   * cli + provider + model and surface tail-latency outliers.
+   */
+  logTimingBreakdown(state, startTime, code) {
+    const now = getTimeProvider().now();
+    const totalMs = now - startTime;
+    const spawnLatencyMs = state.firstByteTime === null ? null : state.firstByteTime - startTime;
+    const streamingMs = state.firstByteTime === null ? null : now - state.firstByteTime;
+    this.logger.info("Subprocess timing", {
+      cli: this.name,
+      totalMs,
+      spawnLatencyMs,
+      streamingMs,
+      sawFirstByte: state.firstByteTime !== null,
+      exitCode: code,
+      stdoutBytes: state.stdoutBytes,
+      stderrBytes: state.stderrBytes
+    });
+  }
   /** Classify a subprocess close event into a Result. */
   classifyCloseResult(code, state, startTime) {
     state.stdout = sanitizeOutput(state.stdout);
@@ -863,25 +991,7 @@ var SubprocessCliAdapter = class extends BaseCliAdapter {
     }
     const text = this.parser.extractResponse(stdout);
     if (text === null) {
-      if (isRateLimitText(stdout)) {
-        const snippet2 = stdout.slice(0, 500).trim();
-        return err(this.createError("RATE_LIMITED", snippet2));
-      }
-      const plaintext = tryPlaintextFallback(stdout);
-      if (plaintext !== null) {
-        subprocessLogger.debug("Using plaintext fallback for unparseable output");
-        return ok(
-          this.normalizeResponse(plaintext, void 0, {
-            durationMs: getTimeProvider().now() - startTime,
-            raw: stdout
-          })
-        );
-      }
-      const snippet = stdout.slice(0, 500).trim();
-      const stderrHint = stderr !== "" ? ` [stderr: ${stderr.slice(0, 300).trim()}]` : "";
-      return err(
-        this.createError("PARSE_ERROR", `Failed to parse response: ${snippet}${stderrHint}`)
-      );
+      return this.handleUnparseableOutput(stdout, stderr, startTime);
     }
     const usage = this.parser.extractUsage(stdout);
     const sessionId = this.parser.extractSessionId(stdout);
@@ -893,6 +1003,48 @@ var SubprocessCliAdapter = class extends BaseCliAdapter {
       })
     );
   }
+  /**
+   * Handles the parse-failure branch: when the CLI's structured response
+   * parser returned null. Order of recovery attempts (most-specific first):
+   *   1. Rate-limit text in raw stdout (#1320)
+   *   2. Structured CLI error envelope (#2440)
+   *   3. Plaintext fallback for natural-language output (#1401)
+   *   4. Generic PARSE_ERROR with truncated snippet
+   */
+  handleUnparseableOutput(stdout, stderr, startTime) {
+    if (isRateLimitText(stdout)) {
+      const snippet2 = stdout.slice(0, 500).trim();
+      return err(this.createError("RATE_LIMITED", snippet2));
+    }
+    const envelope = parseCliErrorEnvelope(stdout, this.name);
+    if (envelope !== null) {
+      const msg = envelope.hint !== void 0 ? `${envelope.message}
+  \u2192 ${envelope.hint}` : envelope.message;
+      subprocessLogger.debug("CLI error envelope unwrapped", {
+        cli: this.name,
+        code: envelope.code,
+        rawSanitized: sanitizeOutput(stdout)
+      });
+      return err(this.createError(envelope.code, msg));
+    }
+    const plaintext = tryPlaintextFallback(stdout);
+    if (plaintext !== null) {
+      subprocessLogger.debug("Using plaintext fallback for unparseable output", {
+        rawSanitized: sanitizeOutput(stdout)
+      });
+      return ok(
+        this.normalizeResponse(plaintext, void 0, {
+          durationMs: getTimeProvider().now() - startTime,
+          raw: stdout
+        })
+      );
+    }
+    const snippet = stdout.slice(0, 500).trim();
+    const stderrHint = stderr !== "" ? ` [stderr: ${stderr.slice(0, 300).trim()}]` : "";
+    return err(
+      this.createError("PARSE_ERROR", `Failed to parse response: ${snippet}${stderrHint}`)
+    );
+  }
   /**
    * Handles subprocess execution errors.
    */
@@ -2700,4 +2852,4 @@ export {
   isCliAvailable,
   getAvailableClis
 };
-//# sourceMappingURL=chunk-XATH462F.js.map
+//# sourceMappingURL=chunk-ES6GFP35.js.map