shipwright-cli 2.3.0 → 2.3.1

package/README.md

@@ -13,7 +13,7 @@
   <a href="https://github.com/sethdford/shipwright/actions/workflows/test.yml"><img src="https://github.com/sethdford/shipwright/actions/workflows/test.yml/badge.svg" alt="Tests"></a>
   <a href="https://github.com/sethdford/shipwright/actions/workflows/shipwright-pipeline.yml"><img src="https://github.com/sethdford/shipwright/actions/workflows/shipwright-pipeline.yml/badge.svg" alt="Pipeline"></a>
   <img src="https://img.shields.io/badge/tests-103_suites_passing-4ade80?style=flat-square" alt="103 suites">
-  <img src="https://img.shields.io/badge/version-2.3.0-00d4ff?style=flat-square" alt="v2.3.0">
+  <img src="https://img.shields.io/badge/version-2.3.1-00d4ff?style=flat-square" alt="v2.3.1">
   <img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="MIT License">
   <img src="https://img.shields.io/badge/bash-3.2%2B-7c3aed?style=flat-square" alt="Bash 3.2+">
 </p>
@@ -23,7 +23,7 @@
 ## Table of Contents
 
 - [Shipwright Builds Itself](#shipwright-builds-itself)
-- [What's New in v2.3.0](#whats-new-in-v230)
+- [What's New in v2.3.1](#whats-new-in-v231)
 - [How It Works](#how-it-works)
 - [Install](#install)
 - [Quick Start](#quick-start)
@@ -46,7 +46,7 @@ This repo uses Shipwright to process its own issues. Label a GitHub issue with `
 
 ---
 
-## What's New in v2.3.0
+## What's New in v2.3.1
 
 **Docs & platform polish** — doc-fleet, shared libs, policy schema, release infra:
 

package/dashboard/public/index.html

@@ -733,7 +733,7 @@
 
     <!-- Footer -->
     <footer class="footer">
-      <span>Shipwright Fleet Command v2.3.0</span>
+      <span>Shipwright Fleet Command v2.3.1</span>
       <span>Dashboard refreshes via WebSocket</span>
     </footer>
 

package/dashboard/src/core/api.test.ts

@@ -0,0 +1,362 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import * as api from "./api";
+
+// Mock global fetch
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+function jsonResponse(data: unknown, status = 200) {
+  return Promise.resolve({
+    ok: status >= 200 && status < 300,
+    status,
+    json: () => Promise.resolve(data),
+  });
+}
+
+function errorResponse(status: number, body?: unknown) {
+  return Promise.resolve({
+    ok: false,
+    status,
+    json: () => Promise.resolve(body || { error: `HTTP ${status}` }),
+  });
+}
+
+describe("API Client", () => {
+  beforeEach(() => {
+    mockFetch.mockReset();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("fetchMe", () => {
+    it("calls GET /api/me", async () => {
+      const userData = { username: "test", role: "admin" };
+      mockFetch.mockReturnValueOnce(jsonResponse(userData));
+
+      const result = await api.fetchMe();
+      expect(result).toEqual(userData);
+      expect(mockFetch).toHaveBeenCalledWith("/api/me", undefined);
+    });
+  });
+
+  describe("fetchPipelineDetail", () => {
+    it("calls GET /api/pipeline/:issue", async () => {
+      const detail = { issue: 42, status: "building" };
+      mockFetch.mockReturnValueOnce(jsonResponse(detail));
+
+      const result = await api.fetchPipelineDetail(42);
+      expect(result).toEqual(detail);
+      expect(mockFetch).toHaveBeenCalledWith("/api/pipeline/42", undefined);
+    });
+
+    it("encodes special characters in issue", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchPipelineDetail("test/123");
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/pipeline/test%2F123",
+        undefined,
+      );
+    });
+  });
+
+  describe("fetchMetricsHistory", () => {
+    it("defaults to 30 day period", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ history: [] }));
+      await api.fetchMetricsHistory();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/history?period=30",
+        undefined,
+      );
+    });
+
+    it("respects custom period", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ history: [] }));
+      await api.fetchMetricsHistory(7);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/history?period=7",
+        undefined,
+      );
+    });
+  });
+
+  describe("fetchTimeline", () => {
+    it("defaults to 24h range", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse([]));
+      await api.fetchTimeline();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/timeline?range=24h",
+        undefined,
+      );
+    });
+  });
+
+  describe("fetchActivity", () => {
+    it("builds query string from params", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ events: [], hasMore: false }),
+      );
+      await api.fetchActivity({ limit: 50, offset: 10, type: "error" });
+
+      const url = mockFetch.mock.calls[0][0] as string;
+      expect(url).toContain("/api/activity?");
+      expect(url).toContain("limit=50");
+      expect(url).toContain("offset=10");
+      expect(url).toContain("type=error");
+    });
+
+    it("excludes type=all from query string", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ events: [], hasMore: false }),
+      );
+      await api.fetchActivity({ type: "all" });
+
+      const url = mockFetch.mock.calls[0][0] as string;
+      expect(url).not.toContain("type=");
+    });
+  });
+
+  describe("machine operations", () => {
+    it("fetchMachines calls GET /api/machines", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse([]));
+      await api.fetchMachines();
+      expect(mockFetch).toHaveBeenCalledWith("/api/machines", undefined);
+    });
+
+    it("addMachine calls POST /api/machines", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ name: "m1" }));
+      await api.addMachine({ name: "m1", host: "localhost" });
+
+      expect(mockFetch).toHaveBeenCalledWith("/api/machines", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: "m1", host: "localhost" }),
+      });
+    });
+
+    it("updateMachine calls PATCH /api/machines/:name", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ name: "m1" }));
+      await api.updateMachine("m1", { status: "active" });
+
+      expect(mockFetch).toHaveBeenCalledWith("/api/machines/m1", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ status: "active" }),
+      });
+    });
+
+    it("removeMachine calls DELETE /api/machines/:name", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.removeMachine("m1");
+
+      expect(mockFetch).toHaveBeenCalledWith("/api/machines/m1", {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+      });
+    });
+  });
+
+  describe("fetchQueueDetailed", () => {
+    it("transforms queue property to items", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ queue: [{ id: 1 }, { id: 2 }] }),
+      );
+      const result = await api.fetchQueueDetailed();
+      expect(result).toEqual({ items: [{ id: 1 }, { id: 2 }] });
+    });
+
+    it("handles missing queue property gracefully", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      const result = await api.fetchQueueDetailed();
+      expect(result).toEqual({ items: [] });
+    });
+  });
+
+  describe("emergency brake", () => {
+    it("calls POST /api/emergency-brake", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.emergencyBrake();
+
+      expect(mockFetch).toHaveBeenCalledWith("/api/emergency-brake", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+      });
+    });
+  });
+
+  describe("sendIntervention", () => {
+    it("calls POST /api/intervention/:issue/:action with body", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.sendIntervention(42, "pause", { reason: "testing" });
+
+      expect(mockFetch).toHaveBeenCalledWith("/api/intervention/42/pause", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ reason: "testing" }),
+      });
+    });
+  });
+
+  describe("insights endpoints", () => {
+    it("fetchPatterns returns empty array on error", async () => {
+      mockFetch.mockReturnValueOnce(errorResponse(500));
+      const result = await api.fetchPatterns();
+      expect(result).toEqual({ patterns: [] });
+    });
+
+    it("fetchDecisions returns empty array on error", async () => {
+      mockFetch.mockReturnValueOnce(errorResponse(500));
+      const result = await api.fetchDecisions();
+      expect(result).toEqual({ decisions: [] });
+    });
+
+    it("fetchHeatmap returns null on error", async () => {
+      mockFetch.mockReturnValueOnce(errorResponse(500));
+      const result = await api.fetchHeatmap();
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("pipeline live changes", () => {
+    it("fetchPipelineDiff calls correct endpoint", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({
+          diff: "diff output",
+          stats: { files_changed: 1, insertions: 10, deletions: 5 },
+          worktree: "/path",
+        }),
+      );
+      await api.fetchPipelineDiff(142);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/pipeline/142/diff",
+        undefined,
+      );
+    });
+
+    it("fetchPipelineFiles calls correct endpoint", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({
+          files: [{ path: "src/main.ts", status: "modified" }],
+        }),
+      );
+      await api.fetchPipelineFiles(142);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/pipeline/142/files",
+        undefined,
+      );
+    });
+
+    it("fetchPipelineReasoning calls correct endpoint", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ reasoning: [] }));
+      await api.fetchPipelineReasoning(142);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/pipeline/142/reasoning",
+        undefined,
+      );
+    });
+
+    it("fetchPipelineFailures calls correct endpoint", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ failures: [] }));
+      await api.fetchPipelineFailures(142);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/pipeline/142/failures",
+        undefined,
+      );
+    });
+  });
+
+  describe("approval gates", () => {
+    it("approveGate sends POST with stage", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.approveGate(42, "build");
+
+      expect(mockFetch).toHaveBeenCalledWith("/api/approval-gates/42/approve", {
+        method: "POST",
+        body: JSON.stringify({ stage: "build" }),
+      });
+    });
+
+    it("rejectGate sends POST with stage and reason", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.rejectGate(42, "build", "Failed QA");
+
+      expect(mockFetch).toHaveBeenCalledWith("/api/approval-gates/42/reject", {
+        method: "POST",
+        body: JSON.stringify({ stage: "build", reason: "Failed QA" }),
+      });
+    });
+  });
+
+  describe("notifications", () => {
+    it("addWebhook sends POST", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.addWebhook("https://slack.com/hook", "Slack", ["failure"]);
+
+      expect(mockFetch).toHaveBeenCalledWith("/api/notifications/webhook", {
+        method: "POST",
+        body: JSON.stringify({
+          url: "https://slack.com/hook",
+          label: "Slack",
+          events: ["failure"],
+        }),
+      });
+    });
+
+    it("removeWebhook sends DELETE", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.removeWebhook("https://slack.com/hook");
+
+      expect(mockFetch).toHaveBeenCalledWith("/api/notifications/webhook", {
+        method: "DELETE",
+        body: JSON.stringify({ url: "https://slack.com/hook" }),
+      });
+    });
+  });
+
+  describe("machine claim/release", () => {
+    it("claimIssue sends POST with issue and machine", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ approved: true, claimed_by: "m1" }),
+      );
+      const result = await api.claimIssue(42, "m1");
+      expect(result.approved).toBe(true);
+    });
+
+    it("releaseIssue sends POST", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.releaseIssue(42, "m1");
+
+      expect(mockFetch).toHaveBeenCalledWith("/api/claim/release", {
+        method: "POST",
+        body: JSON.stringify({ issue: 42, machine: "m1" }),
+      });
+    });
+  });
+
+  describe("error handling", () => {
+    it("throws on non-ok response", async () => {
+      mockFetch.mockReturnValueOnce(errorResponse(404, { error: "Not found" }));
+
+      await expect(api.fetchMe()).rejects.toThrow("Not found");
+    });
+
+    it("falls back to HTTP status on unparseable error", async () => {
+      mockFetch.mockReturnValueOnce(
+        Promise.resolve({
+          ok: false,
+          status: 500,
+          json: () => Promise.reject(new Error("parse error")),
+        }),
+      );
+
+      await expect(api.fetchMe()).rejects.toThrow("HTTP 500");
+    });
+
+    it("fetchPredictions returns empty object on error", async () => {
+      mockFetch.mockReturnValueOnce(errorResponse(500));
+      const result = await api.fetchPredictions(42);
+      expect(result).toEqual({});
+    });
+  });
+});

package/dashboard/src/core/router.test.ts

@@ -0,0 +1,266 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+
+// We need to mock the DOM and store before importing the router
+describe("Router", () => {
+  let store: any;
+  let router: typeof import("./router");
+
+  beforeEach(async () => {
+    // Reset DOM
+    document.body.innerHTML = `
+      <div class="tab-btn" data-tab="overview">Overview</div>
+      <div class="tab-btn" data-tab="pipelines">Pipelines</div>
+      <div class="tab-btn" data-tab="metrics">Metrics</div>
+      <div class="tab-btn" data-tab="team">Team</div>
+      <div class="tab-panel" id="panel-overview"></div>
+      <div class="tab-panel" id="panel-pipelines"></div>
+      <div class="tab-panel" id="panel-metrics"></div>
+      <div class="tab-panel" id="panel-team"></div>
+    `;
+
+    // Reset hash
+    location.hash = "";
+
+    // Fresh imports
+    vi.resetModules();
+    store = (await import("./state")).store;
+    router = await import("./router");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("registerView", () => {
+    it("registers a view for a tab", () => {
+      const mockView = {
+        init: vi.fn(),
+        render: vi.fn(),
+        destroy: vi.fn(),
+      };
+      router.registerView("overview", mockView);
+
+      const views = router.getRegisteredViews();
+      expect(views.get("overview")).toBe(mockView);
+    });
+  });
+
+  describe("switchTab", () => {
+    it("updates the active tab in the store", () => {
+      store.set("activeTab", "overview");
+      router.switchTab("pipelines");
+      expect(store.get("activeTab")).toBe("pipelines");
+    });
+
+    it("updates the location hash", () => {
+      store.set("activeTab", "overview");
+      router.switchTab("pipelines");
+      expect(location.hash).toBe("#pipelines");
+    });
+
+    it("adds active class to the correct tab button", () => {
+      store.set("activeTab", "overview");
+      router.switchTab("pipelines");
+
+      const btns = document.querySelectorAll(".tab-btn");
+      const pipelinesBtn = Array.from(btns).find(
+        (b) => b.getAttribute("data-tab") === "pipelines",
+      );
+      const overviewBtn = Array.from(btns).find(
+        (b) => b.getAttribute("data-tab") === "overview",
+      );
+
+      expect(pipelinesBtn?.classList.contains("active")).toBe(true);
+      expect(overviewBtn?.classList.contains("active")).toBe(false);
+    });
+
+    it("adds active class to the correct panel", () => {
+      store.set("activeTab", "overview");
+      router.switchTab("pipelines");
+
+      const pipelinesPanel = document.getElementById("panel-pipelines");
+      const overviewPanel = document.getElementById("panel-overview");
+
+      expect(pipelinesPanel?.classList.contains("active")).toBe(true);
+      expect(overviewPanel?.classList.contains("active")).toBe(false);
+    });
+
+    it("does nothing when switching to the current tab", () => {
+      store.set("activeTab", "overview");
+      const prevHash = location.hash;
+      router.switchTab("overview");
+      // Should not change anything
+      expect(store.get("activeTab")).toBe("overview");
+    });
+
+    it("initializes the view on first switch", () => {
+      const mockView = {
+        init: vi.fn(),
+        render: vi.fn(),
+        destroy: vi.fn(),
+      };
+      router.registerView("metrics", mockView);
+
+      store.set("activeTab", "overview");
+      router.switchTab("metrics");
+
+      expect(mockView.init).toHaveBeenCalledTimes(1);
+    });
+
+    it("destroys the previous view on tab switch", () => {
+      const overviewView = {
+        init: vi.fn(),
+        render: vi.fn(),
+        destroy: vi.fn(),
+      };
+      const metricsView = {
+        init: vi.fn(),
+        render: vi.fn(),
+        destroy: vi.fn(),
+      };
+
+      router.registerView("overview", overviewView);
+      router.registerView("metrics", metricsView);
+
+      // First, switch to overview so it gets initialized
+      store.set("activeTab", "pipelines");
+      router.switchTab("overview");
+      expect(overviewView.init).toHaveBeenCalledTimes(1);
+
+      // Now switch to metrics
+      router.switchTab("metrics");
+      expect(overviewView.destroy).toHaveBeenCalledTimes(1);
+      expect(metricsView.init).toHaveBeenCalledTimes(1);
+    });
+
+    it("renders with fleet state if available", () => {
+      const mockView = {
+        init: vi.fn(),
+        render: vi.fn(),
+        destroy: vi.fn(),
+      };
+      router.registerView("metrics", mockView);
+
+      const fakeState = { pipelines: [], machines: [] };
+      store.set("fleetState", fakeState);
+      store.set("activeTab", "overview");
+
+      router.switchTab("metrics");
+      expect(mockView.render).toHaveBeenCalledWith(fakeState);
+    });
+  });
+
+  describe("error boundaries", () => {
+    it("catches init errors and shows error boundary", () => {
+      const errorView = {
+        init: vi.fn(() => {
+          throw new Error("Init failed!");
+        }),
+        render: vi.fn(),
+        destroy: vi.fn(),
+      };
+      router.registerView("metrics", errorView);
+
+      // Suppress console.error for this test
+      const consoleSpy = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      store.set("activeTab", "overview");
+      router.switchTab("metrics");
+
+      const panel = document.getElementById("panel-metrics");
+      const errorBoundary = panel?.querySelector(".tab-error-boundary");
+      expect(errorBoundary).toBeTruthy();
+      expect(errorBoundary?.textContent).toContain("Init failed!");
+
+      consoleSpy.mockRestore();
+    });
+
+    it("catches render errors and shows error boundary", () => {
+      const errorView = {
+        init: vi.fn(),
+        render: vi.fn(() => {
+          throw new Error("Render exploded!");
+        }),
+        destroy: vi.fn(),
+      };
+      router.registerView("metrics", errorView);
+
+      const consoleSpy = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      store.set("fleetState", { pipelines: [] });
+      store.set("activeTab", "overview");
+      router.switchTab("metrics");
+
+      const panel = document.getElementById("panel-metrics");
+      const errorBoundary = panel?.querySelector(".tab-error-boundary");
+      expect(errorBoundary).toBeTruthy();
+      expect(errorBoundary?.textContent).toContain("Render exploded!");
+
+      consoleSpy.mockRestore();
+    });
+
+    it("does not stack multiple error boundaries", () => {
+      const errorView = {
+        init: vi.fn(() => {
+          throw new Error("Fail");
+        }),
+        render: vi.fn(),
+        destroy: vi.fn(),
+      };
+      router.registerView("metrics", errorView);
+
+      const consoleSpy = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      store.set("activeTab", "overview");
+      router.switchTab("metrics");
+
+      // Try to trigger again (should not add second boundary)
+      store.set("activeTab", "pipelines");
+      router.switchTab("metrics");
+
+      const panel = document.getElementById("panel-metrics");
+      const boundaries = panel?.querySelectorAll(".tab-error-boundary");
+      expect(boundaries?.length).toBeLessThanOrEqual(1);
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe("renderActiveView", () => {
+    it("renders the current active view with fleet state", () => {
+      const mockView = {
+        init: vi.fn(),
+        render: vi.fn(),
+        destroy: vi.fn(),
+      };
+      router.registerView("overview", mockView);
+
+      const fakeState = { pipelines: [] };
+      store.set("fleetState", fakeState);
+      store.set("activeTab", "overview");
+
+      router.renderActiveView();
+
+      expect(mockView.render).toHaveBeenCalledWith(fakeState);
+    });
+
+    it("does nothing when no fleet state is available", () => {
+      const mockView = {
+        init: vi.fn(),
+        render: vi.fn(),
+        destroy: vi.fn(),
+      };
+      router.registerView("overview", mockView);
+      store.set("activeTab", "overview");
+
+      router.renderActiveView();
+      expect(mockView.render).not.toHaveBeenCalled();
+    });
+  });
+});