crewswarm 0.9.4 → 1.0.0

package/scripts/health-check.mjs

@@ -16,6 +16,8 @@ import fs   from "node:fs";
 import path from "node:path";
 import os   from "node:os";
 import { execSync } from "node:child_process";
+import http from "node:http";
+import https from "node:https";
 
 const JSON_MODE    = process.argv.includes("--json");
 const QUIET_MODE   = process.argv.includes("--quiet");
@@ -51,9 +53,31 @@ function authHeaders() {
   return { "content-type": "application/json", ...(t ? { authorization: `Bearer ${t}` } : {}) };
 }
 
+function request(url, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const transport = parsed.protocol === "https:" ? https : http;
+    const req = transport.request(parsed, {
+      method: opts.method || "GET",
+      headers: opts.headers || {},
+    }, (res) => {
+      let body = "";
+      res.setEncoding("utf8");
+      res.on("data", chunk => { body += chunk; });
+      res.on("end", () => resolve({ status: res.statusCode || 0, body, headers: res.headers }));
+    });
+
+    req.on("error", reject);
+    req.setTimeout(opts.timeout || 10000, () => req.destroy(new Error("timeout")));
+
+    if (opts.body) req.write(opts.body);
+    req.end();
+  });
+}
+
 async function ping(url, label, opts = {}) {
   try {
-    const res = await fetch(url, { signal: AbortSignal.timeout(opts.timeout || 10000), headers: authHeaders() });
+    const res = await request(url, { timeout: opts.timeout || 10000, headers: authHeaders() });
     return { ok: res.ok || res.status < 500, status: res.status };
   } catch (e) {
     return { ok: false, error: e.message };
@@ -84,7 +108,7 @@ async function run() {
   check("~/.crewswarm/crewswarm.json", hasSwarm ? "pass" : "fail", hasSwarm ? "" : "run: bash install.sh");
 
   const token = getToken();
-  check("Auth token", token ? "pass" : "fail", token ? `${token.slice(0,8)}…` : "missing rt.authToken");
+  check("Auth token", token ? "pass" : "warn", token ? `${token.slice(0,8)}…` : "no rt.authToken (optional for local dev)");
 
   // ── 2. API keys ──────────────────────────────────────────────────────────────
   section("API Keys");
@@ -127,19 +151,32 @@ async function run() {
   if (!NO_SERVICES) {
     section("Agents");
     try {
-      const res = await fetch(`${CREW_LEAD}/api/agents`, { headers: authHeaders(), signal: AbortSignal.timeout(5000) });
-      const d = await res.json();
-      const agents = d.agents || [];
-      // crew-lead /api/agents uses liveness field; dashboard /api/agents uses online/alive/liveness
-      const online = agents.filter(a => a.online || a.alive || a.liveness === "alive");
-      const coreAgents = ["crew-coder","crew-qa","crew-pm","crew-main","crew-fixer"];
-      check(`Agents online (${online.length}/${agents.length})`,
-        online.length > 0 ? "pass" : "warn",
-        online.length === 0 ? "bridges not started — run: npm run start-crew" : online.map(a => a.id?.replace("crew-","")).join(", ").slice(0,80));
-      for (const core of coreAgents) {
-        const a = agents.find(x => x.id === core);
-        const isOnline = a?.online || a?.alive || a?.liveness === "alive";
-        check(`  ${core}`, isOnline ? "pass" : "warn", isOnline ? "" : "bridge not running");
+      // Try with auth first, fall back to no-auth for local dev
+      let res = await request(`${CREW_LEAD}/api/agents`, { headers: authHeaders(), timeout: 5000 });
+      if (res.status === 401) {
+        // No token or wrong token — try the dashboard proxy which may not require auth
+        try {
+          res = await request(`${DASHBOARD}/api/agents`, { timeout: 5000 });
+        } catch { /* dashboard proxy also failed, use original 401 response */ }
+      }
+      const d = JSON.parse(res.body || "{}");
+      // Dashboard returns array directly, crew-lead returns { agents: [...] }
+      const agents = Array.isArray(d) ? d : (d.agents || []);
+      if (agents.length === 0 && d.error) {
+        // Auth required but no valid token — report agent count from bridge process list
+        const bridgeCount = (() => { try { return execSync("pgrep -f 'gateway-bridge.mjs' | wc -l", { encoding: "utf8", timeout: 2000 }).trim(); } catch { return "0"; } })();
+        check(`Agents`, bridgeCount > 0 ? "pass" : "warn", `${bridgeCount} bridge processes running (auth required for detailed status)`);
+      } else {
+        const online = agents.filter(a => a.online || a.alive || a.liveness === "online" || a.liveness === "alive");
+        const coreAgents = ["crew-coder","crew-qa","crew-pm","crew-main","crew-fixer"];
+        check(`Agents online (${online.length}/${agents.length})`,
+          online.length > 0 ? "pass" : "warn",
+          online.length === 0 ? "bridges not started — run: npm run start-crew" : online.map(a => a.id?.replace("crew-","")).join(", ").slice(0,80));
+        for (const core of coreAgents) {
+          const a = agents.find(x => x.id === core);
+          const isOnline = a?.online || a?.alive || a?.liveness === "online" || a?.liveness === "alive";
+          check(`  ${core}`, isOnline ? "pass" : "warn", isOnline ? "" : "bridge not running");
+        }
       }
     } catch (e) {
       check("Agents", "fail", `could not reach crew-lead: ${e.message}`);
@@ -150,7 +187,7 @@ async function run() {
   section("CLI Tools");
   const [cursorCli, claudeCli, opencodeCli, nodeCli] = await Promise.all([
     Promise.resolve(cliCheck("cursor --version 2>/dev/null || cursor-cli --version 2>/dev/null", "cursor")),
-    Promise.resolve(cliCheck("echo '' | timeout 3 claude --version 2>/dev/null || echo 'not found'", "claude")),
+    Promise.resolve(cliCheck("which claude 2>/dev/null && claude --version 2>/dev/null || echo 'not found'", "claude")),
     Promise.resolve(cliCheck("opencode --version 2>/dev/null || echo 'not found'", "opencode")),
     Promise.resolve(cliCheck("node --version", "node")),
   ]);
@@ -168,23 +205,23 @@ async function run() {
   if (!NO_SERVICES && mcpServer.ok) {
     section("MCP Protocol");
     try {
-      const initRes = await fetch(`${MCP_URL}/mcp`, {
+      const initRes = await request(`${MCP_URL}/mcp`, {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2024-11-05", clientInfo: { name: "health-check", version: "1.0" } } }),
-        signal: AbortSignal.timeout(4000),
+        timeout: 4000,
       });
-      const initData = await initRes.json();
+      const initData = JSON.parse(initRes.body || "{}");
       check("MCP initialize", initData?.result?.serverInfo ? "pass" : "fail",
         initData?.result?.serverInfo?.name || JSON.stringify(initData).slice(0,60));
 
-      const toolsRes = await fetch(`${MCP_URL}/mcp`, {
+      const toolsRes = await request(`${MCP_URL}/mcp`, {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} }),
-        signal: AbortSignal.timeout(4000),
+        timeout: 4000,
       });
-      const toolsData = await toolsRes.json();
+      const toolsData = JSON.parse(toolsRes.body || "{}");
       const toolCount = toolsData?.result?.tools?.length || 0;
       check(`MCP tools/list (${toolCount} tools)`, toolCount >= 5 ? "pass" : "warn",
         toolsData?.result?.tools?.map(t => t.name).join(", ").slice(0, 80));
@@ -200,17 +237,22 @@ async function run() {
   } else {
     try {
       const start = Date.now();
-      const res = await fetch(`${CREW_LEAD}/chat`, {
+      const res = await request(`${CREW_LEAD}/chat`, {
         method: "POST",
         headers: authHeaders(),
         body: JSON.stringify({ message: "say: HEALTH_OK", sessionId: "health-check" }),
-        signal: AbortSignal.timeout(15000),
+        timeout: 15000,
       });
-      const d = await res.json();
+      const d = JSON.parse(res.body || "{}");
       const elapsed = Date.now() - start;
-      const reply = d.reply || d.message || "";
-      check("crew-lead responds", reply.length > 0 ? "pass" : "fail",
-        `${Math.round(elapsed/100)/10}s — "${reply.slice(0,60)}"`);
+      if (res.status === 401) {
+        // Auth required — crew-lead is up but we can't chat without token
+        check("crew-lead responds", "pass", `up (auth required for chat test)`);
+      } else {
+        const reply = d.reply || d.message || "";
+        check("crew-lead responds", reply.length > 0 ? "pass" : "warn",
+          `${Math.round(elapsed/100)/10}s — "${reply.slice(0,60) || "(empty reply)"}"`);
+      }
     } catch (e) {
       check("crew-lead chat", "fail", e.message);
     }

package/scripts/install-docker.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # crewswarm Docker Installer — one-line setup for cloud VMs and dedicated servers
-# Usage: curl -fsSL https://raw.githubusercontent.com/your-org/crewswarm/main/scripts/install-docker.sh | bash
+# Usage: curl -fsSL https://raw.githubusercontent.com/crewswarm/crewswarm/main/scripts/install-docker.sh | bash
 
 set -e
 

package/scripts/restart-all-from-repo.sh

@@ -21,8 +21,9 @@ YELLOW='\033[0;33m'
 BOLD='\033[1m'
 RESET='\033[0m'
 
-# ── Service status tracking ──────────────────────────────────────────────────
-declare -A SVC_STATUS  # "up" or "down"
+# ── Service status tracking (bash 3.2 compatible — no associative arrays) ────
+svc_set() { eval "SVC_$(echo "$1" | tr '-' '_')=$2"; }
+svc_get() { eval "echo \${SVC_$(echo "$1" | tr '-' '_'):-unknown}"; }
 
 # ── Graceful kill: SIGTERM first, SIGKILL after 5s ────────────────────────────
 graceful_kill_pattern() {
@@ -71,14 +72,14 @@ wait_for_health() {
   while [ $attempt -lt $max_attempts ]; do
     if curl -s --max-time 2 "$url" > /dev/null 2>&1; then
       echo -e "  ${GREEN}✓${RESET} $name is up"
-      SVC_STATUS[$name]="up"
+      svc_set "$name" "up"
       return 0
     fi
     attempt=$((attempt + 1))
     sleep 1
   done
   echo -e "  ${RED}✗${RESET} $name failed to start (tried ${max_attempts}s)"
-  SVC_STATUS[$name]="down"
+  svc_set "$name" "down"
   return 1
 }
 
@@ -112,6 +113,8 @@ graceful_kill_pattern "telegram-bridge.mjs"
 graceful_kill_pattern "whatsapp-bridge.mjs"
 graceful_kill_pattern "opencode serve"
 graceful_kill_pattern "pm-loop.mjs"
+graceful_kill_pattern "node --test"        # orphaned test runners from dashboard
+graceful_kill_pattern "npx playwright"     # orphaned playwright runners
 graceful_kill_pattern "apps/vibe/server.mjs"
 graceful_kill_pattern "watch-server.mjs"
 graceful_kill_pattern "vite.*vibe"
@@ -151,11 +154,11 @@ OPENCODE_BIN="$(command -v opencode 2>/dev/null)" || OPENCODE_BIN="/usr/local/bi
 if [[ -x "$OPENCODE_BIN" ]]; then
   nohup "$OPENCODE_BIN" serve --port 4096 --hostname 127.0.0.1 >> /tmp/opencode.log 2>&1 &
   # Non-critical — don't block on health
-  SVC_STATUS["opencode"]="up"
+  svc_set "opencode" "up"
   echo "  Started (PID $!)"
 else
   echo "  (opencode not found; skip)"
-  SVC_STATUS["opencode"]="skip"
+  svc_set "opencode" "skip"
 fi
 
 # ── 2. RT daemon (port 18889) ────────────────────────────────────────────────
@@ -181,7 +184,7 @@ fi
 echo ""
 echo "Starting gateway bridges (crew-main, crew-pm, crew-coder, etc.)..."
 "$NODE" scripts/start-crew.mjs --force
-SVC_STATUS["agents"]="up"
+svc_set "agents" "up"
 sleep 1
 
 # ── 4. crew-lead (port 5010) — CRITICAL ─────────────────────────────────────
@@ -206,27 +209,27 @@ if [[ "$START_DASH" -eq 1 ]]; then
   fi
   wait_for_health "http://127.0.0.1:4319/" "dashboard" 30 || true
 else
-  SVC_STATUS["dashboard"]="skip"
+  svc_set "dashboard" "skip"
 fi
 
 # ── 6. Messaging bridges (Telegram + WhatsApp) ──────────────────────────────
 if [[ "$START_BRIDGES" -eq 1 ]]; then
   echo ""
   # Verify RT bus is still up before starting bridges
-  if [[ "${SVC_STATUS[rt-bus]:-down}" == "up" ]]; then
+  if [[ "$(svc_get rt-bus)" == "up" ]]; then
     echo "Starting Telegram bridge..."
     nohup "$NODE" "$REPO_DIR/telegram-bridge.mjs" >> /tmp/telegram-bridge.log 2>&1 &
-    SVC_STATUS["telegram"]="up"
+    svc_set "telegram" "up"
     echo "  PID: $!"
 
     echo "Starting WhatsApp bridge..."
     nohup "$NODE" "$REPO_DIR/whatsapp-bridge.mjs" >> /tmp/whatsapp-bridge.log 2>&1 &
-    SVC_STATUS["whatsapp"]="up"
+    svc_set "whatsapp" "up"
     echo "  PID: $!"
   else
     echo -e "  ${YELLOW}Skipping messaging bridges — RT bus is not up${RESET}"
-    SVC_STATUS["telegram"]="skip"
-    SVC_STATUS["whatsapp"]="skip"
+    svc_set "telegram" "skip"
+    svc_set "whatsapp" "skip"
   fi
 fi
 
@@ -238,7 +241,7 @@ if ! lsof -ti :5020 >/dev/null 2>&1; then
   wait_for_health "http://127.0.0.1:5020/health" "mcp-server" 15 || true
 else
   echo "  (already running on :5020)"
-  SVC_STATUS["mcp-server"]="up"
+  svc_set "mcp-server" "up"
 fi
 
 # ── 8. Vibe + file watcher (ports 3333, 3334) ───────────────────────────────
@@ -257,18 +260,18 @@ if [[ "$START_STUDIO" -eq 1 ]]; then
   for i in $(seq 1 10); do
     if lsof -ti :3334 >/dev/null 2>&1; then
       echo -e "  ${GREEN}✓${RESET} file watcher is up"
-      SVC_STATUS["file-watcher"]="up"
+      svc_set "file-watcher" "up"
       break
     fi
     if [[ "$i" -eq 10 ]]; then
       echo -e "  ${YELLOW}!${RESET} file watcher not detected on :3334"
-      SVC_STATUS["file-watcher"]="down"
+      svc_set "file-watcher" "down"
     fi
     sleep 1
   done
 else
-  SVC_STATUS["vibe-studio"]="skip"
-  SVC_STATUS["file-watcher"]="skip"
+  svc_set "vibe-studio" "skip"
+  svc_set "file-watcher" "skip"
 fi
 
 # ══════════════════════════════════════════════════════════════════════════════
@@ -280,7 +283,7 @@ echo -e "${BOLD}━━━ Service Summary ━━━${RESET}"
 print_status() {
   local name="$1"
   local port="$2"
-  local status="${SVC_STATUS[$name]:-unknown}"
+  local status="$(svc_get "$name")"
   case "$status" in
     up)   echo -e "  ${GREEN}✓${RESET} $name  :$port" ;;
     down) echo -e "  ${RED}✗${RESET} $name  :$port" ;;
@@ -309,12 +312,13 @@ echo "Logs: /tmp/opencode.log /tmp/opencrew-rt-daemon.log /tmp/crew-lead.log /tm
 if [[ -f "$REPO_DIR/scripts/health-check.mjs" ]]; then
   echo ""
   echo -e "${BOLD}Running health check...${RESET}"
+  sleep 2  # let services fully warm up
   "$NODE" "$REPO_DIR/scripts/health-check.mjs" --quiet 2>/dev/null || true
 fi
 
 # ── Exit code: 0 if critical services are up, 1 otherwise ────────────────────
-CREW_LEAD_OK="${SVC_STATUS[crew-lead]:-down}"
-DASHBOARD_OK="${SVC_STATUS[dashboard]:-down}"
+CREW_LEAD_OK="$(svc_get crew-lead)"
+DASHBOARD_OK="$(svc_get dashboard)"
 
 if [[ "$CREW_LEAD_OK" == "up" ]] && { [[ "$DASHBOARD_OK" == "up" ]] || [[ "$START_DASH" -eq 0 ]]; }; then
   echo ""

package/scripts/start.mjs

@@ -2,24 +2,29 @@
 /**
  * scripts/start.mjs — CrewSwarm first-run entry point
  *
- * This is the script behind `npm start`.  It validates the environment before
- * handing off to the real stack so that a brand-new user who clones the repo
- * and types `npm start` gets clear, actionable guidance rather than a stack
- * trace.
+ * This is the script behind `npm start` / `npx crewswarm`.  It validates the
+ * environment before handing off to the real stack so that a brand-new user
+ * who clones the repo and types `npm start` gets clear, actionable guidance
+ * rather than a stack trace.
  *
  * Checks performed (in order):
  *   1. Node.js version >= 20
  *   2. ~/.crewswarm/crewswarm.json exists (created by install.sh)
- *   3. ~/.crewswarm/crewswarm.json exists (created by install.sh)
+ *   3. ~/.crewswarm/config.json exists (created by install.sh)
  *   4. At least one provider with an apiKey is configured
  *
- * On success, delegates to `npm run dashboard` (the standard start target).
+ * On success:
+ *   1. Spawns start-crew.mjs in the background (RT bus + crew-lead + bridges)
+ *   2. Waits 3 seconds for services to come up
+ *   3. Starts dashboard in the foreground (the process the user sees)
+ *
+ * NOTE: `npm run dashboard` still starts only the dashboard (unchanged).
  */
 
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -63,43 +68,53 @@ success(`Node.js v${process.versions.node}`);
 // ── 2. Config directory ───────────────────────────────────────────────────────
 const CREWSWARM_DIR = path.join(os.homedir(), ".crewswarm");
 const SWARM_CFG     = path.join(CREWSWARM_DIR, "crewswarm.json");
-const SYS_CFG       = path.join(CREWSWARM_DIR, "crewswarm.json");
+const SYS_CFG       = path.join(CREWSWARM_DIR, "config.json");
 const INSTALL_SH    = path.join(ROOT, "install.sh");
 
 function tryReadJSON(p) {
   try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
 }
 
+// Bootstrap config directory + minimal config if missing — the dashboard's
+// setup wizard will guide the user through API key entry on first visit.
+let firstRun = false;
 if (!fs.existsSync(CREWSWARM_DIR)) {
-  fatal(
-    `Config directory not found: ${CREWSWARM_DIR}`,
-    `Run the installer first:\n\n  bash ${INSTALL_SH}\n\n` +
-    `Or, for a one-liner from the web:\n\n` +
-    `  bash <(curl -fsSL https://raw.githubusercontent.com/crewswarm/crewswarm/main/install.sh)`
-  );
+  fs.mkdirSync(CREWSWARM_DIR, { recursive: true });
+  info(`Created config directory: ${CREWSWARM_DIR}`);
+  firstRun = true;
 }
 
 // ── 3. crewswarm.json ─────────────────────────────────────────────────────────
 if (!fs.existsSync(SWARM_CFG)) {
-  fatal(
-    `Agent config not found: ${SWARM_CFG}`,
-    `Run the installer to create it:\n\n  bash ${INSTALL_SH}`
-  );
+  const defaultConfig = {
+    agents: [
+      { id: "crew-lead",   model: "groq/llama-3.3-70b-versatile" },
+      { id: "crew-main",   model: "groq/llama-3.3-70b-versatile" },
+      { id: "crew-coder",  model: "groq/llama-3.3-70b-versatile" },
+      { id: "crew-qa",     model: "groq/llama-3.3-70b-versatile" },
+      { id: "crew-fixer",  model: "groq/llama-3.3-70b-versatile" },
+      { id: "crew-pm",     model: "groq/llama-3.3-70b-versatile" }
+    ],
+    providers: {}
+  };
+  fs.writeFileSync(SWARM_CFG, JSON.stringify(defaultConfig, null, 2));
+  info(`Created default ${SWARM_CFG} — add API keys in the dashboard setup wizard`);
+  firstRun = true;
 }
-const swarm = tryReadJSON(SWARM_CFG);
+let swarm = tryReadJSON(SWARM_CFG);
 if (!swarm) {
   fatal(
     `Cannot parse ${SWARM_CFG} — file may be corrupt.`,
     `Check it is valid JSON, or re-run:\n\n  bash ${INSTALL_SH}`
   );
 }
-success(`crewswarm.json found`);
+success(`crewswarm.json found${firstRun ? " (first run — setup wizard will launch)" : ""}`);
 
 // ── 4. config.json ───────────────────────────────────────────────────────────
 if (!fs.existsSync(SYS_CFG)) {
-  warn(`System config not found: ${SYS_CFG}`);
-  warn(`Some features (RT bus auth, background consciousness) will be disabled.`);
-  warn(`To configure them, run:  bash ${INSTALL_SH}`);
+  const defaultSysCfg = { rt: { authToken: `local-${Date.now().toString(36)}` } };
+  fs.writeFileSync(SYS_CFG, JSON.stringify(defaultSysCfg, null, 2));
+  info(`Created default ${SYS_CFG}`);
 } else {
   const sys = tryReadJSON(SYS_CFG);
   if (!sys) {
@@ -109,6 +124,16 @@ if (!fs.existsSync(SYS_CFG)) {
   }
 }
 
+// ── Bootstrap supporting files if missing ────────────────────────────────────
+const CMD_ALLOWLIST = path.join(CREWSWARM_DIR, "cmd-allowlist.json");
+const AGENT_PROMPTS = path.join(CREWSWARM_DIR, "agent-prompts.json");
+if (!fs.existsSync(CMD_ALLOWLIST)) {
+  fs.writeFileSync(CMD_ALLOWLIST, '["npm *","node *","npx *","git *"]');
+}
+if (!fs.existsSync(AGENT_PROMPTS)) {
+  fs.writeFileSync(AGENT_PROMPTS, "{}");
+}
+
 // ── 5. Provider check ────────────────────────────────────────────────────────
 const providers = swarm.providers || {};
 const configured = Object.entries(providers).filter(([, v]) => v?.apiKey && String(v.apiKey).trim().length > 0 && !String(v.apiKey).startsWith("your-"));
@@ -130,14 +155,44 @@ if (agents.length === 0) {
 }
 info(`${agents.length} agent(s) defined`);
 
-// ── 7. Hand off to dashboard ──────────────────────────────────────────────────
+// ── 7. Start full stack ───────────────────────────────────────────────────────
+console.log("");
+divider();
+info("All checks passed — starting full CrewSwarm stack");
+divider();
+console.log("");
+
+// Step 1: Spawn start-crew.mjs in the background (RT bus + crew-lead + bridges)
+info("Launching RT bus, crew-lead, and gateway bridges…");
+const crewScript = path.join(ROOT, "scripts", "start-crew.mjs");
+const crewProc = spawn(process.execPath, [crewScript], {
+  cwd: ROOT,
+  stdio: "inherit",
+  detached: false,
+  env: process.env,
+});
+
+// Wait for start-crew.mjs to finish its synchronous setup (it exits after spawning daemons)
+await new Promise((resolve) => {
+  crewProc.on("exit", resolve);
+  crewProc.on("error", (err) => {
+    warn(`start-crew.mjs exited with error: ${err.message}`);
+    resolve();
+  });
+});
+
+// Step 2: Give the background daemons a moment to bind their ports
+info("Waiting 3 s for services to come up…");
+await new Promise((resolve) => setTimeout(resolve, 3000));
+
+// Step 3: Start dashboard in the foreground (what the user sees)
 console.log("");
 divider();
-info("All checks passed — launching dashboard on http://127.0.0.1:4319");
+console.log(bold("  All services started.  Dashboard → http://127.0.0.1:4319"));
 divider();
 console.log("");
 
-const result = spawnSync("node", [path.join(ROOT, "scripts", "dashboard.mjs")], {
+const result = spawnSync(process.execPath, [path.join(ROOT, "scripts", "dashboard.mjs")], {
   cwd: ROOT,
   stdio: "inherit",
   env: process.env,