buildwithnexus 0.8.6 → 0.8.8

package/dist/bin.js

@@ -1229,8 +1229,6 @@ var TUI = class {
     );
   }
   displayBrainstormResponse(response) {
-    console.log("");
-    console.log(chalk.blue.bold("\u{1F4A1} Ideas & Analysis"));
     console.log("");
     const lines = response.split("\n");
     for (const line of lines) {
@@ -1607,10 +1605,25 @@ init_secrets();
 init_docker();
 
 // src/core/version.ts
-var resolvedVersion = true ? "0.8.6" : pkg.version;
+var resolvedVersion = true ? "0.8.8" : pkg.version;
 
 // src/cli/interactive.ts
 var appVersion = resolvedVersion;
+var SSE_STALL_WARNING_MS = 8e3;
+async function reportBackendError(label, response) {
+  let bodySnippet = "";
+  try {
+    const text = await response.text();
+    bodySnippet = text.slice(0, 300);
+  } catch {
+    bodySnippet = "(could not read response body)";
+  }
+  console.error(chalk3.red(`${label}: HTTP ${response.status} ${response.statusText}`));
+  if (bodySnippet) {
+    console.error(chalk3.gray(`  body: ${bodySnippet}`));
+  }
+  console.error(chalk3.gray("  Tip: stream backend logs with `buildwithnexus logs -f`"));
+}
 async function interactiveMode() {
   const backendUrl = process.env.BACKEND_URL || "http://localhost:4200";
   const urlCheck = validateBackendUrl(backendUrl);
@@ -1784,7 +1797,7 @@ async function planModeLoop(task, backendUrl, currentMode, ask) {
       signal: AbortSignal.timeout(12e4)
     });
     if (!response.ok) {
-      console.error(chalk3.red("Backend error \u2014 cannot fetch plan."));
+      await reportBackendError("Backend error fetching plan", response);
       return "cancel";
     }
     const planText = await response.text();
@@ -1808,27 +1821,36 @@ async function planModeLoop(task, backendUrl, currentMode, ask) {
     tui.displayConnected(run_id);
     const streamResponse = await fetch(`${backendUrl}/api/stream/${run_id}`, { signal: AbortSignal.timeout(12e4) });
     if (!streamResponse.ok) {
-      console.error(chalk3.red(`Stream endpoint returned ${streamResponse.status}`));
+      await reportBackendError("Stream endpoint error", streamResponse);
       return "cancel";
     }
     const reader = streamResponse.body?.getReader();
     if (!reader) throw new Error("No response body");
     let planReceived = false;
-    for await (const parsed of parseSSEStream(reader)) {
-      if (parsed.type === "plan") {
-        steps = parsed.data["steps"] || [];
-        planReceived = true;
-        reader.cancel();
-        break;
-      } else if (parsed.type === "error") {
-        const errorMsg = parsed.data["error"] || parsed.data["content"] || "Unknown error";
-        tui.displayError(errorMsg);
-        reader.cancel();
-        return "cancel";
+    const stallTimer = setTimeout(() => {
+      console.log(chalk3.gray(`(no events from backend after ${SSE_STALL_WARNING_MS / 1e3}s \u2014 backend may be stalled; check \`buildwithnexus logs -f\`)`));
+    }, SSE_STALL_WARNING_MS);
+    try {
+      for await (const parsed of parseSSEStream(reader)) {
+        if (parsed.type === "plan") {
+          steps = parsed.data["steps"] || [];
+          planReceived = true;
+          reader.cancel();
+          break;
+        } else if (parsed.type === "error") {
+          const errorMsg = parsed.data["error"] || parsed.data["content"] || "Unknown error";
+          tui.displayError(errorMsg);
+          reader.cancel();
+          return "cancel";
+        }
       }
+    } finally {
+      clearTimeout(stallTimer);
     }
     if (!planReceived || steps.length === 0) {
       console.log(chalk3.yellow("No plan received from backend."));
+      console.log(chalk3.gray("  This usually means the backend exited without emitting a plan event."));
+      console.log(chalk3.gray("  Check `buildwithnexus logs -f` for the underlying error."));
       steps = ["(no steps returned \u2014 execute anyway?)"];
     }
   } catch (err) {
@@ -1843,7 +1865,7 @@ async function planModeLoop(task, backendUrl, currentMode, ask) {
     if (answer === "" || answer === "y") {
       return "BUILD";
     }
-    if (answer === "n" || answer === "\x1B") {
+    if (answer === "n" || answer === "") {
       console.log(chalk3.yellow("\nExecution cancelled.\n"));
       return "cancel";
     }
@@ -1895,7 +1917,7 @@ async function buildModeLoop(task, backendUrl, currentMode, ask) {
       signal: AbortSignal.timeout(12e4)
     });
     if (!response.ok) {
-      console.error(chalk3.red("Backend error"));
+      await reportBackendError("Backend error starting run", response);
       return "done";
     }
     const buildText = await response.text();
@@ -1921,30 +1943,45 @@ async function buildModeLoop(task, backendUrl, currentMode, ask) {
     tui.displayStreamStart();
     const streamResponse = await fetch(`${backendUrl}/api/stream/${run_id}`, { signal: AbortSignal.timeout(12e4) });
     if (!streamResponse.ok) {
-      console.error(chalk3.red(`Stream endpoint returned ${streamResponse.status}`));
+      await reportBackendError("Stream endpoint error", streamResponse);
       return "done";
     }
     const reader = streamResponse.body?.getReader();
     if (!reader) throw new Error("No response body");
-    for await (const parsed of parseSSEStream(reader)) {
-      const type = parsed.type;
-      if (type === "execution_complete") {
-        const summary = parsed.data["summary"] || "";
-        const count = parsed.data["todos_completed"] || 0;
-        tui.displayResults(summary, count);
-        tui.displayComplete(tui.getElapsedTime());
-        break;
-      } else if (type === "done") {
-        tui.displayEvent(type, { content: "Task completed successfully" });
-        tui.displayComplete(tui.getElapsedTime());
-        break;
-      } else if (type === "error") {
-        const errorMsg = parsed.data["error"] || parsed.data["content"] || "Unknown error";
-        tui.displayError(errorMsg);
-        break;
-      } else if (type !== "plan") {
-        tui.displayEvent(type, parsed.data);
+    let sawTerminal = false;
+    const stallTimer = setTimeout(() => {
+      console.log(chalk3.gray(`(no events from backend after ${SSE_STALL_WARNING_MS / 1e3}s \u2014 backend may be stalled; check \`buildwithnexus logs -f\`)`));
+    }, SSE_STALL_WARNING_MS);
+    try {
+      for await (const parsed of parseSSEStream(reader)) {
+        const type = parsed.type;
+        if (type === "execution_complete") {
+          const summary = parsed.data["summary"] || "";
+          const count = parsed.data["todos_completed"] || 0;
+          tui.displayResults(summary, count);
+          tui.displayComplete(tui.getElapsedTime());
+          sawTerminal = true;
+          break;
+        } else if (type === "done") {
+          tui.displayEvent(type, { content: "Task completed successfully" });
+          tui.displayComplete(tui.getElapsedTime());
+          sawTerminal = true;
+          break;
+        } else if (type === "error") {
+          const errorMsg = parsed.data["error"] || parsed.data["content"] || "Unknown error";
+          tui.displayError(errorMsg);
+          sawTerminal = true;
+          break;
+        } else if (type !== "plan") {
+          tui.displayEvent(type, parsed.data);
+        }
       }
+    } finally {
+      clearTimeout(stallTimer);
+    }
+    if (!sawTerminal) {
+      console.log(chalk3.yellow("Stream ended without a terminal event (no execution_complete / done / error)."));
+      console.log(chalk3.gray("  The backend likely crashed mid-run. Check `buildwithnexus logs -f`."));
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -1974,7 +2011,9 @@ async function brainstormModeLoop(task, backendUrl, currentMode, ask) {
         )),
         signal: AbortSignal.timeout(12e4)
       });
-      if (response.ok) {
+      if (!response.ok) {
+        await reportBackendError("Backend error in brainstorm", response);
+      } else {
         const brainstormText = await response.text();
         let brainstormParsed;
         try {
@@ -1995,7 +2034,7 @@ async function brainstormModeLoop(task, backendUrl, currentMode, ask) {
         const run_id = brainstormRunId;
         const streamResponse = await fetch(`${backendUrl}/api/stream/${run_id}`, { signal: AbortSignal.timeout(12e4) });
         if (!streamResponse.ok) {
-          console.error(chalk3.red(`Stream endpoint returned ${streamResponse.status}`));
+          await reportBackendError("Stream endpoint error", streamResponse);
           continue;
         }
         const reader = streamResponse.body?.getReader();
@@ -2005,50 +2044,55 @@ async function brainstormModeLoop(task, backendUrl, currentMode, ask) {
         }
         let responseText = "";
         let firstEvent = true;
-        for await (const parsed of parseSSEStream(reader)) {
-          const type = parsed.type;
-          const data = parsed.data;
-          if (firstEvent && type !== "done" && type !== "error") {
-            console.log(chalk3.bold.blue("\u{1F4AD} Thinking...\n"));
-            firstEvent = false;
-          }
-          if (type === "done" || type === "execution_complete" || type === "final_result") {
-            const summary = data["summary"] || data["result"] || "";
-            if (summary) responseText = summary;
-            break;
-          } else if (type === "error") {
-            const errorMsg = data["error"] || data["content"] || "Unknown error";
-            responseText += errorMsg + "\n";
-            break;
-          } else if (type === "thought" || type === "observation") {
-            const content = data["content"] || "";
-            if (content) {
-              console.log(chalk3.gray("\u2192 " + content));
-              responseText += content + "\n";
+        const stallTimer = setTimeout(() => {
+          console.log(chalk3.gray(`(no events from backend after ${SSE_STALL_WARNING_MS / 1e3}s \u2014 backend may be stalled; check \`buildwithnexus logs -f\`)`));
+        }, SSE_STALL_WARNING_MS);
+        try {
+          for await (const parsed of parseSSEStream(reader)) {
+            const type = parsed.type;
+            const data = parsed.data;
+            if (firstEvent && type !== "done" && type !== "error") {
+              console.log(chalk3.bold.blue("\u{1F4AD} Thinking...\n"));
+              firstEvent = false;
             }
-          } else if (type === "agent_response" || type === "agent_result") {
-            const content = data["content"] || data["result"] || "";
-            if (content) responseText += content + "\n";
-          } else if (type === "action") {
-            const content = data["content"] || "";
-            if (content) {
-              console.log(chalk3.cyan("\u2699\uFE0F  " + content));
-              responseText += content + "\n";
+            if (type === "done" || type === "execution_complete" || type === "final_result") {
+              const summary = data["summary"] || data["result"] || "";
+              if (summary) responseText = summary;
+              break;
+            } else if (type === "error") {
+              const errorMsg = data["error"] || data["content"] || "Unknown error";
+              responseText += errorMsg + "\n";
+              break;
+            } else if (type === "thought" || type === "observation") {
+              const content = data["content"] || "";
+              if (content) {
+                console.log(chalk3.gray("\u2192 " + content));
+                responseText += content + "\n";
+              }
+            } else if (type === "agent_response" || type === "agent_result") {
+              const content = data["content"] || data["result"] || "";
+              if (content) responseText += content + "\n";
+            } else if (type === "action") {
+              const content = data["content"] || "";
+              if (content) {
+                console.log(chalk3.cyan("\u2699\uFE0F  " + content));
+                responseText += content + "\n";
+              }
+            } else if (type === "agent_working" || type === "started") {
+            } else if (type !== "plan") {
+              const content = data["content"] || data["response"] || "";
+              if (content) responseText += content + "\n";
             }
-          } else if (type === "agent_working" || type === "started") {
-          } else if (type !== "plan") {
-            const content = data["content"] || data["response"] || "";
-            if (content) responseText += content + "\n";
           }
+        } finally {
+          clearTimeout(stallTimer);
         }
         console.log("");
         if (responseText.trim()) {
           tui.displayBrainstormResponse(responseText.trim());
         } else {
-          console.log(chalk3.gray("(No response received from agent)"));
+          console.log(chalk3.gray("(No response received from agent \u2014 check `buildwithnexus logs -f`)"));
         }
-      } else {
-        console.log(chalk3.red("Could not reach backend for brainstorm response."));
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buildwithnexus",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "Interactive AI agent orchestrator with intent-based planning, execution, and brainstorming modes",
   "type": "module",
   "bin": {