claudeboard 2.15.2 → 2.15.4

package/agents/claude-resolver.js

@@ -0,0 +1,167 @@
+/**
+ * claude-resolver.js — Cross-platform Claude Code CLI detection
+ *
+ * Problem: On Windows, Claude Desktop installs a `claude.exe` that shadows
+ * the Claude Code CLI installed via `npm install -g @anthropic-ai/claude-code`.
+ * `which`/`where` may return the Desktop binary instead of the CLI.
+ *
+ * Strategy:
+ *   1. Honor CLAUDE_CODE_PATH env var (explicit override)
+ *   2. npm-based detection (most reliable — finds the npm-installed binary directly)
+ *   3. which/where — but validate it's not the Desktop app
+ *   4. Hardcoded platform-specific fallback paths
+ */
+
+import { execSync } from "child_process";
+import path from "path";
+import fs from "fs";
+
+const isWin = process.platform === "win32";
+const pathSep = isWin ? ";" : ":";
+
+/**
+ * Returns true if the candidate path looks like the Claude Code CLI
+ * and NOT the Claude Desktop app binary.
+ */
+function isClaudeCodePath(p) {
+  if (!p) return false;
+  const lower = p.toLowerCase().replace(/\\/g, "/");
+  // Desktop app on Windows: usually under AppData/Local/AnthropicClaude/
+  if (lower.includes("anthropicclaude")) return false;
+  if (lower.includes("anthropic claude")) return false;
+  // Desktop app on macOS: /Applications/Claude.app/...
+  if (lower.includes("claude.app/")) return false;
+  return true;
+}
+
+/**
+ * Resolves the path to the Claude Code CLI binary.
+ * Handles Windows / macOS / Linux, and the Desktop-vs-CLI shadowing conflict.
+ */
+export function resolveClaudePath() {
+  // 1. Explicit override always wins
+  if (process.env.CLAUDE_CODE_PATH) return process.env.CLAUDE_CODE_PATH;
+
+  // 2. npm global bin detection — bypasses PATH shadowing entirely
+  try {
+    const npmRoot = execSync("npm root -g", { stdio: "pipe", timeout: 5000 })
+      .toString().trim();
+    // npmRoot: /usr/local/lib/node_modules  or  C:\Users\<user>\AppData\Roaming\npm\node_modules
+    // The global bin dir is one level up from node_modules
+    const npmBinDir = path.dirname(npmRoot);
+    const candidates = isWin
+      ? [
+          path.join(npmBinDir, "claude.cmd"),
+          path.join(npmBinDir, "claude"),
+        ]
+      : [path.join(npmBinDir, "claude")];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) return c;
+    }
+  } catch {}
+
+  // 3. which / where — validate it's not the Desktop app
+  try {
+    const raw = execSync(isWin ? "where claude" : "which claude", {
+      stdio: "pipe",
+      timeout: 5000,
+    }).toString().trim();
+    // `where` on Windows may return multiple lines; take the first valid one
+    const lines = raw.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    for (const candidate of lines) {
+      if (isClaudeCodePath(candidate)) return candidate;
+    }
+  } catch {}
+
+  // 4. Hardcoded platform-specific fallback paths
+  if (isWin) {
+    const appData = process.env.APPDATA || "";
+    for (const p of [
+      path.join(appData, "npm", "claude.cmd"),
+      path.join(appData, "npm", "claude"),
+    ]) {
+      if (fs.existsSync(p)) return p;
+    }
+  } else {
+    for (const p of [
+      "/opt/homebrew/bin/claude",
+      "/usr/local/bin/claude",
+      `${process.env.HOME}/.nvm/versions/node/current/bin/claude`,
+      `${process.env.HOME}/.npm-global/bin/claude`,
+    ]) {
+      try {
+        execSync(`test -f "${p}"`, { stdio: "pipe" });
+        return p;
+      } catch {}
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Builds a cross-platform environment for subprocesses so that node/npm/npx
+ * are always resolvable inside Claude Code's shell.
+ * Also strips ANTHROPIC_API_KEY so Claude uses the user's subscription.
+ */
+export function buildEnv() {
+  // Use the current process's node binary dir — reliable on all platforms
+  const nodeBinDir = path.dirname(process.execPath);
+
+  const extraPaths = isWin
+    ? [
+        process.env.APPDATA ? path.join(process.env.APPDATA, "npm") : "",
+        process.env.LOCALAPPDATA
+          ? path.join(process.env.LOCALAPPDATA, "Microsoft", "WindowsApps")
+          : "",
+      ]
+    : [
+        "/opt/homebrew/bin",
+        "/opt/homebrew/sbin",
+        "/usr/local/bin",
+        "/usr/bin",
+        "/bin",
+        `${process.env.HOME}/.npm-global/bin`,
+        `${process.env.HOME}/.nvm/versions/node/current/bin`,
+      ];
+
+  const pathParts = [
+    process.env.PATH || "",
+    nodeBinDir,
+    ...extraPaths,
+  ].filter(Boolean);
+
+  const fullPath = [
+    ...new Set(pathParts.join(pathSep).split(pathSep).filter(Boolean)),
+  ].join(pathSep);
+
+  const env = { ...process.env, PATH: fullPath };
+  if (!isWin) env.HOME = process.env.HOME;
+  // Remove API key so Claude Code uses the Claude subscription (not API credits)
+  delete env.ANTHROPIC_API_KEY;
+  return env;
+}
+
+/**
+ * Returns a human-readable installation hint for the current platform.
+ */
+export function installHint() {
+  if (isWin) {
+    return [
+      "Claude Code CLI not found or shadowed by Claude Desktop.",
+      "",
+      "Install the CLI:  npm install -g @anthropic-ai/claude-code",
+      "Then run:         claude",
+      "",
+      "If already installed, set the explicit path to avoid conflicts:",
+      "  set CLAUDE_CODE_PATH=C:\\Users\\<you>\\AppData\\Roaming\\npm\\claude.cmd",
+      "  claudeboard run ...",
+    ].join("\n");
+  }
+  return [
+    "Claude Code CLI not found.",
+    "",
+    "Install:  npm install -g @anthropic-ai/claude-code",
+    "Then run: claude",
+  ].join("\n");
+}

package/agents/developer.js

@@ -8,47 +8,7 @@
 
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { startTask, completeTask, failTask, addLog } from "./board-client.js";
-import { execSync } from "child_process";
-
-// ── Resolve the global `claude` binary path at startup ────────────────────────
-function resolveClaudePath() {
-  if (process.env.CLAUDE_CODE_PATH) return process.env.CLAUDE_CODE_PATH;
-  try { return execSync("which claude", { stdio: "pipe" }).toString().trim(); } catch {}
-  for (const p of [
-    "/opt/homebrew/bin/claude",
-    "/usr/local/bin/claude",
-    `${process.env.HOME}/.nvm/versions/node/current/bin/claude`,
-    `${process.env.HOME}/.npm-global/bin/claude`,
-  ]) {
-    try { execSync(`test -f "${p}"`, { stdio: "pipe" }); return p; } catch {}
-  }
-  return null;
-}
-
-// ── Build a full PATH so node/npm/npx are found inside the subprocess ─────────
-// Exit code 127 = "command not found" — happens when PATH is stripped for global pkgs
-function buildEnv() {
-  let nodeBinDir = "";
-  try { nodeBinDir = execSync("dirname $(which node)", { stdio: "pipe" }).toString().trim(); } catch {}
-
-  const pathParts = [
-    process.env.PATH || "",
-    nodeBinDir,
-    "/opt/homebrew/bin",
-    "/opt/homebrew/sbin",
-    "/usr/local/bin",
-    "/usr/bin",
-    "/bin",
-    `${process.env.HOME}/.npm-global/bin`,
-    `${process.env.HOME}/.nvm/versions/node/current/bin`,
-  ].filter(Boolean);
-
-  const fullPath = [...new Set(pathParts.join(":").split(":"))].join(":");
-  const env = { ...process.env, PATH: fullPath, HOME: process.env.HOME };
-  // Remove API key so Claude Code uses the Claude subscription (not API credits)
-  delete env.ANTHROPIC_API_KEY;
-  return env;
-}
+import { resolveClaudePath, buildEnv, installHint } from "./claude-resolver.js";
 
 const CLAUDE_PATH = resolveClaudePath();
 
@@ -79,7 +39,7 @@ export async function runDeveloperAgent(task, projectPath, techStack, allTasks =
   console.log(`  🤖  Claude Code working on: ${task.title}`);
 
   if (!CLAUDE_PATH) {
-    const hint = "Claude Code CLI not found. Run: npm install -g @anthropic-ai/claude-code";
+    const hint = installHint();
     await startTask(task.id, hint);
     await failTask(task.id, hint);
     console.error(`\n  ✗ ${hint}\n`);

package/agents/expo-health.js

@@ -10,6 +10,9 @@ import { createConnection } from "net";
 import { spawn as _spawn, execSync } from "child_process";
 
 const require = createRequire(import.meta.url);
+// On Windows, npm-installed binaries have a .cmd wrapper — use it for spawn()
+const isWin = process.platform === "win32";
+const NPX = isWin ? "npx.cmd" : "npx";
 const MAX_FIX_ATTEMPTS = 5;
 const BUILD_HASH_FILE = ".claudeboard-build-hash.txt";
 const BUILD_TIMEOUT_MS = 10 * 60 * 1000; // 10 min max for expo run:ios
@@ -244,7 +247,7 @@ export async function ensureDevBuild(projectPath) {
     }, BUILD_TIMEOUT_MS);
 
     try {
-      const proc = _spawn("npx", ["expo", "run:ios", "--simulator"], {
+      const proc = _spawn(NPX, ["expo", "run:ios", "--simulator"], {
         cwd: projectPath,
         env: { ...process.env, CI: "1", EXPO_NO_INTERACTIVE: "1" },
         stdio: "pipe",
@@ -386,7 +389,7 @@ async function tryStartExpo(projectPath, port) {
         ? ["expo", "start", "--ios", "--port", String(port)]
         : ["expo", "start", "--web", "--port", String(port)];
       
-      proc = _spawn("npx", expoArgs, {
+      proc = _spawn(NPX, expoArgs, {
         cwd: projectPath,
         env: (() => { const e = { ...process.env, CI: "1", EXPO_NO_INTERACTIVE: "1", EXPO_NO_DOTENV: "0" }; delete e.ANTHROPIC_API_KEY; return e; })(),
         stdio: "pipe",

package/agents/qa.js

@@ -5,44 +5,11 @@ import { screenshotExpoWeb } from "../tools/screenshot.js";
 import { screenshotSimulator } from "./expo-health.js";
 import { callClaudeWithImage } from "./claude-api.js";
 import { listFiles, readFile } from "../tools/filesystem.js";
-import { execSync } from "child_process";
 import chalk from "chalk";
 import path from "path";
 import fs from "fs";
 import { createConnection } from "net";
-
-// ── Reuse Claude Code path + env from developer ───────────────────────────────
-function resolveClaudePath() {
-  if (process.env.CLAUDE_CODE_PATH) return process.env.CLAUDE_CODE_PATH;
-  try { return execSync("which claude", { stdio: "pipe" }).toString().trim(); } catch {}
-  for (const p of [
-    "/opt/homebrew/bin/claude",
-    "/usr/local/bin/claude",
-    `${process.env.HOME}/.nvm/versions/node/current/bin/claude`,
-    `${process.env.HOME}/.npm-global/bin/claude`,
-  ]) {
-    try { execSync(`test -f "${p}"`, { stdio: "pipe" }); return p; } catch {}
-  }
-  return null;
-}
-
-function buildEnv() {
-  let nodeBinDir = "";
-  try { nodeBinDir = execSync("dirname $(which node)", { stdio: "pipe" }).toString().trim(); } catch {}
-  const pathParts = [
-    process.env.PATH || "",
-    nodeBinDir,
-    "/opt/homebrew/bin", "/opt/homebrew/sbin",
-    "/usr/local/bin", "/usr/bin", "/bin",
-    `${process.env.HOME}/.npm-global/bin`,
-    `${process.env.HOME}/.nvm/versions/node/current/bin`,
-  ].filter(Boolean);
-  const fullPath = [...new Set(pathParts.join(":").split(":"))].join(":");
-  const env = { ...process.env, PATH: fullPath, HOME: process.env.HOME };
-  // Remove API key so Claude Code uses the Claude subscription (not API credits)
-  delete env.ANTHROPIC_API_KEY;
-  return env;
-}
+import { resolveClaudePath, buildEnv } from "./claude-resolver.js";
 
 const CLAUDE_PATH = resolveClaudePath();
 

package/bin/cli.js

@@ -16,9 +16,9 @@ const _pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "../package.json"),
 
 
 const LOGO = `
-${chalk.cyan("╔══════════════════════════════════════╗")}
-${chalk.cyan("║")}  ${chalk.bold.white("●")} ${chalk.bold.cyan("CLAUDEBOARD")}  ${chalk.dim("ai engineering highvalue team")}  ${chalk.cyan("║")}
-${chalk.cyan("╚══════════════════════════════════════╝")}
+${chalk.cyan("╔════════════════════════════════════════════╗")}
+${chalk.cyan("║")}  ${chalk.bold.white("●")} ${chalk.bold.cyan("CLAUDEBOARD")}  ${chalk.dim("powered by High Value, LLC")}  ${chalk.cyan("║")}
+${chalk.cyan("╚════════════════════════════════════════════╝")}
 `;
 
 function loadConfig() {
@@ -48,7 +48,7 @@ program
     console.log(LOGO);
     const { default: Enquirer } = await import("enquirer");
     const enquirer = new Enquirer();
-    console.log(chalk.bold("Let's set up your AI engineering team.\n"));
+    console.log(chalk.bold("Let's set up your AI engineering team — powered by High Value, LLC.\n"));
 
     const answers = await enquirer.prompt([
       { type: "input", name: "projectName", message: "Project name:", initial: path.basename(process.cwd()) },
@@ -158,18 +158,22 @@ program
 
     // ── Verify Claude Code CLI is installed ───────────────────────────────────
     const { execSync } = await import("child_process");
-    try {
-      execSync("claude --version", { stdio: "pipe" });
-      const version = execSync("claude --version", { stdio: "pipe" }).toString().trim();
-      console.log(chalk.dim(`  Claude Code → ${version}\n`));
-    } catch {
+    const { resolveClaudePath, installHint } = await import("../agents/claude-resolver.js");
+    const claudePath = resolveClaudePath();
+    if (!claudePath) {
       console.log(chalk.red("\n  ✗ Claude Code CLI not found!\n"));
-      console.log(chalk.yellow("  The developer agent requires Claude Code to be installed:"));
-      console.log(chalk.bold("    npm install -g @anthropic-ai/claude-code\n"));
-      console.log(chalk.dim("  Then authenticate:"));
-      console.log(chalk.bold("    claude\n"));
+      for (const line of installHint().split("\n")) {
+        console.log(chalk.yellow(`  ${line}`));
+      }
+      console.log();
       process.exit(1);
     }
+    try {
+      const version = execSync(`"${claudePath}" --version`, { stdio: "pipe" }).toString().trim();
+      console.log(chalk.dim(`  Claude Code → ${version}  (${claudePath})\n`));
+    } catch {
+      console.log(chalk.dim(`  Claude Code → ${claudePath}\n`));
+    }
 
     const resolvedProject = path.resolve(opts.project);
 
@@ -241,7 +245,7 @@ program
 
 program
   .name("claudeboard")
-  .description("AI engineering team — from PRD to working app, autonomously")
+  .description("AI engineering team — from PRD to working app, autonomously — powered by High Value, LLC")
   .version(_pkg.version);
 
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeboard",
-  "version": "2.15.2",
+  "version": "2.15.4",
   "description": "AI engineering team — from PRD to working mobile app, autonomously",
   "type": "module",
   "bin": {

package/tools/terminal.js

@@ -1,7 +1,9 @@
 import { exec, spawn } from "child_process";
 import { promisify } from "util";
+import { createConnection } from "net";
 
 const execAsync = promisify(exec);
+const isWin = process.platform === "win32";
 
 /**
  * Run a shell command in a given directory, return { stdout, stderr, exitCode }
@@ -12,6 +14,7 @@ export async function runCommand(cmd, cwd, timeoutMs = 60000) {
       cwd,
       timeout: timeoutMs,
       env: { ...process.env, CI: "true", FORCE_COLOR: "0" },
+      shell: isWin ? "cmd.exe" : "/bin/sh",
     });
     return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0 };
   } catch (err) {
@@ -43,15 +46,17 @@ export function startProcess(cmd, args, cwd, onLog) {
 }
 
 /**
- * Check if a port is in use
+ * Check if a port is in use — uses a TCP connection probe (cross-platform, no curl needed)
  */
 export async function waitForPort(port, timeoutMs = 30000) {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
-    try {
-      const result = await execAsync(`curl -s -o /dev/null -w "%{http_code}" http://localhost:${port}`);
-      if (result.stdout !== "000") return true;
-    } catch {}
+    const open = await new Promise((resolve) => {
+      const sock = createConnection({ port, host: "127.0.0.1" });
+      sock.once("connect", () => { sock.destroy(); resolve(true); });
+      sock.once("error", () => { sock.destroy(); resolve(false); });
+    });
+    if (open) return true;
     await new Promise((r) => setTimeout(r, 1000));
   }
   return false;