@zaip-ai/cli 6.3.0 → 7.5.0

package/templates/.agents/dashboard/apps/frontend/src/cost-guide-calculations.ts

@@ -0,0 +1,118 @@
+import type { PricingModel } from "./dashboard-api.js";
+
+export type Currency = "USD" | "BRL";
+export type Tier = "standard" | "priority";
+
+interface TokenUsage {
+  input: number;
+  cache: number;
+  output: number;
+  reasoning: number;
+}
+
+interface CostRates {
+  input: number;
+  cache: number | null;
+  output: number;
+}
+
+export interface Example {
+  usage: TokenUsage;
+  rates: CostRates;
+  inputMultiplier: number;
+  outputMultiplier: number;
+  inputUsd: number;
+  cacheUsd: number;
+  outputUsd: number;
+  reasoningUsd: 0;
+  totalUsd: number;
+  totalBrl: number | null;
+}
+
+export const exampleUsage: TokenUsage = {
+  input: 100_000,
+  cache: 40_000,
+  output: 20_000,
+  reasoning: 8_000,
+};
+
+const roundCurrency = (value: number) => Math.round(value * 1_000_000) / 1_000_000;
+
+function calculateExample(
+  usage: TokenUsage,
+  rates: CostRates,
+  inputMultiplier: number,
+  outputMultiplier: number,
+  fxRate: number | null,
+): Example {
+  const uncachedInput = Math.max(usage.input - usage.cache, 0);
+  const inputUsd = roundCurrency((uncachedInput / 1_000_000) * rates.input * inputMultiplier);
+  const cacheUsd = roundCurrency((usage.cache / 1_000_000) * (rates.cache ?? 0) * inputMultiplier);
+  const outputUsd = roundCurrency((usage.output / 1_000_000) * rates.output * outputMultiplier);
+  const totalUsd = roundCurrency(inputUsd + cacheUsd + outputUsd);
+
+  return {
+    usage,
+    rates,
+    inputMultiplier,
+    outputMultiplier,
+    inputUsd,
+    cacheUsd,
+    outputUsd,
+    reasoningUsd: 0,
+    totalUsd,
+    totalBrl: fxRate === null ? null : roundCurrency(totalUsd * fxRate),
+  };
+}
+
+function ratesForTier(model: PricingModel, tier: Tier): CostRates | null {
+  if (tier === "standard") {
+    return {
+      input: model.input_per_million_usd,
+      cache: model.cached_input_per_million_usd,
+      output: model.output_per_million_usd,
+    };
+  }
+
+  const input = model.priority_input_per_million_usd;
+  const output = model.priority_output_per_million_usd;
+  if (input === null || input === undefined || output === null || output === undefined) {
+    return null;
+  }
+
+  return {
+    input,
+    cache: model.priority_cached_input_per_million_usd ?? null,
+    output,
+  };
+}
+
+export function calculateGuideCost(
+  model: PricingModel,
+  tier: Tier,
+  fxRate: number | null,
+): Example | null {
+  const rates = ratesForTier(model, tier);
+  return rates === null ? null : calculateExample(exampleUsage, rates, 1, 1, fxRate);
+}
+
+export function calculateLongContextGuideCost(
+  model: PricingModel,
+  fxRate: number | null,
+): Example | null {
+  if (model.long_context_threshold_tokens === null) return null;
+
+  const usage: TokenUsage = {
+    input: model.long_context_threshold_tokens + 50_000,
+    cache: exampleUsage.cache,
+    output: exampleUsage.output,
+    reasoning: exampleUsage.reasoning,
+  };
+  return calculateExample(
+    usage,
+    ratesForTier(model, "standard")!,
+    model.long_context_input_multiplier,
+    model.long_context_output_multiplier,
+    fxRate,
+  );
+}

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

@@ -39,6 +39,9 @@ export interface SqliteViewPage {
   limit: number;
   total_count: number;
   has_more: boolean;
+  snapshot_id?: string | null;
+  snapshot_updated_at?: string | null;
+  financial_summary?: Record<string, unknown>;
   totals?: Record<string, unknown>;
   period_averages?: Record<"BRL" | "USD", CostPeriodAverages>;
   rows: Array<Record<string, unknown>>;

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

@@ -1,3 +1,15 @@
+import {
+  dashboardRequestTimeoutMs,
+  fetchWithTimeout,
+  reconciliationRequestTimeoutMs,
+} from "./dashboard-http-transport.js";
+
+export {
+  dashboardRequestTimeoutMs,
+  fetchWithTimeout,
+  reconciliationRequestTimeoutMs,
+} from "./dashboard-http-transport.js";
+
 import type { ProjectOverview } from "./dashboard-project-overview.js";
 
 export type { ProjectOverview } from "./dashboard-project-overview.js";
@@ -43,6 +55,9 @@ export type WorkBoardStage =
   | "failed";
 
 export interface OperationsBoardPage {
+  snapshot_id?: string | null;
+  snapshot_updated_at?: string | null;
+  financial_summary?: Record<string, unknown>;
   stage: WorkBoardStage;
   offset: number;
   total: number;
@@ -611,37 +626,6 @@ function operationsPageParams(
   return params.toString();
 }
 
-export const dashboardRequestTimeoutMs = 60_000;
-// The command may use two minutes plus a projection rebuild; keep enough
-// transport margin to avoid false browser failures after healthy reconciliation.
-export const reconciliationRequestTimeoutMs = 180_000;
-
-export async function fetchWithTimeout(
-  path: string,
-  init: RequestInit,
-  timeoutMs = dashboardRequestTimeoutMs,
-  externalSignal?: AbortSignal,
-): Promise<Response> {
-  const controller = new AbortController();
-  const abort = () => controller.abort();
-  externalSignal?.addEventListener("abort", abort, { once: true });
-  if (externalSignal?.aborted) controller.abort();
-  const timeout = window.setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(path, { ...init, signal: controller.signal });
-  } catch (cause) {
-    if (cause instanceof DOMException && cause.name === "AbortError") {
-      throw new Error(
-        `A leitura demorou mais de ${Math.ceil(timeoutMs / 1_000)} segundos. Tente novamente.`,
-      );
-    }
-    throw cause;
-  } finally {
-    window.clearTimeout(timeout);
-    externalSignal?.removeEventListener("abort", abort);
-  }
-}
-
 function withPeriod(
   path: string,
   period: { from: string | null; to: string | null } | undefined,

package/templates/.agents/dashboard/apps/frontend/src/dashboard-http-transport.ts

@@ -0,0 +1,30 @@
+export const dashboardRequestTimeoutMs = 60_000;
+// The command may use two minutes plus a projection rebuild; keep enough
+// transport margin to avoid false browser failures after healthy reconciliation.
+export const reconciliationRequestTimeoutMs = 180_000;
+
+export async function fetchWithTimeout(
+  path: string,
+  init: RequestInit,
+  timeoutMs = dashboardRequestTimeoutMs,
+  externalSignal?: AbortSignal,
+): Promise<Response> {
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  externalSignal?.addEventListener("abort", abort, { once: true });
+  if (externalSignal?.aborted) controller.abort();
+  const timeout = window.setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(path, { ...init, signal: controller.signal });
+  } catch (cause) {
+    if (cause instanceof DOMException && cause.name === "AbortError") {
+      throw new Error(
+        `A leitura demorou mais de ${Math.ceil(timeoutMs / 1_000)} segundos. Tente novamente.`,
+      );
+    }
+    throw cause;
+  } finally {
+    window.clearTimeout(timeout);
+    externalSignal?.removeEventListener("abort", abort);
+  }
+}

package/templates/.agents/dashboard/apps/frontend/src/dashboard-runtime-status.ts

@@ -5,6 +5,7 @@ export interface DashboardRuntimeStatus {
   status: "ok" | "degraded";
   lifecycle_manifest_state: "initialized" | "missing" | "invalid";
   active_capture_failure?: { code: string } | null;
+  projection_refresh_failure?: { code?: string; message?: string } | null;
 }
 
 export async function readDashboardRuntimeStatus(
@@ -12,8 +13,10 @@ export async function readDashboardRuntimeStatus(
 ): Promise<DashboardRuntimeStatus> {
   const response = await fetch("/api/v2/health", { cache: "no-store", signal });
   const value = await response.json();
-  // A degraded response is useful diagnostic data, including HTTP 503.
+  // Pending capture can report degraded while the snapshot is fully readable.
+  // A failed HTTP request must still be surfaced as a loading error.
   if (
+    !response.ok ||
     value?.kind !== "zaip-dashboard-sqlite-runtime" ||
     typeof value.workspace !== "string" ||
     typeof value.workspace_name !== "string" ||

package/templates/.agents/dashboard/apps/frontend/src/main.tsx

@@ -2,6 +2,7 @@ import { StrictMode } from "react";
 import { createRoot } from "react-dom/client";
 import { App } from "./App.js";
 import "./styles.css";
+import "./styles-pricing.css";
 import "./pricing-settings-dialog.css";
 import "./cost-calculation-guide.css";
 

package/templates/.agents/dashboard/apps/frontend/src/project-settings-model.ts

@@ -7,6 +7,7 @@ export const stackComponentDefinitions = [
   { id: "query_builder", defaultName: "Kysely", scope: "backend" },
   { id: "database", defaultName: "PostgreSQL via Supabase", scope: "backend" },
   { id: "auth_storage", defaultName: "Supabase Auth + Storage", scope: "backend" },
+  { id: "backend_secrets", defaultName: "Infisical self-hosted", scope: "backend" },
   { id: "cache_messaging", defaultName: "Redis", scope: "backend" },
   { id: "async_queue", defaultName: "BullMQ", scope: "backend" },
   { id: "backend_infrastructure", defaultName: "Terraform", scope: "backend" },
@@ -37,6 +38,7 @@ export type StackComponentsDraft = Record<StackComponentId, StackComponentDraft>
 const descriptiveVersionComponentIds = new Set<StackComponentId>([
   "database",
   "auth_storage",
+  "backend_secrets",
   "backend_hosting",
   "frontend_hosting",
   "site_hosting",

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

@@ -36,6 +36,22 @@ const config: ProjectConfigSettings = {
 };
 
 describe("project settings form mapping", () => {
+  it("includes the backend vault in the stack and preserves an explicit existing choice", () => {
+    const draft = projectSettingsDraft(config);
+    expect(draft.components.backend_secrets.name).toBe("Infisical self-hosted");
+    draft.components.backend_secrets = {
+      name: "Existing Vault",
+      version: "Self-hosted",
+      reference: "custom",
+    };
+    const payload = buildProjectSettingsPayload(config, draft.components, draft.otherOverrides);
+    expect(payload.stack.overrides.components).toMatchObject({
+      backend_secrets: draft.components.backend_secrets,
+    });
+    expect(payload.stack.overrides.languages).toMatchObject({
+      backend: expect.arrayContaining(["Existing Vault"]),
+    });
+  });
   it("uses the supported GPT-6 model when enabling autonomous execution", () => {
     expect(defaultAutonomousExecution().autonomous.model).toBe("gpt-6.1-sol");
   });
@@ -99,6 +115,7 @@ describe("project settings form mapping", () => {
           "Kysely",
           "PostgreSQL via Supabase",
           "Supabase Auth + Storage",
+          "Infisical self-hosted",
           "Redis",
           "BullMQ",
           "Terraform",

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

@@ -154,12 +154,6 @@ describe("atomic Cost snapshot loading", () => {
     expect(shouldPollSnapshotReady(true, snapshotReadyPollAttempts)).toBe(false);
     expect(shouldPollSnapshotReady(false, 0)).toBe(false);
     expect(snapshotReadyPollExhaustedMessage).toContain("desatualizados");
-    const effects = readFileSync(new URL("./use-app-effects.ts", import.meta.url), "utf8");
-    expect(effects).toContain("const ready = await api.ready()");
-    expect(effects).toContain("await refresh(false, false, false, true)");
-    expect(effects).not.toContain("refresh(false, true");
-    expect(effects).toContain("setSnapshotUpdating(false);");
-    expect(effects).toContain("setError(snapshotReadyPollExhaustedMessage)");
   });
 
   it("observes committed snapshot revisions from an open tab with GET-only refreshes", () => {
@@ -196,20 +190,6 @@ describe("atomic Cost snapshot loading", () => {
         succeeded: true,
       }),
     ).toEqual({ observedRevision: "revision-2", pendingRevision: null });
-
-    const effects = readFileSync(new URL("./use-app-effects.ts", import.meta.url), "utf8");
-    expect(effects).toContain("const observedSnapshotRevision = useRef<string | null>(null)");
-    expect(effects).toContain("pendingSnapshotRevisionRefresh");
-    expect(effects).toContain(
-      "isCommittedSnapshotRevision(ready.snapshot_state, ready.snapshot_revision)",
-    );
-    expect(effects).toContain("settleSnapshotRevisionRefresh({");
-    expect(effects).toContain("if (succeeded) setSnapshotUpdating(false);");
-    expect(effects).toContain(
-      "snapshotRevisionPollDelay(document.visibilityState, consecutiveFailures)",
-    );
-    expect(effects).toContain("void refresh(false, false, false, true)");
-    expect(effects).not.toContain("refresh(false, false, true, true)");
   });
 
   it("does not reconcile open work automatically", () => {

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

@@ -0,0 +1,112 @@
+import { afterEach, expect, it, vi } from "vitest";
+import { snapshotReadyPollAttempts, startSnapshotObserver } from "./snapshot-observer.js";
+
+afterEach(() => vi.useRealTimers());
+const current = (revision: string) => ({
+  snapshot_state: "current" as const,
+  snapshot_revision: revision,
+});
+function fixture(updating = false) {
+  vi.useFakeTimers();
+  const options = {
+    ready: vi.fn().mockResolvedValue(current("a")),
+    reload: vi.fn().mockResolvedValue(true),
+    updating: () => updating,
+    visibility: () => "visible" as const,
+    settled: vi.fn(() => {
+      updating = false;
+    }),
+    exhausted: vi.fn(() => {
+      updating = false;
+    }),
+  };
+  return options;
+}
+
+it("shares startup/revision observation and retries rejected reload before settling", async () => {
+  const f = fixture(true);
+  f.reload.mockRejectedValueOnce(new Error("GET failed"));
+  const stop = startSnapshotObserver(f);
+  await vi.advanceTimersByTimeAsync(0);
+  expect(f.settled).not.toHaveBeenCalled();
+  await vi.advanceTimersByTimeAsync(2000);
+  expect(f.ready).toHaveBeenCalledTimes(2);
+  expect(f.reload).toHaveBeenCalledTimes(2);
+  expect(f.settled).toHaveBeenCalledOnce();
+  await vi.advanceTimersByTimeAsync(5000);
+  expect(f.reload).toHaveBeenCalledTimes(2);
+  stop();
+  expect(vi.getTimerCount()).toBe(0);
+});
+
+it("retains failed revisions and loads a successor committed during the previous GET", async () => {
+  const f = fixture();
+  const stop = startSnapshotObserver(f);
+  await vi.advanceTimersByTimeAsync(0);
+  f.ready.mockResolvedValue({ ...current("b"), snapshot_state: "updating" });
+  f.reload.mockResolvedValueOnce(false);
+  await vi.advanceTimersByTimeAsync(5000);
+  expect(f.settled).not.toHaveBeenCalled();
+  let release!: (ok: boolean) => void;
+  f.reload.mockImplementationOnce(
+    () =>
+      new Promise<boolean>((r) => {
+        release = r;
+      }),
+  );
+  await vi.advanceTimersByTimeAsync(5000);
+  const calls = f.ready.mock.calls.length;
+  f.ready.mockResolvedValue(current("c"));
+  await vi.advanceTimersByTimeAsync(30000);
+  expect(f.ready).toHaveBeenCalledTimes(calls);
+  release(true);
+  await vi.advanceTimersByTimeAsync(5000);
+  expect(f.reload).toHaveBeenCalledTimes(3);
+  await vi.advanceTimersByTimeAsync(5000);
+  expect(f.reload).toHaveBeenCalledTimes(3);
+  stop();
+});
+
+it("does not overlap pending readiness or update disposed UI", async () => {
+  const f = fixture(true);
+  let release!: (value: ReturnType<typeof current>) => void;
+  f.ready.mockImplementationOnce(
+    () =>
+      new Promise((r) => {
+        release = r;
+      }),
+  );
+  const stop = startSnapshotObserver(f);
+  await vi.advanceTimersByTimeAsync(60000);
+  expect(f.ready).toHaveBeenCalledOnce();
+  stop();
+  release(current("a"));
+  await vi.advanceTimersByTimeAsync(60000);
+  expect(f.reload).not.toHaveBeenCalled();
+  expect(f.settled).not.toHaveBeenCalled();
+  expect(vi.getTimerCount()).toBe(0);
+});
+
+it("warns once after bounded startup attempts and recovers by passive observation", async () => {
+  const f = fixture(true);
+  f.ready.mockResolvedValue({ snapshot_state: "updating" });
+  const stop = startSnapshotObserver(f);
+  await vi.advanceTimersByTimeAsync((snapshotReadyPollAttempts - 1) * 2000);
+  expect(f.exhausted).toHaveBeenCalledOnce();
+  expect(f.ready).toHaveBeenCalledTimes(snapshotReadyPollAttempts);
+  f.ready.mockResolvedValue(current("new"));
+  await vi.advanceTimersByTimeAsync(5000);
+  expect(f.settled).toHaveBeenCalledOnce();
+  stop();
+});
+
+it("backs off failed observation while hidden", async () => {
+  const f = { ...fixture(), visibility: () => "hidden" as const };
+  f.ready.mockRejectedValueOnce(new Error("offline"));
+  const stop = startSnapshotObserver(f);
+  await vi.advanceTimersByTimeAsync(29999);
+  expect(f.ready).toHaveBeenCalledOnce();
+  await vi.advanceTimersByTimeAsync(1);
+  expect(f.ready).toHaveBeenCalledTimes(2);
+  stop();
+});

package/templates/.agents/dashboard/apps/frontend/src/snapshot-observer.ts

@@ -0,0 +1,147 @@
+export const projectionRefreshDebounceMs = 5_000;
+export const snapshotReadyPollMs = 2_000;
+export const snapshotReadyPollAttempts = 90;
+export const snapshotRevisionVisiblePollMs = 5_000;
+export const snapshotRevisionHiddenPollMs = 10_000;
+export const snapshotRevisionHiddenFailurePollMs = 30_000;
+export const snapshotReadyPollExhaustedMessage =
+  "A atualização do snapshot não foi concluída. Os dados exibidos podem estar desatualizados.";
+
+export function shouldPollSnapshotReady(snapshotUpdating: boolean, attempts: number): boolean {
+  return snapshotUpdating && attempts < snapshotReadyPollAttempts;
+}
+
+export function snapshotRevisionPollDelay(
+  visibilityState: DocumentVisibilityState,
+  consecutiveFailures: number,
+): number {
+  if (visibilityState === "visible") return snapshotRevisionVisiblePollMs;
+  return consecutiveFailures > 0
+    ? snapshotRevisionHiddenFailurePollMs
+    : snapshotRevisionHiddenPollMs;
+}
+
+export function shouldRefreshForSnapshotRevision(
+  previousRevision: string | null,
+  nextRevision: string | undefined,
+): boolean {
+  return (
+    previousRevision !== null &&
+    typeof nextRevision === "string" &&
+    nextRevision.length > 0 &&
+    previousRevision !== nextRevision
+  );
+}
+
+export function isCommittedSnapshotRevision(
+  snapshotState: "current" | "updating" | undefined,
+  snapshotRevision: string | undefined,
+): snapshotRevision is string {
+  return (
+    (snapshotState === "current" || snapshotState === "updating") &&
+    typeof snapshotRevision === "string" &&
+    snapshotRevision.length > 0
+  );
+}
+
+/** A changed immutable revision is usable even while its successor is building. */
+export function settleSnapshotRevisionRefresh({
+  observedRevision,
+  pendingRevision,
+  requestedRevision,
+  succeeded,
+}: {
+  observedRevision: string | null;
+  pendingRevision: string | null;
+  requestedRevision: string;
+  succeeded: boolean;
+}): { observedRevision: string | null; pendingRevision: string | null } {
+  if (!succeeded) return { observedRevision, pendingRevision };
+  return {
+    observedRevision: requestedRevision,
+    pendingRevision: pendingRevision === requestedRevision ? null : pendingRevision,
+  };
+}
+
+export function shouldRefreshVisibleProjection({
+  inFlight,
+  lastRefreshAt,
+  now,
+  visibilityState,
+}: {
+  inFlight: boolean;
+  lastRefreshAt: number;
+  now: number;
+  visibilityState: DocumentVisibilityState;
+}): boolean {
+  return (
+    visibilityState === "visible" && !inFlight && now - lastRefreshAt >= projectionRefreshDebounceMs
+  );
+}
+
+/** One serialized readiness observer owns startup and passive revision checks.
+ * Neither a failed GET nor disposal acknowledges a revision the UI never loaded.
+ */
+export function startSnapshotObserver(options: {
+  ready: () => Promise<{ snapshot_state?: "current" | "updating"; snapshot_revision?: string }>;
+  reload: () => Promise<boolean>;
+  updating: () => boolean;
+  visibility: () => DocumentVisibilityState;
+  settled: () => void;
+  exhausted: (message: string) => void;
+}): () => void {
+  let disposed = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let revision: string | null = null;
+  let failures = 0;
+  let attempts = 0;
+  let startupPending = options.updating();
+  let warned = false;
+  const poll = async () => {
+    if (disposed) return;
+    // An explicit refresh can begin while this observer is already mounted.
+    if (options.updating() && !startupPending) {
+      startupPending = true;
+      attempts = 0;
+      warned = false;
+    }
+    if (startupPending) attempts++;
+    try {
+      const ready = await options.ready();
+      if (disposed) return;
+      failures = 0;
+      const committed = isCommittedSnapshotRevision(ready.snapshot_state, ready.snapshot_revision);
+      const changed =
+        committed && shouldRefreshForSnapshotRevision(revision, ready.snapshot_revision);
+      if (changed || (startupPending && ready.snapshot_state === "current")) {
+        const succeeded = await options.reload();
+        if (disposed) return;
+        if (succeeded) {
+          if (committed) revision = ready.snapshot_revision ?? null;
+          startupPending = false;
+          options.settled();
+        }
+      } else if (revision === null && committed) {
+        revision = ready.snapshot_revision ?? null;
+      }
+    } catch {
+      failures++;
+    }
+    if (disposed) return;
+    if (startupPending && attempts >= snapshotReadyPollAttempts && !warned) {
+      warned = true;
+      options.exhausted(snapshotReadyPollExhaustedMessage);
+    }
+    timer = setTimeout(
+      () => void poll(),
+      startupPending && !warned
+        ? snapshotReadyPollMs
+        : snapshotRevisionPollDelay(options.visibility(), failures),
+    );
+  };
+  void poll();
+  return () => {
+    disposed = true;
+    if (timer !== undefined) clearTimeout(timer);
+  };
+}