shipwright-cli 2.4.0 → 3.1.0

package/dashboard/server.ts

@@ -57,6 +57,21 @@ function getDb(): Database | null {
   }
 }
 
+function dbQueryEventsByIdGreaterThan(
+  afterId: number,
+  limit = 100,
+): Array<Record<string, unknown>> {
+  const conn = getDb();
+  if (!conn) return [];
+  try {
+    return conn
+      .query(`SELECT * FROM events WHERE id > ? ORDER BY id ASC LIMIT ?`)
+      .all(afterId, limit) as Array<Record<string, unknown>>;
+  } catch {
+    return [];
+  }
+}
+
 function dbQueryEvents(since?: number, limit = 200): DaemonEvent[] {
   const conn = getDb();
   if (!conn) return [];
@@ -475,6 +490,7 @@ function isPublicRoute(pathname: string): boolean {
     pathname === "/login" ||
     pathname.startsWith("/auth/") ||
     pathname === "/api/health" ||
+    pathname === "/api/ws-status" ||
     pathname.startsWith("/api/join/") ||
     pathname.startsWith("/api/connect/") ||
     pathname === "/api/team" ||
@@ -876,6 +892,8 @@ function appendAuditLog(
 
 // ─── WebSocket client tracking ───────────────────────────────────────
 const wsClients = new Set<import("bun").ServerWebSocket<unknown>>();
+const eventClients = new Set<import("bun").ServerWebSocket<unknown>>();
+let lastBroadcastEventId = 0;
 const startTime = Date.now();
 
 function broadcastToClients(data: FleetState): void {
@@ -889,6 +907,30 @@ function broadcastToClients(data: FleetState): void {
   }
 }
 
+function broadcastNewEvents(): void {
+  if (eventClients.size === 0) return;
+  const db = getDb();
+  if (!db) return;
+  try {
+    const newEvents = dbQueryEventsByIdGreaterThan(lastBroadcastEventId, 100);
+    if (newEvents.length > 0) {
+      const eventMsg = JSON.stringify({ type: "events", data: newEvents });
+      for (const ws of eventClients) {
+        try {
+          ws.send(eventMsg);
+        } catch {
+          eventClients.delete(ws);
+        }
+      }
+      const lastRow = newEvents[newEvents.length - 1];
+      const lastId = (lastRow?.id as number) | 0;
+      if (lastId > 0) lastBroadcastEventId = lastId;
+    }
+  } catch {
+    /* non-fatal */
+  }
+}
+
 // ─── Data Collection ─────────────────────────────────────────────────
 function readEvents(): DaemonEvent[] {
   // Try SQLite first (faster for large event logs)
@@ -917,6 +959,47 @@ function readEvents(): DaemonEvent[] {
 }
 
 function readDaemonState(): Record<string, unknown> | null {
+  // Try DB first
+  try {
+    const conn = getDb();
+    if (conn) {
+      const active = dbQueryJobs("active") as Array<Record<string, unknown>>;
+      const completedRows = conn
+        .query(
+          "SELECT * FROM daemon_state WHERE status IN ('completed', 'failed') ORDER BY completed_at DESC LIMIT 20",
+        )
+        .all() as Array<Record<string, unknown>>;
+      if (active.length > 0 || completedRows.length > 0) {
+        const activeJobs = active.map((j) => ({
+          job_id: j.job_id,
+          issue: j.issue_number,
+          title: j.title || "",
+          stage: j.stage_name || "",
+          started_at: j.started_at,
+          started_epoch: j.started_at
+            ? Math.floor(new Date(j.started_at as string).getTime() / 1000)
+            : 0,
+          worktree: j.worktree || "",
+          branch: j.branch || "",
+          pid: j.pid || 0,
+        }));
+        const completed = completedRows.map((j) => ({
+          issue: j.issue_number,
+          result: j.result || "",
+          duration: j.duration || "",
+          completed_at: j.completed_at || "",
+        }));
+        return {
+          active_jobs: activeJobs,
+          completed,
+          queued: [] as number[],
+        };
+      }
+    }
+  } catch {
+    /* fall through to file */
+  }
+  // Fallback to file
   if (!existsSync(DAEMON_STATE)) return null;
   try {
     return JSON.parse(readFileSync(DAEMON_STATE, "utf-8"));
@@ -1546,7 +1629,63 @@ function getAgents(): AgentInfo[] {
     }
   }
 
-  // Read heartbeat files
+  // Try DB heartbeats first
+  try {
+    const conn = getDb();
+    if (conn) {
+      const rows = dbQueryHeartbeats();
+      if (rows.length > 0) {
+        for (const hb of rows) {
+          const jobId = String(hb.job_id || "");
+          const issue = (hb.issue as number) || 0;
+          const updatedAt = (hb.updated_at as string) || "";
+          let hbEpoch = 0;
+          try {
+            hbEpoch = Math.floor(new Date(updatedAt).getTime() / 1000);
+          } catch {
+            /* ignore */
+          }
+          const age = hbEpoch > 0 ? now - hbEpoch : 9999;
+
+          let status: AgentInfo["status"] = "active";
+          if (age > 120) status = "stale";
+          else if (age > 30) status = "idle";
+
+          const job = issue ? jobMap[issue] : undefined;
+          const startedAt = job ? (job.started_at as string) || "" : updatedAt;
+          let elapsed = 0;
+          if (startedAt) {
+            try {
+              elapsed = now - Math.floor(new Date(startedAt).getTime() / 1000);
+            } catch {
+              /* ignore */
+            }
+          }
+
+          agents.push({
+            id: jobId,
+            issue,
+            title: job ? (job.title as string) || "" : "",
+            machine: (hb.machine as string) || "localhost",
+            stage: (hb.stage as string) || "",
+            iteration: (hb.iteration as number) || 0,
+            activity: (hb.last_activity as string) || "",
+            memory_mb: (hb.memory_mb as number) || 0,
+            cpu_pct: (hb.cpu_pct as number) || 0,
+            status,
+            heartbeat_age_s: age,
+            started_at: startedAt,
+            elapsed_s: elapsed,
+          });
+        }
+        return agents;
+      }
+    }
+  } catch {
+    /* fall through to file */
+  }
+
+  // Fallback: Read heartbeat files
   if (existsSync(HEARTBEAT_DIR)) {
     try {
       const files = readdirSync(HEARTBEAT_DIR).filter((f) =>
@@ -1869,10 +2008,48 @@ interface CostInfo {
   pct_used: number;
 }
 
+function dbQueryBudget(): { dailyBudget: number } {
+  const conn = getDb();
+  if (!conn) return { dailyBudget: 0 };
+  try {
+    const row = conn
+      .query("SELECT daily_budget_usd, enabled FROM budgets WHERE id = 1")
+      .get() as { daily_budget_usd: number; enabled: number } | null;
+    if (!row || row.enabled !== 1) return { dailyBudget: 0 };
+    return { dailyBudget: row.daily_budget_usd || 0 };
+  } catch {
+    return { dailyBudget: 0 };
+  }
+}
+
 function getCostInfo(): CostInfo {
   let todaySpent = 0;
   let dailyBudget = 0;
 
+  // Try DB first
+  try {
+    const conn = getDb();
+    if (conn) {
+      const costs = dbQueryCostsToday();
+      if (costs.count > 0 || costs.total > 0) {
+        todaySpent = Math.round(costs.total * 100) / 100;
+        const budget = dbQueryBudget();
+        dailyBudget = budget.dailyBudget;
+        const pctUsed =
+          dailyBudget > 0
+            ? Math.round((todaySpent / dailyBudget) * 10000) / 100
+            : 0;
+        return {
+          today_spent: todaySpent,
+          daily_budget: dailyBudget,
+          pct_used: pctUsed,
+        };
+      }
+    }
+  } catch {
+    /* fall through to file */
+  }
+
   if (existsSync(COSTS_FILE)) {
     try {
       const data = JSON.parse(readFileSync(COSTS_FILE, "utf-8"));
@@ -2126,6 +2303,7 @@ function startEventsWatcher(): void {
         // Check for new events and send notifications
         if (filename === "events.jsonl") {
           checkAndNotifyNewEvents();
+          broadcastNewEvents();
         }
       }
     });
@@ -2138,15 +2316,22 @@ function startEventsWatcher(): void {
 let lastPushedJson = "";
 
 function periodicPush(): void {
-  if (wsClients.size === 0) return;
+  const hasStateClients = wsClients.size > 0;
+  const hasEventClients = eventClients.size > 0;
 
-  const state = getFleetState();
-  const json = JSON.stringify(state);
-  // Skip push if nothing changed (file watcher already pushed)
-  if (json === lastPushedJson) return;
-  lastPushedJson = json;
+  if (hasStateClients) {
+    const state = getFleetState();
+    const json = JSON.stringify(state);
+    // Skip push if nothing changed (file watcher already pushed)
+    if (json !== lastPushedJson) {
+      lastPushedJson = json;
+      broadcastToClients(state);
+    }
+  }
 
-  broadcastToClients(state);
+  if (hasEventClients) {
+    broadcastNewEvents();
+  }
 }
 
 // ─── GitHub OAuth helpers ───────────────────────────────────────────
@@ -2397,6 +2582,24 @@ const server = Bun.serve({
       });
     }
 
+    // GET /api/ws-status — WebSocket connection status (for evidence collection)
+    if (pathname === "/api/ws-status" && req.method === "GET") {
+      const clients = wsClients?.size ?? 0;
+      return new Response(
+        JSON.stringify({
+          status: "ok",
+          websocket: {
+            active_connections: clients,
+            server_running: true,
+          },
+          timestamp: new Date().toISOString(),
+        }),
+        {
+          headers: { "Content-Type": "application/json", ...CORS_HEADERS },
+        },
+      );
+    }
+
     // GET /api/join/{token} — Serve join script (public, no auth required)
     if (pathname.startsWith("/api/join/") && req.method === "GET") {
       const token = pathname.split("/")[3] || "";
@@ -2492,7 +2695,7 @@ const server = Bun.serve({
       const session = getSession(req);
       if (!session) {
         // WebSocket upgrade attempt without auth
-        if (pathname === "/ws") {
+        if (pathname === "/ws" || pathname === "/ws/events") {
           return new Response("Unauthorized", { status: 401 });
         }
         return new Response(null, {
@@ -2504,7 +2707,14 @@ const server = Bun.serve({
 
     // ── Protected routes ──────────────────────────────────────────
 
-    // WebSocket upgrade
+    // WebSocket upgrade — /ws/events streams raw events, /ws streams aggregated state
+    if (pathname === "/ws/events") {
+      const upgraded = server.upgrade(req, {
+        data: { type: "events", lastEventId: 0 },
+      });
+      if (upgraded) return undefined as unknown as Response;
+      return new Response("WebSocket upgrade failed", { status: 400 });
+    }
     if (pathname === "/ws") {
       const upgraded = server.upgrade(req);
       if (upgraded) return undefined as unknown as Response;
@@ -5289,6 +5499,68 @@ const server = Bun.serve({
           );
         }
 
+        // VERIFY: re-read labels — if competing claimed:* labels exist, we lost the race
+        try {
+          const verifyLabels = execSync(
+            `gh issue view ${issue}${repoFlag} --json labels -q '.labels[].name'`,
+            {
+              encoding: "utf-8",
+              timeout: 10000,
+              stdio: ["pipe", "pipe", "pipe"],
+            },
+          )
+            .trim()
+            .split("\n")
+            .filter((l: string) => l.startsWith("claimed:"));
+          if (
+            verifyLabels.length !== 1 ||
+            verifyLabels[0] !== `claimed:${machine}`
+          ) {
+            // Competing claim — remove ours and reject
+            execSync(
+              `gh issue edit ${issue}${repoFlag} --remove-label "claimed:${machine}"`,
+              { timeout: 10000, stdio: ["pipe", "pipe", "pipe"] },
+            );
+            return new Response(
+              JSON.stringify({
+                approved: false,
+                claimed_by:
+                  verifyLabels[0]?.replace("claimed:", "") || "another machine",
+                error: "Claim race lost",
+              }),
+              {
+                headers: {
+                  "Content-Type": "application/json",
+                  ...CORS_HEADERS,
+                },
+              },
+            );
+          }
+        } catch {
+          // Verification failed — conservative: remove our label and reject
+          try {
+            execSync(
+              `gh issue edit ${issue}${repoFlag} --remove-label "claimed:${machine}"`,
+              { timeout: 10000, stdio: ["pipe", "pipe", "pipe"] },
+            );
+          } catch {
+            /* best-effort cleanup */
+          }
+          return new Response(
+            JSON.stringify({
+              approved: false,
+              error: "Claim verification failed",
+            }),
+            {
+              status: 500,
+              headers: {
+                "Content-Type": "application/json",
+                ...CORS_HEADERS,
+              },
+            },
+          );
+        }
+
         return new Response(
           JSON.stringify({ approved: true, claimed_by: machine }),
           {
@@ -5473,12 +5745,20 @@ const server = Bun.serve({
 
   websocket: {
     open(ws) {
-      wsClients.add(ws);
-      // Send initial state immediately on connect
-      try {
-        ws.send(JSON.stringify(getFleetState()));
-      } catch {
-        wsClients.delete(ws);
+      const data = ws.data as
+        | { type?: string; lastEventId?: number }
+        | undefined;
+      if (data?.type === "events") {
+        eventClients.add(ws);
+        // Event clients get events via broadcastNewEvents; no initial state
+      } else {
+        wsClients.add(ws);
+        // Send initial state immediately on connect
+        try {
+          ws.send(JSON.stringify(getFleetState()));
+        } catch {
+          wsClients.delete(ws);
+        }
       }
     },
     message(_ws, _message) {
@@ -5486,6 +5766,7 @@ const server = Bun.serve({
     },
     close(ws) {
       wsClients.delete(ws);
+      eventClients.delete(ws);
     },
   },
 });
@@ -5572,7 +5853,15 @@ process.on("SIGINT", () => {
       // ignore
     }
   }
+  for (const ws of eventClients) {
+    try {
+      ws.close(1001, "Server shutting down");
+    } catch {
+      // ignore
+    }
+  }
   wsClients.clear();
+  eventClients.clear();
   server.stop();
   process.exit(0);
 });
@@ -5597,7 +5886,7 @@ console.log(
   `  ${GREEN}\u25CF${RESET} API:       ${ULINE}http://localhost:${server.port}/api/status${RESET}`,
 );
 console.log(
-  `  ${GREEN}\u25CF${RESET} WebSocket: ${ULINE}ws://localhost:${server.port}/ws${RESET}`,
+  `  ${GREEN}\u25CF${RESET} WebSocket: ${ULINE}ws://localhost:${server.port}/ws${RESET} | ${ULINE}/ws/events${RESET}`,
 );
 console.log(
   `  ${GREEN}\u25CF${RESET} Health:    ${ULINE}http://localhost:${server.port}/api/health${RESET}`,

package/dashboard/src/components/charts/bar.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import { renderSVGBarChart } from "./bar";
+
+describe("bar", () => {
+  describe("renderSVGBarChart", () => {
+    it("returns empty string for empty data", () => {
+      expect(renderSVGBarChart([])).toBe("");
+    });
+
+    it("returns empty string for null/undefined", () => {
+      expect(renderSVGBarChart(null as unknown as never[])).toBe("");
+    });
+
+    it("returns SVG with rect for single bar", () => {
+      const data = [{ date: "2025-02-17", completed: 5, failed: 2 }];
+      const svg = renderSVGBarChart(data);
+      expect(svg).toContain('<svg class="svg-bar-chart"');
+      expect(svg).toContain("<rect");
+      expect(svg).toContain('fill="#4ade80"');
+      expect(svg).toContain('fill="#f43f5e"');
+    });
+
+    it("returns SVG with multiple rects for multiple bars", () => {
+      const data = [
+        { date: "2025-02-15", completed: 3, failed: 0 },
+        { date: "2025-02-16", completed: 5, failed: 1 },
+        { date: "2025-02-17", completed: 2, failed: 3 },
+      ];
+      const svg = renderSVGBarChart(data);
+      expect(svg).toContain('<svg class="svg-bar-chart"');
+      const rectCount = (svg.match(/<rect/g) || []).length;
+      expect(rectCount).toBeGreaterThanOrEqual(3);
+      const textCount = (svg.match(/<text/g) || []).length;
+      expect(textCount).toBe(3);
+    });
+
+    it("renders zero-value bars as thin rect (1px)", () => {
+      const data = [{ date: "2025-02-17", completed: 0, failed: 0 }];
+      const svg = renderSVGBarChart(data);
+      expect(svg).toContain("<rect");
+      expect(svg).toContain('height="1"');
+      expect(svg).toContain('fill="#0d1f3c"');
+    });
+
+    it("renders labels from date (MM/DD format)", () => {
+      const data = [{ date: "2025-02-17", completed: 1, failed: 0 }];
+      const svg = renderSVGBarChart(data);
+      expect(svg).toContain("02/17");
+    });
+
+    it("handles dates without enough parts (falls back to full date)", () => {
+      const data = [{ date: "2025", completed: 1, failed: 0 }];
+      const svg = renderSVGBarChart(data);
+      expect(svg).toContain("2025");
+    });
+
+    it("escapes HTML in labels", () => {
+      const data = [{ date: "2025-02-17<script>", completed: 1, failed: 0 }];
+      const svg = renderSVGBarChart(data);
+      expect(svg).toContain("&lt;script&gt;");
+      expect(svg).not.toContain("<script>");
+    });
+
+    it("handles missing completed/failed (treats as 0)", () => {
+      const data = [
+        { date: "2025-02-17", completed: undefined, failed: undefined },
+      ];
+      const svg = renderSVGBarChart(data as never[]);
+      expect(svg).toContain("<rect");
+      expect(svg).toContain('height="1"');
+    });
+
+    it("has correct viewBox dimensions", () => {
+      const data = [{ date: "2025-02-17", completed: 5, failed: 2 }];
+      const svg = renderSVGBarChart(data);
+      expect(svg).toContain('viewBox="0 0 700 120"');
+    });
+  });
+});

package/dashboard/src/components/charts/donut.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect } from "vitest";
+import { renderSVGDonut } from "./donut";
+
+describe("donut", () => {
+  describe("renderSVGDonut", () => {
+    it("renders SVG with zero rate", () => {
+      const svg = renderSVGDonut(0);
+      expect(svg).toContain('<svg class="svg-donut"');
+      expect(svg).toContain('viewBox="0 0 120 120"');
+      expect(svg).toContain("<circle");
+      expect(svg).toContain("0.0%");
+    });
+
+    it("renders SVG with single segment (partial fill)", () => {
+      const svg = renderSVGDonut(50);
+      expect(svg).toContain('<svg class="svg-donut"');
+      expect(svg).toContain("<circle");
+      expect(svg).toContain("50.0%");
+      expect(svg).toContain("stroke-dasharray");
+      expect(svg).toContain("stroke-dashoffset");
+    });
+
+    it("renders SVG with full segment (100%)", () => {
+      const svg = renderSVGDonut(100);
+      expect(svg).toContain('<svg class="svg-donut"');
+      expect(svg).toContain("100.0%");
+    });
+
+    it("contains expected SVG elements: circle, defs, text", () => {
+      const svg = renderSVGDonut(75);
+      expect(svg).toContain("<defs>");
+      expect(svg).toContain("linearGradient");
+      expect(svg).toContain("donut-grad");
+      expect(svg).toContain("<circle");
+      expect(svg).toContain("<text");
+      expect(svg).toContain('text-anchor="middle"');
+    });
+
+    it("clamps negative rate to 0", () => {
+      const svg = renderSVGDonut(-10);
+      expect(svg).toContain("0.0%");
+    });
+
+    it("clamps rate above 100 to 100", () => {
+      const svg = renderSVGDonut(150);
+      expect(svg).toContain("100.0%");
+    });
+
+    it("renders label with percentage", () => {
+      const svg = renderSVGDonut(33.5);
+      expect(svg).toContain("33.5%");
+    });
+
+    it("has fixed size 120x120", () => {
+      const svg = renderSVGDonut(25);
+      expect(svg).toContain('width="120"');
+      expect(svg).toContain('height="120"');
+    });
+
+    it("uses background circle and gradient stroke circle", () => {
+      const svg = renderSVGDonut(50);
+      const circleCount = (svg.match(/<circle/g) || []).length;
+      expect(circleCount).toBe(2);
+      expect(svg).toContain('stroke="#0d1f3c"');
+      expect(svg).toContain('stroke="url(#donut-grad)"');
+    });
+  });
+});