shipwright-cli 2.3.1 → 3.0.0

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

@@ -334,6 +334,315 @@ describe("API Client", () => {
     });
   });
 
+  describe("machine health check and join tokens", () => {
+    it("machineHealthCheck calls POST", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ machine: {} }));
+      await api.machineHealthCheck("node-1");
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/machines/node-1/health-check",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+
+    it("fetchJoinTokens calls GET /api/join-token", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ tokens: [] }));
+      await api.fetchJoinTokens();
+      expect(mockFetch).toHaveBeenCalledWith("/api/join-token", undefined);
+    });
+
+    it("generateJoinToken calls POST /api/join-token", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ join_cmd: "sw join ..." }));
+      await api.generateJoinToken({ label: "test", max_workers: 4 });
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/join-token",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+  });
+
+  describe("costs", () => {
+    it("fetchCostBreakdown defaults to 7 day period", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchCostBreakdown();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/costs/breakdown?period=7",
+        undefined,
+      );
+    });
+
+    it("fetchCostTrend defaults to 30 day period", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ points: [] }));
+      await api.fetchCostTrend();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/costs/trend?period=30",
+        undefined,
+      );
+    });
+  });
+
+  describe("daemon", () => {
+    it("fetchDaemonConfig calls GET /api/daemon/config", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchDaemonConfig();
+      expect(mockFetch).toHaveBeenCalledWith("/api/daemon/config", undefined);
+    });
+
+    it("daemonControl calls POST /api/daemon/:action", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.daemonControl("pause");
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/daemon/pause",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+  });
+
+  describe("alerts and artifacts", () => {
+    it("fetchAlerts calls GET /api/alerts", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ alerts: [] }));
+      await api.fetchAlerts();
+      expect(mockFetch).toHaveBeenCalledWith("/api/alerts", undefined);
+    });
+
+    it("fetchArtifact calls correct endpoint", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ content: "..." }));
+      await api.fetchArtifact(42, "plan");
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/artifacts/42/plan",
+        undefined,
+      );
+    });
+
+    it("fetchGitHubStatus calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchGitHubStatus(42);
+      expect(mockFetch).toHaveBeenCalledWith("/api/github/42", undefined);
+    });
+
+    it("fetchLogs calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ content: "log" }));
+      await api.fetchLogs(42);
+      expect(mockFetch).toHaveBeenCalledWith("/api/logs/42", undefined);
+    });
+  });
+
+  describe("metrics detail", () => {
+    it("fetchStagePerformance defaults to 7 days", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ stages: [] }));
+      await api.fetchStagePerformance();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/stage-performance?period=7",
+        undefined,
+      );
+    });
+
+    it("fetchBottlenecks calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ bottlenecks: [] }));
+      await api.fetchBottlenecks();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/bottlenecks",
+        undefined,
+      );
+    });
+
+    it("fetchThroughputTrend defaults to 30 days", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ points: [] }));
+      await api.fetchThroughputTrend();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/throughput-trend?period=30",
+        undefined,
+      );
+    });
+
+    it("fetchCapacity calls GET", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ rate: 2, queue_clear_hours: 1 }),
+      );
+      await api.fetchCapacity();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/capacity",
+        undefined,
+      );
+    });
+
+    it("fetchDoraTrend defaults to 30 days", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchDoraTrend();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/dora-trend?period=30",
+        undefined,
+      );
+    });
+  });
+
+  describe("team endpoints", () => {
+    it("fetchTeam calls GET /api/team", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchTeam();
+      expect(mockFetch).toHaveBeenCalledWith("/api/team", undefined);
+    });
+
+    it("fetchTeamActivity returns events array", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ events: [{ id: 1 }] }));
+      const result = await api.fetchTeamActivity();
+      expect(result).toEqual([{ id: 1 }]);
+    });
+
+    it("fetchTeamActivity returns empty array on error", async () => {
+      mockFetch.mockReturnValueOnce(errorResponse(500));
+      const result = await api.fetchTeamActivity();
+      expect(result).toEqual([]);
+    });
+
+    it("createTeamInvite calls POST /api/team/invite", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ token: "abc", url: "...", expires_at: "..." }),
+      );
+      await api.createTeamInvite({ expires_hours: 24 });
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/team/invite",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+  });
+
+  describe("pipeline test results and learnings", () => {
+    it("fetchPipelineTestResults calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchPipelineTestResults(42);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/pipeline/42/test-results",
+        undefined,
+      );
+    });
+
+    it("fetchGlobalLearnings calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ learnings: [] }));
+      await api.fetchGlobalLearnings();
+      expect(mockFetch).toHaveBeenCalledWith("/api/memory/global", undefined);
+    });
+
+    it("fetchPatrol returns findings on success", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ findings: [{ id: 1 }] }));
+      const result = await api.fetchPatrol();
+      expect(result).toEqual({ findings: [{ id: 1 }] });
+    });
+  });
+
+  describe("integration and DB endpoints", () => {
+    it("fetchLinearStatus calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchLinearStatus();
+      expect(mockFetch).toHaveBeenCalledWith("/api/linear/status", undefined);
+    });
+
+    it("fetchDbEvents with defaults", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ events: [], source: "db" }));
+      await api.fetchDbEvents();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/db/events?since=0&limit=200",
+        undefined,
+      );
+    });
+
+    it("fetchDbJobs without status filter", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ jobs: [], source: "db" }));
+      await api.fetchDbJobs();
+      expect(mockFetch).toHaveBeenCalledWith("/api/db/jobs", undefined);
+    });
+
+    it("fetchDbJobs with status filter", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ jobs: [], source: "db" }));
+      await api.fetchDbJobs("active");
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/db/jobs?status=active",
+        undefined,
+      );
+    });
+
+    it("fetchDbCostsToday calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchDbCostsToday();
+      expect(mockFetch).toHaveBeenCalledWith("/api/db/costs/today", undefined);
+    });
+
+    it("fetchDbHeartbeats calls GET", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ heartbeats: [], source: "db" }),
+      );
+      await api.fetchDbHeartbeats();
+      expect(mockFetch).toHaveBeenCalledWith("/api/db/heartbeats", undefined);
+    });
+
+    it("fetchDbHealth calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchDbHealth();
+      expect(mockFetch).toHaveBeenCalledWith("/api/db/health", undefined);
+    });
+  });
+
+  describe("audit, quality gates, approvals, notifications", () => {
+    it("fetchAuditLog calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ entries: [] }));
+      await api.fetchAuditLog();
+      expect(mockFetch).toHaveBeenCalledWith("/api/audit-log", undefined);
+    });
+
+    it("fetchQualityGates calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ enabled: true, rules: [] }));
+      await api.fetchQualityGates();
+      expect(mockFetch).toHaveBeenCalledWith("/api/quality-gates", undefined);
+    });
+
+    it("fetchPipelineQuality calls GET", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ quality: {}, gates: {}, results: [] }),
+      );
+      await api.fetchPipelineQuality(42);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/pipeline/42/quality",
+        undefined,
+      );
+    });
+
+    it("fetchApprovalGates calls GET", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ enabled: true, stages: [], pending: [] }),
+      );
+      await api.fetchApprovalGates();
+      expect(mockFetch).toHaveBeenCalledWith("/api/approval-gates", undefined);
+    });
+
+    it("updateApprovalGates calls POST", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.updateApprovalGates({ enabled: true, stages: ["review"] });
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/approval-gates",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+
+    it("fetchNotificationConfig calls GET", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ enabled: true, webhooks: [] }),
+      );
+      await api.fetchNotificationConfig();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/notifications/config",
+        undefined,
+      );
+    });
+
+    it("testNotification calls POST", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.testNotification();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/notifications/test",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+  });
+
   describe("error handling", () => {
     it("throws on non-ok response", async () => {
       mockFetch.mockReturnValueOnce(errorResponse(404, { error: "Not found" }));

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

@@ -0,0 +1,301 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  formatDuration,
+  formatTime,
+  escapeHtml,
+  fmtNum,
+  truncate,
+  padZero,
+  getBadgeClass,
+  getTypeShort,
+  animateValue,
+  timeAgo,
+  formatMarkdown,
+} from "./helpers";
+
+describe("helpers", () => {
+  describe("formatDuration", () => {
+    it("returns em dash for null/undefined", () => {
+      expect(formatDuration(null)).toBe("\u2014");
+      expect(formatDuration(undefined)).toBe("\u2014");
+    });
+
+    it("formats seconds (< 60)", () => {
+      expect(formatDuration(0)).toBe("0s");
+      expect(formatDuration(30)).toBe("30s");
+      expect(formatDuration(59)).toBe("59s");
+    });
+
+    it("formats minutes and seconds (60-3599)", () => {
+      expect(formatDuration(60)).toBe("1m 0s");
+      expect(formatDuration(90)).toBe("1m 30s");
+      expect(formatDuration(125)).toBe("2m 5s");
+      expect(formatDuration(3599)).toBe("59m 59s");
+    });
+
+    it("formats hours and minutes (>= 3600)", () => {
+      expect(formatDuration(3600)).toBe("1h 0m");
+      expect(formatDuration(3661)).toBe("1h 1m");
+      expect(formatDuration(7325)).toBe("2h 2m");
+    });
+
+    it("floors fractional seconds", () => {
+      expect(formatDuration(59.9)).toBe("59s");
+      expect(formatDuration(60.9)).toBe("1m 0s");
+    });
+
+    it("handles negative values (formats as seconds when abs < 60)", () => {
+      expect(formatDuration(-5)).toBe("-5s");
+      expect(formatDuration(-65)).toBe("-65s");
+    });
+  });
+
+  describe("formatTime", () => {
+    it("returns em dash for null/undefined/empty", () => {
+      expect(formatTime(null)).toBe("\u2014");
+      expect(formatTime(undefined)).toBe("\u2014");
+      expect(formatTime("")).toBe("\u2014");
+    });
+
+    it("formats ISO string as HH:MM:SS (local time)", () => {
+      const result = formatTime("2025-02-17T14:30:45Z");
+      expect(result).toMatch(/^\d{2}:\d{2}:\d{2}$/);
+      const [, , sec] = result.split(":");
+      expect(Number(sec)).toBe(45);
+    });
+  });
+
+  describe("escapeHtml", () => {
+    it("returns empty string for null/undefined", () => {
+      expect(escapeHtml(null)).toBe("");
+      expect(escapeHtml(undefined)).toBe("");
+    });
+
+    it("escapes XSS characters", () => {
+      expect(escapeHtml("<script>")).toBe("&lt;script&gt;");
+      expect(escapeHtml(">")).toBe("&gt;");
+      expect(escapeHtml("&")).toBe("&amp;");
+      expect(escapeHtml('"')).toBe("&quot;");
+    });
+
+    it("escapes combined characters", () => {
+      expect(escapeHtml('<img src="x">')).toBe("&lt;img src=&quot;x&quot;&gt;");
+    });
+
+    it("leaves single quote unchanged (not escaped in impl)", () => {
+      expect(escapeHtml("'")).toBe("'");
+    });
+  });
+
+  describe("fmtNum", () => {
+    it("returns 0 for null/undefined", () => {
+      expect(fmtNum(null)).toBe("0");
+      expect(fmtNum(undefined)).toBe("0");
+    });
+
+    it("formats numbers with locale string", () => {
+      expect(fmtNum(0)).toBe("0");
+      expect(fmtNum(1000)).toBe("1,000");
+      expect(fmtNum(1234567)).toBe("1,234,567");
+    });
+  });
+
+  describe("truncate", () => {
+    it("returns empty string for null/undefined", () => {
+      expect(truncate(null, 10)).toBe("");
+      expect(truncate(undefined, 10)).toBe("");
+    });
+
+    it("returns string as-is when within maxLen", () => {
+      expect(truncate("hello", 10)).toBe("hello");
+      expect(truncate("hello", 5)).toBe("hello");
+    });
+
+    it("truncates with ellipsis when exceeding maxLen", () => {
+      expect(truncate("hello world", 5)).toBe("hello…");
+      expect(truncate("abcdefghij", 8)).toBe("abcdefgh…");
+    });
+  });
+
+  describe("padZero", () => {
+    it("pads single digits with leading zero", () => {
+      expect(padZero(0)).toBe("00");
+      expect(padZero(5)).toBe("05");
+      expect(padZero(9)).toBe("09");
+    });
+
+    it("does not pad double digits", () => {
+      expect(padZero(10)).toBe("10");
+      expect(padZero(99)).toBe("99");
+    });
+  });
+
+  describe("getBadgeClass", () => {
+    it("returns intervention for intervention type", () => {
+      expect(getBadgeClass("foo.intervention")).toBe("intervention");
+    });
+
+    it("returns heartbeat for heartbeat type", () => {
+      expect(getBadgeClass("machine.heartbeat")).toBe("heartbeat");
+    });
+
+    it("returns recovery for recovery/checkpoint", () => {
+      expect(getBadgeClass("stage.recovery")).toBe("recovery");
+      expect(getBadgeClass("foo.checkpoint")).toBe("recovery");
+    });
+
+    it("returns remote for remote/distributed", () => {
+      expect(getBadgeClass("job.remote")).toBe("remote");
+      expect(getBadgeClass("distributed.task")).toBe("remote");
+    });
+
+    it("returns other specific classes", () => {
+      expect(getBadgeClass("poll")).toBe("poll");
+      expect(getBadgeClass("spawn")).toBe("spawn");
+      expect(getBadgeClass("started")).toBe("started");
+      expect(getBadgeClass("completed")).toBe("completed");
+      expect(getBadgeClass("reap")).toBe("completed");
+      expect(getBadgeClass("failed")).toBe("failed");
+      expect(getBadgeClass("stage")).toBe("stage");
+      expect(getBadgeClass("scale")).toBe("scale");
+    });
+
+    it("returns default for unknown type", () => {
+      expect(getBadgeClass("unknown")).toBe("default");
+    });
+  });
+
+  describe("getTypeShort", () => {
+    it("returns last segment of dotted type", () => {
+      expect(getTypeShort("foo.bar.baz")).toBe("baz");
+      expect(getTypeShort("machine.heartbeat")).toBe("heartbeat");
+    });
+
+    it("returns full string when no dots", () => {
+      expect(getTypeShort("simple")).toBe("simple");
+    });
+
+    it("returns unknown for null/undefined (String converts)", () => {
+      expect(getTypeShort("")).toBe("unknown");
+    });
+  });
+
+  describe("animateValue", () => {
+    let el: HTMLElement;
+
+    beforeEach(() => {
+      el = document.createElement("span");
+      vi.useFakeTimers({ toFake: ["requestAnimationFrame"] });
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it("does nothing when el is null", () => {
+      animateValue(null, 0, 100, 1000);
+      vi.advanceTimersToNextFrame();
+      expect(el.textContent).toBe("");
+    });
+
+    it("sets final value immediately when start equals end", () => {
+      animateValue(el, 50, 50, 1000);
+      expect(el.textContent).toBe("50");
+    });
+
+    it("uses requestAnimationFrame when start differs from end", () => {
+      animateValue(el, 0, 100, 1000);
+      vi.advanceTimersToNextFrame();
+      expect(el.textContent).toBe("0");
+      vi.advanceTimersByTime(1000);
+      vi.advanceTimersToNextFrame();
+      expect(el.textContent).toBe("100");
+    });
+
+    it("appends suffix when provided", () => {
+      animateValue(el, 10, 10, 1000, "%");
+      expect(el.textContent).toBe("10%");
+    });
+  });
+
+  describe("timeAgo", () => {
+    const now = 1708200000000; // fixed timestamp
+
+    beforeEach(() => {
+      vi.useFakeTimers();
+      vi.setSystemTime(now);
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it("returns seconds ago when < 60s", () => {
+      const date = new Date(now - 30 * 1000);
+      expect(timeAgo(date)).toBe("30s ago");
+      expect(timeAgo(new Date(now - 0))).toBe("0s ago");
+      expect(timeAgo(new Date(now - 59 * 1000))).toBe("59s ago");
+    });
+
+    it("returns minutes ago when 60s to < 60m", () => {
+      expect(timeAgo(new Date(now - 60 * 1000))).toBe("1m ago");
+      expect(timeAgo(new Date(now - 90 * 1000))).toBe("1m ago");
+      expect(timeAgo(new Date(now - 3599 * 1000))).toBe("59m ago");
+    });
+
+    it("returns hours ago when 60m to < 24h", () => {
+      expect(timeAgo(new Date(now - 3600 * 1000))).toBe("1h ago");
+      expect(timeAgo(new Date(now - 7200 * 1000))).toBe("2h ago");
+      expect(timeAgo(new Date(now - 23 * 3600 * 1000))).toBe("23h ago");
+    });
+
+    it("returns days ago when >= 24h", () => {
+      expect(timeAgo(new Date(now - 24 * 3600 * 1000))).toBe("1d ago");
+      expect(timeAgo(new Date(now - 48 * 3600 * 1000))).toBe("2d ago");
+    });
+  });
+
+  describe("formatMarkdown", () => {
+    it("returns empty string for null/undefined", () => {
+      expect(formatMarkdown(null)).toBe("");
+      expect(formatMarkdown(undefined)).toBe("");
+    });
+
+    it("converts headers to strong", () => {
+      expect(formatMarkdown("# Title")).toContain("<strong>Title</strong>");
+      expect(formatMarkdown("## Subtitle")).toContain(
+        "<strong>Subtitle</strong>",
+      );
+      expect(formatMarkdown("### Small")).toContain("<strong>Small</strong>");
+    });
+
+    it("converts code blocks to pre", () => {
+      const result = formatMarkdown("```\nconst x = 1;\n```");
+      expect(result).toContain('<pre class="artifact-code">');
+      expect(result).toContain("const x = 1;");
+      expect(result).toContain("</pre>");
+    });
+
+    it("converts inline code to code", () => {
+      expect(formatMarkdown("Use `foo()` here")).toContain(
+        "<code>foo()</code>",
+      );
+    });
+
+    it("converts list items", () => {
+      const result = formatMarkdown("- item one\n- item two");
+      expect(result).toContain("<li>item one</li>");
+      expect(result).toContain("<li>item two</li>");
+    });
+
+    it("converts newlines to br", () => {
+      expect(formatMarkdown("line1\nline2")).toContain("line1<br>line2");
+    });
+
+    it("escapes HTML in content", () => {
+      const result = formatMarkdown("<script>alert(1)</script>");
+      expect(result).toContain("&lt;script&gt;");
+      expect(result).not.toContain("<script>");
+    });
+  });
+});