@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/apps/frontend/src/cost-period-refresh.test.ts

@@ -0,0 +1,70 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { isCurrentDashboardRequest, needsAtomicCostSnapshot } from "./App.js";
+
+describe("Cost period refresh", () => {
+  it("does not retain a prior Cost Monitor snapshot while Todo o Período is loading", () => {
+    const priorSnapshot = { generation: 1, period: "this-month" };
+    let renderedSnapshot: typeof priorSnapshot | null = priorSnapshot;
+    let exportedSnapshot: typeof priorSnapshot | null = priorSnapshot;
+
+    renderedSnapshot = null;
+    exportedSnapshot = null;
+
+    expect(needsAtomicCostSnapshot("cost-monitor", false)).toBe(false);
+    expect(renderedSnapshot).toBeNull();
+    expect(exportedSnapshot).toBeNull();
+  });
+
+  it("mounts Cost from a Daily seed without a full summary request", () => {
+    const app = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
+    const refresh = app.slice(
+      app.indexOf("const refresh = useCallback"),
+      app.indexOf("const loadOperationsDetails"),
+    );
+
+    expect(refresh).not.toContain("dailyCostSeed(currency, period)");
+    expect(refresh).toContain("initialAggregateFreshRef.current");
+    expect(refresh).not.toContain("loadAtomicCostSnapshot(() => api.snapshot(currency, period))");
+    expect(refresh).toContain('api.operations(period, "quick", undefined, initialAggregateFreshRef.current)');
+    expect(refresh).toContain('currency === "USD" ? api.costMonitor(currency, period, "summary") : Promise.resolve(null)');
+    expect(refresh).toContain("setDisplayedCosts(null);");
+    expect(refresh).toContain("const activeDashboardView = dashboardViewRef.current");
+    expect(refresh).toContain("[api, currency, operationsPeriod]");
+    expect(refresh).not.toContain("[api, currency, dashboardView, operationsPeriod]");
+  });
+
+  it("keeps the replacement snapshot when a prior-period details request resolves late", () => {
+    let refreshVersion = 3;
+    const priorRequestVersion = refreshVersion;
+    const activeExport = { generation: 3, period: "this-month" };
+
+    refreshVersion += 1;
+    const latePriorResponseIsCurrent = isCurrentDashboardRequest(
+      priorRequestVersion,
+      refreshVersion,
+    );
+
+    expect(latePriorResponseIsCurrent).toBe(false);
+    expect(activeExport).toEqual({ generation: 3, period: "this-month" });
+  });
+
+  it("connects SQLite run and filtered group pagers through App", () => {
+    const app = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
+    const loaders = readFileSync(new URL("./use-app-cost-loaders.ts", import.meta.url), "utf8");
+    expect(app).toContain("useAppCostLoaders(api)");
+    expect(loaders).toContain("const loadCostRunPage = useCallback<LoadCostRunPage>");
+    expect(loaders).toContain('api.sqliteViewPage("cost_monitor_agent_invocations"');
+    expect(loaders).toContain("const loadCostGroupPage = useCallback<LoadCostGroupPage>");
+    expect(loaders).toContain("task_count: nullableSqlNumber(row.task_count)");
+    expect(loaders).toContain("prd_count: Number(row.prd_count ?? 0)");
+    expect(loaders).toContain("spec_count: Number(row.spec_count ?? 0)");
+    expect(loaders).toContain("evidence_count: Number(row.evidence_count ?? 0)");
+    expect(loaders).toContain("test_count: Number(row.validation_count ?? 0)");
+    for (const dimension of ["provider", "model", "agent", "phase", "status", "origin", "workType", "priority", "risk"])
+      expect(loaders).toContain(`filters.${dimension}`);
+    expect(app).toContain("loadRunPage={loadCostRunPage}");
+    expect(app).toContain("loadReadModelPage={loadCostReadModelPage}");
+    expect(app).toContain("loadDetail={loadCostDetail}");
+  });
+});

package/templates/.agents/dashboard/apps/frontend/src/dashboard-api.test.ts

@@ -28,4 +28,115 @@ describe("DashboardApiClient reconciliation", () => {
     await vi.advanceTimersByTimeAsync(reconciliationRequestTimeoutMs - 30_000);
     await rejection;
   });
+
+  it("posts to the exact canonical reconciliation path without a trailing slash", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn(async () =>
+      new Response(JSON.stringify({ reconciliation: { reconciled_ids: [], blocked: [], not_reconciled: [] } }), { status: 200 }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await new DashboardApiClient("session").reconcileOpenWork("BRL", {
+      from: "2026-08-12",
+      to: "2026-08-12",
+    });
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      "/api/v2/reconcile-open-work?currency=BRL&from=2026-08-12&to=2026-08-12",
+      expect.objectContaining({ method: "POST", headers: { "x-zaip-session": "session" } }),
+    );
+  });
+});
+
+describe("DashboardApiClient cost monitor", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("serializes every supported SQLite lazy-view filter", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn((_path: string) =>
+      Promise.resolve(
+        new Response(JSON.stringify({ runs: [] }), {
+          headers: { "content-type": "application/json" },
+          status: 200,
+        }),
+      ),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await new DashboardApiClient("session").sqliteViewPage(
+      "cost_monitor_agent_invocations",
+      { from: "2026-08-01", to: "2026-08-08" },
+      {
+        limit: 100,
+        query: "edge",
+        provider: "openai",
+        model: "gpt-5",
+        agent: "agent-a",
+        phase: "execution",
+        status: "completed",
+      },
+    );
+
+    const requestPath = String(fetchMock.mock.calls[0]?.[0]);
+    for (const value of [
+      "query=edge",
+      "provider=openai",
+      "model=gpt-5",
+      "agent=agent-a",
+      "phase=execution",
+      "status=completed",
+      "from=2026-08-01",
+      "to=2026-08-08",
+    ])
+      expect(requestPath).toContain(value);
+    expect(requestPath).not.toContain("run_kind=");
+  });
+
+  it("adds fresh only to an explicit bootstrap aggregate read", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn((_path: string | URL | Request) =>
+      Promise.resolve(new Response("{}", { status: 200 })),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    const client = new DashboardApiClient("session");
+    await client.operations(undefined, "quick", undefined, true);
+    await client.costMonitor("BRL", undefined, "summary", undefined, undefined, true);
+    await client.operations(undefined, "quick");
+    const paths = fetchMock.mock.calls.map(([path]) => String(path));
+    expect(paths[0]).toContain("fresh=1");
+    expect(paths[1]).toContain("fresh=1");
+    expect(paths[2]).not.toContain("fresh=1");
+  });
+
+  it("loads dimensional detail through the authenticated client with filters and cancellation", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn((_path: string, _init?: RequestInit) =>
+      Promise.resolve(
+        new Response(JSON.stringify({ runs: [] }), {
+          headers: { "content-type": "application/json" },
+          status: 200,
+        }),
+      ),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    const controller = new AbortController();
+
+    await new DashboardApiClient("session").costMonitor(
+      "BRL",
+      { from: "2026-08-07", to: "2026-08-07" },
+      "detail",
+      controller.signal,
+      { agent: "zaip-agent-builder", model: "gpt-5.6-terra" },
+    );
+
+    const requestPath = String(fetchMock.mock.calls[0]?.[0]);
+    const requestInit = fetchMock.mock.calls[0]?.[1];
+    expect(requestPath).toContain("scope=detail");
+    expect(requestPath).toContain("agent=zaip-agent-builder");
+    expect(requestPath).toContain("model=gpt-5.6-terra");
+    expect(requestInit?.headers).toEqual({ "x-zaip-session": "session" });
+    expect(requestInit?.signal).toBeInstanceOf(AbortSignal);
+  });
 });