buildwithnexus 0.7.2 → 0.7.4

package/dist/bin.js

@@ -428,6 +428,112 @@ var init_platform = __esm({
   }
 });
 
+// src/core/utils.ts
+function backoffMs(attempt) {
+  return Math.min(3e3 * Math.pow(2, attempt), 3e4);
+}
+var init_utils = __esm({
+  "src/core/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/health.ts
+var health_exports = {};
+__export(health_exports, {
+  checkHealth: () => checkHealth,
+  waitForServer: () => waitForServer
+});
+async function checkHealth(vmRunning) {
+  const status = {
+    vmRunning,
+    sshReady: false,
+    dockerReady: false,
+    serverHealthy: false,
+    tunnelUrl: null,
+    dockerVersion: null,
+    serverVersion: null,
+    diskUsagePercent: null,
+    uptimeSeconds: null,
+    lastChecked: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (!vmRunning) return status;
+  status.sshReady = true;
+  try {
+    const { stdout, code } = await dockerExec("docker version --format '{{.Server.Version}}'");
+    status.dockerReady = code === 0 && stdout.trim().length > 0;
+    if (status.dockerReady) status.dockerVersion = stdout.trim();
+  } catch {
+  }
+  try {
+    const { stdout, code } = await dockerExec("curl -sf http://localhost:4200/health");
+    status.serverHealthy = code === 0 && stdout.includes("ok");
+    if (status.serverHealthy) {
+      try {
+        const parsed = JSON.parse(stdout);
+        if (typeof parsed.version === "string") status.serverVersion = parsed.version;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  try {
+    const { stdout } = await dockerExec("df / --output=pcent | tail -1 | tr -dc '0-9'");
+    const pct = parseInt(stdout.trim(), 10);
+    if (!isNaN(pct)) status.diskUsagePercent = pct;
+  } catch {
+  }
+  try {
+    const { stdout } = await dockerExec("awk '{print int($1)}' /proc/uptime 2>/dev/null");
+    const up = parseInt(stdout.trim(), 10);
+    if (!isNaN(up)) status.uptimeSeconds = up;
+  } catch {
+  }
+  try {
+    const { stdout } = await dockerExec("cat /home/nexus/.nexus/tunnel-url.txt 2>/dev/null");
+    if (stdout.includes("https://")) {
+      status.tunnelUrl = stdout.trim();
+    }
+  } catch {
+  }
+  return status;
+}
+async function waitForServer(timeoutMs = 9e5) {
+  const start = Date.now();
+  let lastLog = 0;
+  let attempt = 0;
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const { stdout, code } = await dockerExec("curl -sf http://localhost:4200/health");
+      if (code === 0 && stdout.includes("ok")) return true;
+    } catch {
+    }
+    const elapsed = Date.now() - start;
+    if (elapsed - lastLog >= 3e4) {
+      lastLog = elapsed;
+      try {
+        const { stdout } = await dockerExec("systemctl is-active nexus 2>/dev/null || echo 'starting...'");
+        process.stderr.write(`
+  [server ${Math.round(elapsed / 1e3)}s] ${stdout.trim().slice(0, 120)}
+`);
+      } catch {
+      }
+    }
+    const delay = backoffMs(attempt++);
+    const remaining = timeoutMs - (Date.now() - start);
+    if (remaining <= 0) break;
+    await new Promise((r) => setTimeout(r, Math.min(delay, remaining)));
+  }
+  return false;
+}
+var init_health = __esm({
+  "src/core/health.ts"() {
+    "use strict";
+    init_docker();
+    init_utils();
+  }
+});
+
 // src/core/docker.ts
 var docker_exports = {};
 __export(docker_exports, {
@@ -436,6 +542,7 @@ __export(docker_exports, {
   installDocker: () => installDocker,
   isDockerInstalled: () => isDockerInstalled,
   isNexusRunning: () => isNexusRunning,
+  launchNexus: () => launchNexus,
   pullImage: () => pullImage,
   startBackend: () => startBackend,
   startNexus: () => startNexus,
@@ -811,7 +918,7 @@ async function startBackend() {
   const path11 = await import("path");
   const nexusDir = path11.join(os5.homedir(), "Projects", "nexus");
   log.step(`Starting Nexus backend from ${nexusDir}...`);
-  const child = spawn2("python", ["-m", "src.deep_agents_server"], {
+  const child = spawn2("python3", ["-m", "src.deep_agents_server"], {
     cwd: nexusDir,
     detached: true,
     stdio: "ignore",
@@ -820,6 +927,16 @@ async function startBackend() {
   child.unref();
   log.success("Nexus backend process started");
 }
+async function launchNexus(keys, config, opts) {
+  const { healthTimeoutMs = 6e4, stopExisting = true } = opts ?? {};
+  if (stopExisting && await isNexusRunning()) {
+    await stopNexus();
+  }
+  await startNexus(keys, config);
+  if (healthTimeoutMs <= 0) return true;
+  const { waitForServer: waitForServer2 } = await Promise.resolve().then(() => (init_health(), health_exports));
+  return waitForServer2(healthTimeoutMs);
+}
 async function isNexusRunning() {
   try {
     const { stdout } = await execa("docker", [
@@ -1228,6 +1345,77 @@ function validateBackendUrl(url) {
   };
 }
 
+// src/core/api.ts
+function buildRunPayload(task, agentRole, agentGoal, keys) {
+  const k = keys ?? loadApiKeys();
+  return {
+    task,
+    agent_role: agentRole,
+    agent_goal: agentGoal,
+    api_key: k.anthropic || "",
+    openai_api_key: k.openai || "",
+    google_api_key: k.google || ""
+  };
+}
+async function httpPost(httpPort, path11, body, timeoutMs = 6e4) {
+  const res = await fetch(`http://localhost:${httpPort}${path11}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) throw new Error(`Server returned ${res.status}`);
+  const text = await res.text();
+  try {
+    const parsed = JSON.parse(text);
+    return parsed.response ?? parsed.message ?? text;
+  } catch {
+    return text;
+  }
+}
+async function httpGet(httpPort, path11, timeoutMs = 1e4) {
+  try {
+    const res = await fetch(`http://localhost:${httpPort}${path11}`, {
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    const text = await res.text();
+    return { ok: res.ok, text };
+  } catch {
+    return { ok: false, text: "" };
+  }
+}
+async function checkServerHealth(target, timeoutMs = 1e4) {
+  const url = typeof target === "number" ? `http://localhost:${target}/health` : `${target}/health`;
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/sse-parser.ts
+async function* parseSSEStream(reader) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      try {
+        const parsed = JSON.parse(line.slice(6));
+        yield parsed;
+      } catch (e) {
+        if (process.env.LOG_LEVEL === "debug") console.error("SSE parse error:", e);
+      }
+    }
+  }
+}
+
 // src/cli/run-command.ts
 async function runCommand(task, options) {
   const backendUrl = process.env.BACKEND_URL || "http://localhost:4200";
@@ -1240,30 +1428,17 @@ ${urlCheck.error}`);
   tui.displayHeader(task, options.agent);
   tui.displayConnecting();
   try {
-    let healthOk = false;
-    try {
-      const healthResponse = await fetch(`${backendUrl}/health`);
-      healthOk = healthResponse.ok;
-    } catch {
-    }
-    if (!healthOk) {
+    if (!await checkServerHealth(backendUrl)) {
       console.error(
         "Backend not responding. Start it with:\n   buildwithnexus server"
       );
       process.exit(1);
     }
-    const keys = loadApiKeys();
+    const payload = buildRunPayload(task, options.agent, options.goal || "");
     const response = await fetch(`${backendUrl}/api/run`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        task,
-        agent_role: options.agent,
-        agent_goal: options.goal || "",
-        api_key: keys.anthropic || "",
-        openai_api_key: keys.openai || "",
-        google_api_key: keys.google || ""
-      })
+      body: JSON.stringify(payload)
     });
     if (!response.ok) {
       console.error("Backend error");
@@ -1415,32 +1590,13 @@ function classifyIntent(task) {
 
 // src/cli/interactive.ts
 init_secrets();
+init_docker();
 
-// src/core/sse-parser.ts
-async function* parseSSEStream2(reader) {
-  const decoder = new TextDecoder();
-  let buffer = "";
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() || "";
-    for (const line of lines) {
-      if (!line.startsWith("data: ")) continue;
-      try {
-        const parsed = JSON.parse(line.slice(6));
-        yield parsed;
-      } catch (e) {
-        if (process.env.LOG_LEVEL === "debug") console.error("SSE parse error:", e);
-      }
-    }
-  }
-}
+// src/core/version.ts
+var resolvedVersion = true ? "0.7.4" : pkg.version;
 
 // src/cli/interactive.ts
-init_docker();
-var appVersion = true ? "0.7.2" : pkg.version;
+var appVersion = resolvedVersion;
 async function interactiveMode() {
   const backendUrl = process.env.BACKEND_URL || "http://localhost:4200";
   const urlCheck = validateBackendUrl(backendUrl);
@@ -1479,26 +1635,11 @@ ${urlCheck.error}`));
   async function waitForBackend() {
     for (let i = 0; i < 5; i++) {
       await new Promise((resolve) => setTimeout(resolve, 2e3));
-      try {
-        const retryResponse = await fetch(`${backendUrl}/health`, { signal: AbortSignal.timeout(1e4) });
-        if (retryResponse.ok) return true;
-      } catch {
-      }
+      if (await checkServerHealth(backendUrl)) return true;
     }
     return false;
   }
-  try {
-    const response = await fetch(`${backendUrl}/health`, { signal: AbortSignal.timeout(1e4) });
-    if (!response.ok) {
-      console.log(chalk3.yellow("\u26A0\uFE0F  Backend not responding, starting..."));
-      await startBackend();
-      const ready = await waitForBackend();
-      if (!ready) {
-        console.error(chalk3.red("\u274C Backend failed to start. Run: buildwithnexus server"));
-        process.exit(1);
-      }
-    }
-  } catch {
+  if (!await checkServerHealth(backendUrl)) {
     console.log(chalk3.yellow("\u26A0\uFE0F  Backend not accessible, attempting to start..."));
     await startBackend();
     const ready = await waitForBackend();
@@ -1619,25 +1760,45 @@ async function planModeLoop(task, backendUrl, ask) {
   console.log("");
   console.log(chalk3.yellow("\u23F3 Fetching plan from backend..."));
   let steps = [];
-  const keys = loadApiKeys();
   try {
     const response = await fetch(`${backendUrl}/api/run`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ task, agent_role: "engineer", agent_goal: "", api_key: keys.anthropic || "", openai_api_key: keys.openai || "", google_api_key: keys.google || "" }),
+      body: JSON.stringify(buildRunPayload(task, "engineer", "")),
       signal: AbortSignal.timeout(12e4)
     });
     if (!response.ok) {
       console.error(chalk3.red("Backend error \u2014 cannot fetch plan."));
       return "cancel";
     }
-    const { run_id } = await response.json();
+    const planText = await response.text();
+    let planParsed;
+    try {
+      planParsed = JSON.parse(planText);
+    } catch {
+      console.error(chalk3.red(`Backend returned invalid JSON: ${planText.slice(0, 200)}`));
+      return "cancel";
+    }
+    const { run_id: planRunId } = planParsed;
+    if (!planRunId || typeof planRunId !== "string") {
+      console.error(chalk3.red("Backend did not return a valid run ID"));
+      return "cancel";
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(planRunId)) {
+      console.error(chalk3.red("Backend returned run ID with invalid characters"));
+      return "cancel";
+    }
+    const run_id = planRunId;
     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}`));
+      return "cancel";
+    }
     const reader = streamResponse.body?.getReader();
     if (!reader) throw new Error("No response body");
     let planReceived = false;
-    for await (const parsed of parseSSEStream2(reader)) {
+    for await (const parsed of parseSSEStream(reader)) {
       if (parsed.type === "plan") {
         steps = parsed.data["steps"] || [];
         planReceived = true;
@@ -1710,26 +1871,46 @@ async function editPlanSteps(steps, ask) {
 async function buildModeLoop(task, backendUrl, ask) {
   console.log(chalk3.bold("Task:"), chalk3.white(task));
   tui.displayConnecting();
-  const keys = loadApiKeys();
   try {
     const response = await fetch(`${backendUrl}/api/run`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ task, agent_role: "engineer", agent_goal: "", api_key: keys.anthropic || "", openai_api_key: keys.openai || "", google_api_key: keys.google || "" }),
+      body: JSON.stringify(buildRunPayload(task, "engineer", "")),
       signal: AbortSignal.timeout(12e4)
     });
     if (!response.ok) {
       console.error(chalk3.red("Backend error"));
       return "done";
     }
-    const { run_id } = await response.json();
+    const buildText = await response.text();
+    let buildParsed;
+    try {
+      buildParsed = JSON.parse(buildText);
+    } catch {
+      console.error(chalk3.red(`Backend returned invalid JSON: ${buildText.slice(0, 200)}`));
+      return "done";
+    }
+    const { run_id: buildRunId } = buildParsed;
+    if (!buildRunId || typeof buildRunId !== "string") {
+      console.error(chalk3.red("Backend did not return a valid run ID"));
+      return "done";
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(buildRunId)) {
+      console.error(chalk3.red("Backend returned run ID with invalid characters"));
+      return "done";
+    }
+    const run_id = buildRunId;
     tui.displayConnected(run_id);
     console.log(chalk3.bold.green("\u2699\uFE0F  Executing..."));
     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}`));
+      return "done";
+    }
     const reader = streamResponse.body?.getReader();
     if (!reader) throw new Error("No response body");
-    for await (const parsed of parseSSEStream2(reader)) {
+    for await (const parsed of parseSSEStream(reader)) {
       const type = parsed.type;
       if (type === "execution_complete") {
         const summary = parsed.data["summary"] || "";
@@ -1768,58 +1949,77 @@ async function brainstormModeLoop(task, backendUrl, ask) {
   while (true) {
     console.log(chalk3.bold.blue("\u{1F4A1} Thinking..."));
     try {
-      const keys = loadApiKeys();
       const response = await fetch(`${backendUrl}/api/run`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          task: currentQuestion,
-          agent_role: "brainstorm",
-          agent_goal: "Generate ideas, considerations, and suggestions. Be concise and helpful.",
-          api_key: keys.anthropic || "",
-          openai_api_key: keys.openai || "",
-          google_api_key: keys.google || ""
-        }),
+        body: JSON.stringify(buildRunPayload(
+          currentQuestion,
+          "brainstorm",
+          "Generate ideas, considerations, and suggestions. Be concise and helpful."
+        )),
         signal: AbortSignal.timeout(12e4)
       });
       if (response.ok) {
-        const { run_id } = await response.json();
+        const brainstormText = await response.text();
+        let brainstormParsed;
+        try {
+          brainstormParsed = JSON.parse(brainstormText);
+        } catch {
+          console.error(chalk3.red(`Backend returned invalid JSON: ${brainstormText.slice(0, 200)}`));
+          continue;
+        }
+        const { run_id: brainstormRunId } = brainstormParsed;
+        if (!brainstormRunId || typeof brainstormRunId !== "string") {
+          console.error(chalk3.red("Backend did not return a valid run ID"));
+          continue;
+        }
+        if (!/^[a-zA-Z0-9_-]+$/.test(brainstormRunId)) {
+          console.error(chalk3.red("Backend returned run ID with invalid characters"));
+          continue;
+        }
+        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}`));
+          continue;
+        }
         const reader = streamResponse.body?.getReader();
-        if (reader) {
-          let responseText = "";
-          for await (const parsed of parseSSEStream2(reader)) {
-            const type = parsed.type;
-            const data = parsed.data;
-            if (type === "done" || type === "execution_complete") {
-              const summary = data["summary"] || "";
-              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) 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) responseText += content + "\n";
-            } else if (type === "agent_working") {
-            } else if (type !== "plan") {
-              const content = data["content"] || data["response"] || "";
-              if (content) responseText += content + "\n";
-            }
-          }
-          if (responseText.trim()) {
-            tui.displayBrainstormResponse(responseText.trim());
-          } else {
-            console.log(chalk3.gray("(No response received from agent)"));
+        if (!reader) {
+          console.error(chalk3.red("No response body from agent"));
+          continue;
+        }
+        let responseText = "";
+        for await (const parsed of parseSSEStream(reader)) {
+          const type = parsed.type;
+          const data = parsed.data;
+          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) 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) 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";
           }
         }
+        if (responseText.trim()) {
+          tui.displayBrainstormResponse(responseText.trim());
+        } else {
+          console.log(chalk3.gray("(No response received from agent)"));
+        }
       } else {
         console.log(chalk3.red("Could not reach backend for brainstorm response."));
       }
@@ -2021,26 +2221,6 @@ async function withSpinner(spinner, label, fn) {
   succeed(spinner, label);
   return result;
 }
-async function waitForHealthy(port, timeoutMs = 12e4) {
-  const start = Date.now();
-  let attempt = 0;
-  const backoffMs = (n) => Math.min(2e3 * Math.pow(2, n), 1e4);
-  while (Date.now() - start < timeoutMs) {
-    try {
-      const res = await fetch(`http://localhost:${port}/health`);
-      if (res.ok) {
-        const body = await res.text();
-        if (body.includes("ok")) return true;
-      }
-    } catch {
-    }
-    const delay = backoffMs(attempt++);
-    const remaining = timeoutMs - (Date.now() - start);
-    if (remaining <= 0) break;
-    await new Promise((r) => setTimeout(r, Math.min(delay, remaining)));
-  }
-  return false;
-}
 var phases = [
   // Phase 1 — Configuration (~30s)
   {
@@ -2120,19 +2300,16 @@ var phases = [
     name: "Launch",
     run: async (ctx, spinner) => {
       const { config, keys } = ctx;
-      const alreadyRunning = await isNexusRunning();
-      if (alreadyRunning) {
-        await withSpinner(spinner, "Stopping existing NEXUS container...", () => stopNexus());
-      }
       await withSpinner(
         spinner,
         "Starting NEXUS container...",
-        () => startNexus(
+        () => launchNexus(
           {
             anthropic: keys.ANTHROPIC_API_KEY,
             openai: keys.OPENAI_API_KEY || ""
           },
-          { port: config.httpPort }
+          { port: config.httpPort },
+          { healthTimeoutMs: 0, stopExisting: true }
         )
       );
       ctx.containerStarted = true;
@@ -2145,7 +2322,8 @@ var phases = [
       const { config } = ctx;
       spinner.text = `Waiting for NEXUS server on port ${config.httpPort}...`;
       spinner.start();
-      const healthy = await waitForHealthy(config.httpPort);
+      const { waitForServer: waitForServer2 } = await Promise.resolve().then(() => (init_health(), health_exports));
+      const healthy = await waitForServer2(12e4);
       if (!healthy) {
         fail(spinner, "Server failed to start within 120s");
         log.warn("Check logs: docker logs nexus");
@@ -2167,11 +2345,11 @@ var phases = [
       await withSpinner(
         spinner,
         "Installing cloudflared...",
-        () => installCloudflared(config.httpPort, platform.arch)
+        () => installCloudflared(platform.arch)
       );
       spinner.text = "Starting tunnel...";
       spinner.start();
-      const url = await startTunnel(config.httpPort);
+      const url = await startTunnel();
       if (url) {
         ctx.tunnelUrl = url;
         succeed(spinner, `Tunnel active: ${url}`);
@@ -2231,40 +2409,6 @@ import { Command as Command3 } from "commander";
 init_logger();
 init_secrets();
 init_docker();
-
-// src/core/health.ts
-init_docker();
-async function waitForServer(timeoutMs = 9e5) {
-  const start = Date.now();
-  let lastLog = 0;
-  let attempt = 0;
-  const backoffMs = (n) => Math.min(3e3 * Math.pow(2, n), 3e4);
-  while (Date.now() - start < timeoutMs) {
-    try {
-      const { stdout, code } = await dockerExec("curl -sf http://localhost:4200/health");
-      if (code === 0 && stdout.includes("ok")) return true;
-    } catch {
-    }
-    const elapsed = Date.now() - start;
-    if (elapsed - lastLog >= 3e4) {
-      lastLog = elapsed;
-      try {
-        const { stdout } = await dockerExec("systemctl is-active nexus 2>/dev/null || echo 'starting...'");
-        process.stderr.write(`
-  [server ${Math.round(elapsed / 1e3)}s] ${stdout.trim().slice(0, 120)}
-`);
-      } catch {
-      }
-    }
-    const delay = backoffMs(attempt++);
-    const remaining = timeoutMs - (Date.now() - start);
-    if (remaining <= 0) break;
-    await new Promise((r) => setTimeout(r, Math.min(delay, remaining)));
-  }
-  return false;
-}
-
-// src/commands/start.ts
 var startCommand = new Command3("start").description("Start the NEXUS runtime").action(async () => {
   const config = loadConfig();
   if (!config) {
@@ -2275,25 +2419,25 @@ var startCommand = new Command3("start").description("Start the NEXUS runtime").
     log.success("NEXUS is already running");
     return;
   }
-  let spinner = createSpinner("Pulling NEXUS image...");
+  let spinner = createSpinner("Checking NEXUS image...");
   spinner.start();
-  await pullImage("buildwithnexus/nexus", "latest");
+  const localExists = await imageExistsLocally("buildwithnexus/nexus", "latest");
+  if (!localExists) {
+    spinner.text = "Pulling NEXUS image...";
+    await pullImage("buildwithnexus/nexus", "latest");
+  }
   succeed(spinner, "Image ready");
-  spinner = createSpinner("Starting NEXUS container...");
-  spinner.start();
   const keys = loadKeys();
   if (!keys) {
-    fail(spinner, "No API keys found. Run: buildwithnexus init");
+    log.error("No API keys found. Run: buildwithnexus init");
     process.exit(1);
   }
-  await startNexus(
+  spinner = createSpinner("Starting NEXUS container...");
+  spinner.start();
+  const ok = await launchNexus(
     { anthropic: keys.ANTHROPIC_API_KEY, openai: keys.OPENAI_API_KEY || "" },
     { port: config.httpPort }
   );
-  succeed(spinner, "Container started");
-  spinner = createSpinner("Waiting for NEXUS server...");
-  spinner.start();
-  const ok = await waitForServer(6e4);
   if (ok) {
     succeed(spinner, "NEXUS server running");
   } else {
@@ -2314,13 +2458,11 @@ var startCommand = new Command3("start").description("Start the NEXUS runtime").
 
 // src/commands/stop.ts
 import { Command as Command4 } from "commander";
+import { execa as execa3 } from "execa";
 init_logger();
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
 async function containerExists() {
   try {
-    const { stdout } = await execFileAsync("docker", [
+    const { stdout } = await execa3("docker", [
       "ps",
       "-a",
       "--filter",
@@ -2335,7 +2477,7 @@ async function containerExists() {
 }
 async function isContainerRunning() {
   try {
-    const { stdout } = await execFileAsync("docker", [
+    const { stdout } = await execa3("docker", [
       "ps",
       "--filter",
       "name=^nexus$",
@@ -2359,10 +2501,10 @@ var stopCommand = new Command4("stop").description("Gracefully shut down the NEX
   try {
     if (await isContainerRunning()) {
       spinner.text = "Stopping container...";
-      await execFileAsync("docker", ["stop", "nexus"]);
+      await execa3("docker", ["stop", "nexus"]);
     }
     spinner.text = "Removing container...";
-    await execFileAsync("docker", ["rm", "nexus"]);
+    await execa3("docker", ["rm", "nexus"]);
     succeed(spinner, "NEXUS container stopped and removed");
   } catch (err) {
     fail(spinner, "Failed to stop NEXUS container");
@@ -2506,11 +2648,11 @@ var doctorCommand = new Command6("doctor").description("Diagnose NEXUS runtime e
 // src/commands/logs.ts
 init_logger();
 import { Command as Command7 } from "commander";
-import { execa as execa3 } from "execa";
+import { execa as execa4 } from "execa";
 var logsCommand = new Command7("logs").description("View NEXUS server logs").action(async () => {
   let containerExists2 = false;
   try {
-    const { stdout } = await execa3("docker", [
+    const { stdout } = await execa4("docker", [
       "ps",
       "-a",
       "--filter",
@@ -2527,7 +2669,7 @@ var logsCommand = new Command7("logs").description("View NEXUS server logs").act
     log.error("NEXUS container not found. Start with: buildwithnexus start");
     process.exit(1);
   }
-  const proc = execa3("docker", ["logs", "-f", "nexus"], {
+  const proc = execa4("docker", ["logs", "-f", "nexus"], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -2544,7 +2686,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 init_logger();
 init_secrets();
 init_docker();
-import { execa as execa4 } from "execa";
+import { execa as execa5 } from "execa";
 function getReleaseTarball() {
   const dir = path6.dirname(fileURLToPath2(import.meta.url));
   const tarballPath = path6.join(dir, "nexus-release.tar.gz");
@@ -2566,7 +2708,7 @@ var updateCommand = new Command8("update").description("Update NEXUS to the late
   let spinner = createSpinner("Uploading release tarball...");
   spinner.start();
   const tarballPath = getReleaseTarball();
-  await execa4("docker", ["cp", tarballPath, "nexus:/tmp/nexus-release.tar.gz"]);
+  await execa5("docker", ["cp", tarballPath, "nexus:/tmp/nexus-release.tar.gz"]);
   succeed(spinner, "Tarball uploaded");
   spinner = createSpinner("Stopping NEXUS server...");
   spinner.start();
@@ -2720,7 +2862,7 @@ keysCommand.command("set <key>").description("Set or update an API key (e.g. ANT
 init_logger();
 init_docker();
 import { Command as Command11 } from "commander";
-import { execa as execa5 } from "execa";
+import { execa as execa6 } from "execa";
 var sshCommand = new Command11("ssh").description("Open an interactive shell inside the NEXUS container").action(async () => {
   const running = await isNexusRunning();
   if (!running) {
@@ -2728,7 +2870,7 @@ var sshCommand = new Command11("ssh").description("Open an interactive shell ins
     process.exit(1);
   }
   log.dim("Opening shell in NEXUS container...");
-  await execa5("docker", ["exec", "-it", "nexus", "/bin/bash"], { stdio: "inherit" });
+  await execa6("docker", ["exec", "-it", "nexus", "/bin/bash"], { stdio: "inherit" });
 });
 
 // src/commands/brainstorm.ts
@@ -2776,13 +2918,7 @@ var brainstormCommand = new Command12("brainstorm").description("Brainstorm an i
     }
     const spinner = createSpinner("Connecting to NEXUS...");
     spinner.start();
-    let healthOk = false;
-    try {
-      const healthRes = await fetch(`http://localhost:${config.httpPort}/health`);
-      const healthText = await healthRes.text();
-      healthOk = healthRes.ok && healthText.includes("ok");
-    } catch {
-    }
+    const healthOk = await checkServerHealth(config.httpPort);
     if (!healthOk) {
       fail(spinner, "NEXUS server is not healthy");
       log.warn("Check status: buildwithnexus status");
@@ -3303,33 +3439,6 @@ var EventStream = class {
 };
 
 // src/commands/shell.ts
-async function httpPost(httpPort, path11, body) {
-  const res = await fetch(`http://localhost:${httpPort}${path11}`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(6e4)
-  });
-  if (!res.ok) throw new Error(`Server returned ${res.status}`);
-  const text = await res.text();
-  try {
-    const parsed = JSON.parse(text);
-    return parsed.response ?? parsed.message ?? text;
-  } catch {
-    return text;
-  }
-}
-async function httpGet(httpPort, path11) {
-  try {
-    const res = await fetch(`http://localhost:${httpPort}${path11}`, {
-      signal: AbortSignal.timeout(1e4)
-    });
-    const text = await res.text();
-    return { ok: res.ok, text };
-  } catch {
-    return { ok: false, text: "" };
-  }
-}
 async function sendMessage2(httpPort, message) {
   return httpPost(httpPort, "/message", { message, source: "shell" });
 }
@@ -3563,12 +3672,12 @@ var shellCommand2 = new Command14("shell").description("Launch the interactive N
       name: "logs",
       description: "Show recent container logs",
       handler: async () => {
-        const { execa: execa6 } = await import("execa");
+        const { execa: execa7 } = await import("execa");
         console.log("");
         console.log(chalk16.bold("  Recent Logs:"));
         console.log(chalk16.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
         try {
-          const { stdout } = await execa6("docker", ["logs", "--tail", "30", "nexus"]);
+          const { stdout } = await execa7("docker", ["logs", "--tail", "30", "nexus"]);
           for (const line of redact(stdout).split("\n")) {
             console.log(chalk16.dim("  " + line));
           }
@@ -3582,10 +3691,10 @@ var shellCommand2 = new Command14("shell").description("Launch the interactive N
       name: "exec",
       description: "Drop into the container shell for debugging/inspection",
       handler: async () => {
-        const { execa: execa6 } = await import("execa");
+        const { execa: execa7 } = await import("execa");
         eventStream.stop();
         try {
-          await execa6("docker", ["exec", "-it", "nexus", "/bin/sh"], { stdio: "inherit" });
+          await execa7("docker", ["exec", "-it", "nexus", "/bin/sh"], { stdio: "inherit" });
         } catch {
         }
         eventStream.start();
@@ -3845,7 +3954,7 @@ import os4 from "os";
 import path10 from "path";
 var homeEnvPath = path10.join(os4.homedir(), ".env.local");
 dotenv2.config({ path: homeEnvPath });
-var version = true ? "0.7.2" : pkg.version;
+var version = resolvedVersion;
 checkForUpdates(version);
 program.name("buildwithnexus").description("Nexus - AI-Powered Task Execution").version(version);
 program.command("da-init").description("Initialize Nexus (set up API keys and .env.local)").action(deepAgentsInitCommand);

package/dist/deep-agents-bin.js

@@ -231,6 +231,19 @@ function loadApiKeys() {
   return result;
 }
 
+// src/core/api.ts
+function buildRunPayload(task, agentRole, agentGoal, keys) {
+  const k = keys ?? loadApiKeys();
+  return {
+    task,
+    agent_role: agentRole,
+    agent_goal: agentGoal,
+    api_key: k.anthropic || "",
+    openai_api_key: k.openai || "",
+    google_api_key: k.google || ""
+  };
+}
+
 // src/core/models.ts
 var MODELS = {
   OPUS: "claude-opus-4-6",
@@ -256,18 +269,11 @@ Starting Nexus Workflow
   console.log(`  Backend: ${backendUrl}
 `);
   try {
-    const keys = loadApiKeys();
+    const payload = buildRunPayload(task, options.agent, options.goal || "");
     const response = await fetch(`${backendUrl}/api/run`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        task,
-        agent_role: options.agent,
-        agent_goal: options.goal || "",
-        api_key: keys.anthropic || "",
-        openai_api_key: keys.openai || "",
-        google_api_key: keys.google || ""
-      })
+      body: JSON.stringify(payload)
     });
     const { run_id } = await response.json();
     console.log(`Run ID: ${run_id}

package/package.json

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