crewswarm 0.9.4 → 1.0.0

package/scripts/dashboard.mjs

@@ -132,9 +132,21 @@ const OAUTH_TOKEN_TTL_MS = 25 * 60 * 1000; // 25 minutes (tokens typically expir
 // Capture execFileSync at module load for sync token refresh
 const { execFileSync: _oauthExecFileSync } = await import("node:child_process");
 
+function getKeychainAccountCandidates() {
+  const candidates = [
+    process.env.CLAUDE_CODE_ACCOUNT,
+    process.env.USER,
+    process.env.LOGNAME,
+  ];
+  try {
+    candidates.unshift(os.userInfo().username);
+  } catch { /* os user lookup can fail in restricted environments */ }
+  return [...new Set(candidates.filter(Boolean))];
+}
+
 function refreshAnthropicOAuthToken() {
   try {
-    for (const acct of [os.userInfo().username, "jeffhobbs", "unknown"]) {
+    for (const acct of getKeychainAccountCandidates()) {
       try {
         const raw = _oauthExecFileSync("security", [
           "find-generic-password", "-s", "Claude Code-credentials", "-a", acct, "-w"
@@ -152,7 +164,7 @@ function refreshAnthropicOAuthToken() {
 
 // Initial load at startup
 try {
-  for (const acct of [os.userInfo().username, "jeffhobbs", "unknown"]) {
+  for (const acct of getKeychainAccountCandidates()) {
     try {
       const raw = _oauthExecFileSync("security", [
         "find-generic-password", "-s", "Claude Code-credentials", "-a", acct, "-w"
@@ -1581,16 +1593,34 @@ const server = http.createServer(async (req, res) => {
         // by inspecting run.json test_command
         async function detectSuite(runDir) {
           try {
-            const r = JSON.parse(await fs.promises.readFile(path.join(runDir, "run.json"), "utf8"));
-            const cmd = r.test_command || "";
+            // Try run.json first
+            let cmd = "";
+            try {
+              const r = JSON.parse(await fs.promises.readFile(path.join(runDir, "run.json"), "utf8"));
+              cmd = r.test_command || "";
+            } catch {
+              // No run.json — try to infer from directory contents
+              try {
+                const ents = await fs.promises.readdir(runDir);
+                const testDirs = ents.filter(e => !e.endsWith(".json") && !e.startsWith("."));
+                // Check first test dir name for suite hint
+                const first = testDirs[0] || "";
+                if (first.includes("test-e2e-")) return "e2e";
+                if (first.includes("test-integration-")) return "integration";
+                if (first.includes("test-unit-")) return "unit";
+                if (first.includes("spec-")) return "playwright";
+              } catch {}
+              return "unknown";
+            }
+            if (cmd.includes("test:playwright") || cmd.includes("playwright test")) return "playwright";
             if (cmd.includes("test/e2e/") || cmd.includes("test:e2e")) return "e2e";
             if (cmd.includes("test/integration/")) return "integration";
             if (cmd.includes("test/unit/")) {
-              // If it has ONLY unit tests, it's a unit run; if mixed, it's "all"
               if (cmd.includes("test/integration/") || cmd.includes("test/e2e/")) return "all";
               return "unit";
             }
-            // Check file count heuristic: >100 files = probably "all"
+            if (cmd.includes("test:all")) return "all";
+            if (cmd.includes("crew-cli") || cmd.includes("--prefix crew-cli")) return "crew-cli";
             const fileCount = (cmd.match(/\.test\.mjs/g) || []).length;
             if (fileCount > 100) return "all";
             if (fileCount > 15) return "unit";
@@ -1699,7 +1729,7 @@ const server = http.createServer(async (req, res) => {
           let count = 0;
           try {
             for (const ent of await fs.promises.readdir(dir, { withFileTypes: true })) {
-              if (ent.isDirectory()) { count += countTestCallsRecursive(path.join(dir, ent.name)); continue; }
+              if (ent.isDirectory()) { count += await countTestCallsRecursive(path.join(dir, ent.name)); continue; }
               if (!ent.name.match(/\.test\./)) continue;
               const src = await fs.promises.readFile(path.join(dir, ent.name), "utf8");
               const matches = src.match(/^\s*(test|it)\s*\(/gm);
@@ -1708,13 +1738,22 @@ const server = http.createServer(async (req, res) => {
           } catch {}
           return count;
         }
+        const [unitTests, intTests, e2eTests, pwTests, cliTests1, cliTests2, rootTests] = await Promise.all([
+          countTestCalls(path.join(testFileDir, "unit"), /\.test\.mjs$/),
+          countTestCalls(path.join(testFileDir, "integration"), /\.test\.mjs$/),
+          countTestCalls(path.join(testFileDir, "e2e"), /\.test\.mjs$/),
+          countTestCalls(testsE2eDir, /\.spec\.js$/),
+          countTestCallsRecursive(crewCliTestDir),
+          countTestCallsRecursive(crewCliTestDir2),
+          countTestCalls(testFileDir, /\.test\./),
+        ]);
         const testCounts = {
-          unit: countTestCalls(path.join(testFileDir, "unit"), /\.test\.mjs$/),
-          integration: countTestCalls(path.join(testFileDir, "integration"), /\.test\.mjs$/),
-          e2e: countTestCalls(path.join(testFileDir, "e2e"), /\.test\.mjs$/),
-          playwright: countTestCalls(testsE2eDir, /\.spec\.js$/),
-          "crew-cli": countTestCallsRecursive(crewCliTestDir) + countTestCallsRecursive(crewCliTestDir2),
-          root: countTestCalls(testFileDir, /\.test\./),
+          unit: unitTests,
+          integration: intTests,
+          e2e: e2eTests,
+          playwright: pwTests,
+          "crew-cli": cliTests1 + cliTests2,
+          root: rootTests,
         };
         res.writeHead(200, { "content-type": "application/json" });
         res.end(JSON.stringify({
@@ -1745,22 +1784,38 @@ const server = http.createServer(async (req, res) => {
               const s = JSON.parse(await fs.promises.readFile(summaryFile, "utf8"));
               entry = { runId: d, timestamp: s.timestamp, status: s.status || (s.failed > 0 ? "failed" : "passed"), passed: s.passed || 0, failed: s.failed || 0, skipped: s.skipped || 0, total: s.total || 0, duration_ms: s.duration_ms || 0 };
             } else {
-              const runMeta = JSON.parse(await fs.promises.readFile(path.join(runDir, "run.json"), "utf8"));
+              let timestamp = null;
+              try { const runMeta = JSON.parse(await fs.promises.readFile(path.join(runDir, "run.json"), "utf8")); timestamp = runMeta.timestamp; } catch {}
+              if (!timestamp) { try { const stat = await fs.promises.stat(runDir); timestamp = stat.mtime.toISOString(); } catch {} }
               const ents = await fs.promises.readdir(runDir);
               const testDirs = ents.filter(e => !e.endsWith(".json") && !e.startsWith("."));
               let failed = 0;
               for (const td of testDirs) { if (await exists(path.join(runDir, td, "failure.json"))) failed++; }
-              entry = { runId: d, timestamp: runMeta.timestamp, status: failed > 0 ? "failed" : "passed", passed: testDirs.length - failed, failed, skipped: 0, total: testDirs.length, duration_ms: 0 };
+              entry = { runId: d, timestamp, status: failed > 0 ? "failed" : "passed", passed: testDirs.length - failed, failed, skipped: 0, total: testDirs.length, duration_ms: 0 };
             }
             // Detect suite from test_command
             try {
               const r = JSON.parse(await fs.promises.readFile(path.join(runDir, "run.json"), "utf8"));
               const cmd = r.test_command || "";
-              if (cmd.includes("test/e2e/")) entry.suite = "e2e";
+              if (cmd.includes("test:playwright") || cmd.includes("playwright test")) entry.suite = "playwright";
+              else if (cmd.includes("test/e2e/") || cmd.includes("test:e2e")) entry.suite = "e2e";
               else if (cmd.includes("test/integration/")) entry.suite = "integration";
+              else if (cmd.includes("test:all")) entry.suite = "all";
+              else if (cmd.includes("crew-cli") || cmd.includes("--prefix crew-cli")) entry.suite = "crew-cli";
               else if (cmd.includes("test/unit/") && !cmd.includes("test/integration/")) entry.suite = "unit";
               else { const fc = (cmd.match(/\.test\.mjs/g) || []).length; entry.suite = fc > 100 ? "all" : fc > 15 ? "unit" : "unknown"; }
-            } catch { entry.suite = "unknown"; }
+            } catch {
+              // No run.json — try to infer from directory contents
+              try {
+                const ents = await fs.promises.readdir(runDir);
+                const first = ents.find(e => !e.endsWith(".json") && !e.startsWith(".")) || "";
+                if (first.includes("test-e2e-")) entry.suite = "e2e";
+                else if (first.includes("test-integration-")) entry.suite = "integration";
+                else if (first.includes("test-unit-")) entry.suite = "unit";
+                else if (first.includes("spec-")) entry.suite = "playwright";
+                else entry.suite = "unknown";
+              } catch { entry.suite = "unknown"; }
+            }
             history.push(entry);
           } catch { /* skip */ }
         }
@@ -1831,8 +1886,13 @@ const server = http.createServer(async (req, res) => {
       req.on("data", (c) => (body += c));
       req.on("end", async () => {
         let suite = "test:unit";
-        try { const parsed = JSON.parse(body); suite = parsed.suite || suite; } catch { /* default */ }
-        const allowed = ["test:unit", "test:integration", "test:e2e", "test:all", "test", "test:e2e:vibe"];
+        let singleFile = null;
+        try {
+          const parsed = JSON.parse(body);
+          suite = parsed.suite || suite;
+          singleFile = parsed.file || null;
+        } catch { /* default */ }
+        const allowed = ["test:unit", "test:integration", "test:e2e", "test:all", "test", "test:e2e:vibe", "test:playwright"];
         if (!allowed.includes(suite)) {
           res.writeHead(400, { "content-type": "application/json" });
           res.end(JSON.stringify({ error: "Invalid suite: " + suite }));
@@ -1841,10 +1901,51 @@ const server = http.createServer(async (req, res) => {
         const { spawn } = await import("node:child_process");
         const progressFile = path.join(CREWSWARM_DIR, "test-results", ".test-progress.json");
         const outputFile = path.join(CREWSWARM_DIR, "test-results", ".test-output.log");
+        // Count total files for this suite so progress can show X/Y
+        let files_total = 0;
+        try {
+          const testFileDir = path.join(CREWSWARM_DIR, "test");
+          const testsE2eDir = path.join(CREWSWARM_DIR, "tests", "e2e");
+          const crewCliTestDir = path.join(CREWSWARM_DIR, "crew-cli", "tests");
+          const crewCliTestDir2 = path.join(CREWSWARM_DIR, "crew-cli", "test");
+          const suiteKey = suite.replace("test:", "");
+          if (suiteKey === "unit") files_total = (await fs.promises.readdir(path.join(testFileDir, "unit"))).filter(f => f.endsWith(".test.mjs")).length;
+          else if (suiteKey === "integration") files_total = (await fs.promises.readdir(path.join(testFileDir, "integration"))).filter(f => f.endsWith(".test.mjs")).length;
+          else if (suiteKey === "e2e") files_total = (await fs.promises.readdir(path.join(testFileDir, "e2e"))).filter(f => f.endsWith(".test.mjs")).length;
+          else if (suiteKey === "playwright") files_total = (await fs.promises.readdir(testsE2eDir)).filter(f => f.endsWith(".spec.js")).length;
+          else if (suite === "test") { // crew-cli
+            const count = async (d) => { try { return (await fs.promises.readdir(d)).filter(f => f.match(/\.test\./)).length; } catch { return 0; } };
+            files_total = await count(path.join(crewCliTestDir, "unit")) + await count(crewCliTestDir) + await count(crewCliTestDir2);
+          } else if (suiteKey === "all") {
+            // Sum all suites
+            const count = async (d, p) => { try { return (await fs.promises.readdir(d)).filter(f => f.match(p)).length; } catch { return 0; } };
+            const countR = async (d) => { try { return (await fs.promises.readdir(d)).filter(f => f.match(/\.test\./)).length; } catch { return 0; } };
+            files_total = await count(path.join(testFileDir, "unit"), /\.test\.mjs$/)
+              + await count(path.join(testFileDir, "integration"), /\.test\.mjs$/)
+              + await count(path.join(testFileDir, "e2e"), /\.test\.mjs$/)
+              + await count(testsE2eDir, /\.spec\.js$/)
+              + await countR(path.join(crewCliTestDir, "unit")) + await countR(crewCliTestDir) + await countR(crewCliTestDir2);
+          }
+        } catch {}
         // Write initial progress
-        await fs.promises.writeFile(progressFile, JSON.stringify({ suite, running: true, pid: 0, started: Date.now(), passed: 0, failed: 0, skipped: 0, files_done: 0, current_file: "" }));
+        await fs.promises.writeFile(progressFile, JSON.stringify({ suite, running: true, pid: 0, started: Date.now(), passed: 0, failed: 0, skipped: 0, files_done: 0, files_total, current_file: singleFile || "" }));
+        // Clean up any stale progress from a previous interrupted run
+        const staleProgress = path.join(CREWSWARM_DIR, "test-results", ".test-progress.json");
+        try {
+          const prev = JSON.parse(fs.readFileSync(staleProgress, "utf8"));
+          if (prev.running && prev.pid) {
+            try { process.kill(prev.pid, 0); process.kill(prev.pid, "SIGTERM"); } catch { /* already dead */ }
+          }
+        } catch { /* no stale progress */ }
+        let child;
         const outFd = fs.openSync(outputFile, "w");
-        const child = spawn("npm", ["run", suite], { cwd: CREWSWARM_DIR, stdio: ["ignore", outFd, outFd], detached: true });
+        if (singleFile) {
+          // Single-file run: use node --test directly on the file
+          const absFile = path.isAbsolute(singleFile) ? singleFile : path.join(CREWSWARM_DIR, singleFile);
+          child = spawn("node", ["--test", "--test-reporter=./scripts/test-reporter.mjs", absFile], { cwd: CREWSWARM_DIR, stdio: ["ignore", outFd, outFd], detached: true });
+        } else {
+          child = spawn("npm", ["run", suite], { cwd: CREWSWARM_DIR, stdio: ["ignore", outFd, outFd], detached: true });
+        }
         child.unref();
         fs.closeSync(outFd);
         // Update progress by tailing the output file
@@ -1862,7 +1963,8 @@ const server = http.createServer(async (req, res) => {
                 current_file = line.trim();
               }
             }
-            fs.writeFileSync(progressFile, JSON.stringify({ suite, running: true, pid: child.pid, started: JSON.parse(fs.readFileSync(progressFile, "utf8")).started, passed, failed, skipped, files_done, current_file }));
+            const prev = JSON.parse(fs.readFileSync(progressFile, "utf8"));
+            fs.writeFileSync(progressFile, JSON.stringify({ suite, running: true, pid: child.pid, started: prev.started, passed, failed, skipped, files_done, files_total: prev.files_total || 0, current_file }));
           } catch { /* file may not exist yet */ }
         }, 2000);
         child.on("exit", (code) => {
@@ -1885,6 +1987,30 @@ const server = http.createServer(async (req, res) => {
       });
       return;
     }
+    if (url.pathname === "/api/tests/stop" && req.method === "POST") {
+      const progressFile = path.join(CREWSWARM_DIR, "test-results", ".test-progress.json");
+      try {
+        const data = JSON.parse(await fs.promises.readFile(progressFile, "utf8"));
+        if (data.running && data.pid) {
+          try { process.kill(data.pid, "SIGTERM"); } catch { /* already dead */ }
+          // Also kill child processes (node --test spawns sub-processes)
+          try { process.kill(-data.pid, "SIGTERM"); } catch { /* no process group */ }
+          data.running = false;
+          data.stopped = true;
+          data.finished = Date.now();
+          await fs.promises.writeFile(progressFile, JSON.stringify(data));
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify({ stopped: true, pid: data.pid }));
+        } else {
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify({ stopped: false, reason: "no running test" }));
+        }
+      } catch {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ stopped: false, reason: "no progress file" }));
+      }
+      return;
+    }
     if (url.pathname === "/api/tests/progress" && req.method === "GET") {
       const progressFile = path.join(CREWSWARM_DIR, "test-results", ".test-progress.json");
       try {
@@ -1898,6 +2024,173 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    // ── GET /api/tests/stale — files changed since last test run ────────────
+    if (url.pathname === "/api/tests/stale" && req.method === "GET") {
+      const resultsDir = path.join(CREWSWARM_DIR, "test-results");
+      const logPath = path.join(resultsDir, "test-log.jsonl");
+      try {
+        // Read last-run fingerprints from test-log.jsonl
+        const fingerprintByFile = new Map();
+        try {
+          const lines = (await fs.promises.readFile(logPath, "utf8")).split("\n").filter(Boolean);
+          for (const line of lines) {
+            try {
+              const entry = JSON.parse(line);
+              if (entry.file && entry.file_fingerprint?.mtime) {
+                // Keep the most recent entry per file
+                fingerprintByFile.set(entry.file, entry.file_fingerprint);
+              }
+            } catch {}
+          }
+        } catch {}
+        const stale = [];
+        for (const [filePath, fp] of fingerprintByFile) {
+          try {
+            const stat = await fs.promises.stat(filePath);
+            const currentMtime = stat.mtime.toISOString();
+            if (currentMtime > fp.mtime) {
+              stale.push({
+                file: filePath.replace(CREWSWARM_DIR + "/", ""),
+                lastRun: fp.mtime,
+                lastModified: currentMtime,
+              });
+            }
+          } catch {}
+        }
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ stale }));
+      } catch (e) {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ stale: [], error: e.message }));
+      }
+      return;
+    }
+
+    // ── GET /api/tests/stream — SSE stream of running test output ───────────
+    if (url.pathname === "/api/tests/stream" && req.method === "GET") {
+      const outputFile = path.join(CREWSWARM_DIR, "test-results", ".test-output.log");
+      res.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache",
+        "connection": "keep-alive",
+        "access-control-allow-origin": "*",
+      });
+      let lastSize = 0;
+      // Send existing content first
+      try {
+        const content = await fs.promises.readFile(outputFile, "utf8");
+        if (content) {
+          res.write("data: " + JSON.stringify({ text: content, reset: true }) + "\n\n");
+          lastSize = Buffer.byteLength(content, "utf8");
+        }
+      } catch {}
+      const streamInterval = setInterval(async () => {
+        try {
+          const stat = await fs.promises.stat(outputFile);
+          if (stat.size > lastSize) {
+            const fd = await fs.promises.open(outputFile, "r");
+            const newBytes = stat.size - lastSize;
+            const buf = Buffer.alloc(newBytes);
+            await fd.read(buf, 0, newBytes, lastSize);
+            await fd.close();
+            const text = buf.toString("utf8");
+            lastSize = stat.size;
+            res.write("data: " + JSON.stringify({ text }) + "\n\n");
+          }
+          // Check if done
+          const progressFile = path.join(CREWSWARM_DIR, "test-results", ".test-progress.json");
+          try {
+            const prog = JSON.parse(await fs.promises.readFile(progressFile, "utf8"));
+            if (!prog.running && prog.finished) {
+              res.write("data: " + JSON.stringify({ done: true }) + "\n\n");
+              clearInterval(streamInterval);
+              res.end();
+            }
+          } catch {}
+        } catch {}
+      }, 500);
+      req.on("close", () => { clearInterval(streamInterval); });
+      return;
+    }
+
+    // ── GET /api/tests/screenshot — serve a Playwright failure screenshot ────
+    if (url.pathname === "/api/tests/screenshot" && req.method === "GET") {
+      const relPath = url.searchParams.get("path");
+      if (!relPath) { res.writeHead(400); res.end("Missing path"); return; }
+      // Security: only allow paths within test-results/
+      const safePath = path.normalize(relPath).replace(/^(\.\.(\/|\\|$))+/, "");
+      const absPath = path.join(CREWSWARM_DIR, "test-results", safePath);
+      if (!absPath.startsWith(path.join(CREWSWARM_DIR, "test-results"))) {
+        res.writeHead(403); res.end("Forbidden"); return;
+      }
+      try {
+        const stat = await fs.promises.stat(absPath);
+        const ext = path.extname(absPath).toLowerCase();
+        const mimeMap = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp" };
+        const mime = mimeMap[ext] || "application/octet-stream";
+        res.writeHead(200, { "content-type": mime, "content-length": stat.size, "cache-control": "max-age=300" });
+        fs.createReadStream(absPath).pipe(res);
+      } catch {
+        res.writeHead(404); res.end("Screenshot not found");
+      }
+      return;
+    }
+
+    // ── GET /api/tests/coverage-map — source files vs test coverage ──────────
+    if (url.pathname === "/api/tests/coverage-map" && req.method === "GET") {
+      try {
+        const libDir = path.join(CREWSWARM_DIR, "lib");
+        const crewCliSrcDir = path.join(CREWSWARM_DIR, "crew-cli", "src");
+        const unitTestDir = path.join(CREWSWARM_DIR, "test", "unit");
+        const crewCliTestDir = path.join(CREWSWARM_DIR, "crew-cli", "tests", "unit");
+
+        // Collect test file basenames (strip extension)
+        const testBases = new Set();
+        async function collectTestBases(dir) {
+          try {
+            for (const ent of await fs.promises.readdir(dir, { withFileTypes: true })) {
+              if (ent.isDirectory()) { await collectTestBases(path.join(dir, ent.name)); continue; }
+              if (ent.name.match(/\.test\.(mjs|js|ts)$/)) {
+                // e.g. crew-judge.test.mjs -> crew-judge
+                testBases.add(ent.name.replace(/\.test\.(mjs|js|ts)$/, ""));
+              }
+            }
+          } catch {}
+        }
+        await collectTestBases(unitTestDir);
+        await collectTestBases(crewCliTestDir);
+
+        // Collect source files and check coverage
+        const covered = [];
+        const uncovered = [];
+        async function scanSourceDir(dir, prefix) {
+          try {
+            for (const ent of await fs.promises.readdir(dir, { withFileTypes: true })) {
+              const fullPath = path.join(dir, ent.name);
+              const relPath = prefix + "/" + ent.name;
+              if (ent.isDirectory()) { await scanSourceDir(fullPath, relPath); continue; }
+              if (!ent.name.match(/\.(mjs|js|ts)$/) || ent.name.includes(".d.ts") || ent.name.includes(".test.")) continue;
+              const base = ent.name.replace(/\.(mjs|js|ts)$/, "");
+              // Check if any test file matches by base name (fuzzy: contains or equals)
+              const hasCoverage = [...testBases].some(tb => tb === base || tb.includes(base) || base.includes(tb));
+              const entry = { file: relPath, base };
+              if (hasCoverage) covered.push(entry);
+              else uncovered.push(entry);
+            }
+          } catch {}
+        }
+        await scanSourceDir(libDir, "lib");
+        await scanSourceDir(crewCliSrcDir, "crew-cli/src");
+
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ covered, uncovered, totalCovered: covered.length, totalUncovered: uncovered.length }));
+      } catch (e) {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ covered: [], uncovered: [], error: e.message }));
+      }
+      return;
+    }
+
     // ── First-run detection ──────────────────────────────────────────────────
     if (url.pathname === "/api/first-run-status" && req.method === "GET") {
       const cfg = readSwarmConfigSafe();
@@ -4517,8 +4810,7 @@ const server = http.createServer(async (req, res) => {
       if (!providers["anthropic-oauth"]) {
         try {
           const { execFileSync } = await import("node:child_process");
-          const { userInfo } = await import("node:os");
-          for (const acct of [userInfo().username, "jeffhobbs", "unknown"]) {
+          for (const acct of getKeychainAccountCandidates()) {
             try {
               const raw = execFileSync("security", [
                 "find-generic-password", "-s", "Claude Code-credentials", "-a", acct, "-w"
@@ -4553,8 +4845,7 @@ const server = http.createServer(async (req, res) => {
         if (!token) {
           if (providerId === "anthropic-oauth") {
             const { execFileSync } = await import("node:child_process");
-            const { userInfo } = await import("node:os");
-            for (const acct of [userInfo().username, "jeffhobbs", "unknown"]) {
+            for (const acct of getKeychainAccountCandidates()) {
               try {
                 const raw = execFileSync("security", [
                   "find-generic-password", "-s", "Claude Code-credentials", "-a", acct, "-w"
@@ -4683,8 +4974,7 @@ const server = http.createServer(async (req, res) => {
         let token = getOAuthTokenCached(providerId);
         if (!token && providerId === "anthropic-oauth") {
           const { execFileSync } = await import("node:child_process");
-          const { userInfo } = await import("node:os");
-          for (const acct of [userInfo().username, "jeffhobbs", "unknown"]) {
+          for (const acct of getKeychainAccountCandidates()) {
             try {
               const raw = execFileSync("security", [
                 "find-generic-password", "-s", "Claude Code-credentials", "-a", acct, "-w"
@@ -7643,6 +7933,86 @@ ORDER BY day DESC, cost DESC;`;
       }
       return;
     }
+    // ── crew-cli cost stats ──────────────────────────────────────────────────
+    if (url.pathname === "/api/crew-cli-stats" && req.method === "GET") {
+      const days = Number(url.searchParams.get("days") || "14");
+      const cutoff = new Date(Date.now() - days * 86400000).toISOString().slice(0, 10);
+      try {
+        // Scan known project directories for .crew/cost.json files
+        const searchDirs = new Set();
+        // 1. opencodeProject from config
+        try {
+          const cfg = JSON.parse(fs.readFileSync(path.join(os.homedir(), ".crewswarm", "crewswarm.json"), "utf8"));
+          if (cfg.opencodeProject) searchDirs.add(cfg.opencodeProject.replace(/\/+$/, ""));
+        } catch {}
+        // 2. Registered projects
+        try {
+          const projFile = path.join(os.homedir(), ".crewswarm", "projects.json");
+          const projs = JSON.parse(fs.readFileSync(projFile, "utf8"));
+          for (const p of (projs.projects || projs || [])) {
+            if (p.outputDir) searchDirs.add(p.outputDir.replace(/\/+$/, ""));
+          }
+        } catch {}
+        // 3. Home .crew dir
+        searchDirs.add(os.homedir());
+
+        const allEntries = [];
+        for (const dir of searchDirs) {
+          const costFile = path.join(dir, ".crew", "cost.json");
+          try {
+            const raw = JSON.parse(fs.readFileSync(costFile, "utf8"));
+            for (const entry of (raw.entries || [])) {
+              if (!entry.timestamp) continue;
+              const day = entry.timestamp.slice(0, 10);
+              if (day >= cutoff) {
+                allEntries.push({ ...entry, day, project: dir });
+              }
+            }
+          } catch {}
+        }
+
+        // Roll up by day
+        const byDay = {};
+        let totalCost = 0;
+        let totalCalls = 0;
+        let totalPromptTokens = 0;
+        let totalCompletionTokens = 0;
+        for (const e of allEntries) {
+          if (!byDay[e.day]) byDay[e.day] = { cost: 0, calls: 0, prompt_tokens: 0, completion_tokens: 0, byModel: {} };
+          const d = byDay[e.day];
+          const usd = Number(e.usd || 0);
+          d.cost += usd;
+          d.calls += 1;
+          d.prompt_tokens += Number(e.promptTokens || 0);
+          d.completion_tokens += Number(e.completionTokens || 0);
+          const model = e.model || "unknown";
+          if (!d.byModel[model]) d.byModel[model] = { cost: 0, calls: 0, prompt_tokens: 0, completion_tokens: 0 };
+          d.byModel[model].cost += usd;
+          d.byModel[model].calls += 1;
+          d.byModel[model].prompt_tokens += Number(e.promptTokens || 0);
+          d.byModel[model].completion_tokens += Number(e.completionTokens || 0);
+          totalCost += usd;
+          totalCalls += 1;
+          totalPromptTokens += Number(e.promptTokens || 0);
+          totalCompletionTokens += Number(e.completionTokens || 0);
+        }
+
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({
+          ok: true,
+          totalCost,
+          totalCalls,
+          totalPromptTokens,
+          totalCompletionTokens,
+          projects: [...searchDirs],
+          byDay,
+        }));
+      } catch (e) {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: e.message, byDay: {} }));
+      }
+      return;
+    }
     // ── OpenCode models API ──────────────────────────────────────────────────
     if (url.pathname === "/api/opencode-models" && req.method === "GET") {
       let models = [];