@zaip-ai/cli 1.0.8 → 1.3.1

package/templates/.agents/dashboard/packages/local-runtime/start-dashboard.test.mjs

@@ -1,12 +1,12 @@
 import { EventEmitter } from "node:events";
 import { mkdir, mkdtemp, readFile, rm, utimes } from "node:fs/promises";
-import { connect, createServer } from "node:net";
+import { createServer } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import {
-  browserLaunchCommands,
   assertDashboardPrerequisites,
+  browserLaunchCommands,
   findAvailablePort,
   findAvailablePortWithFallback,
   findReusableDashboardSession,
@@ -21,7 +21,6 @@ import {
   recordPortStatus,
   registeredListenerMatches,
   runtimeKind,
-  startDashboardLaunchPage,
   stopOwnedDashboardProcess,
   stripTerminalControlCodes,
   teardownWarning,
@@ -59,7 +58,7 @@ describe("dashboard executable session", () => {
 
     expect(source).toContain("export async function assertDashboardPrerequisites()");
     expect(source).toContain('await import("node:sqlite")');
-    expect(source).not.toContain("builtinModules.includes(\"node:sqlite\")");
+    expect(source).not.toContain('builtinModules.includes("node:sqlite")');
     expect(source).toContain("Node.js 22 ou superior");
     expect(source.indexOf("await openBrowser(dashboardUrl(launchPort, token))")).toBeLessThan(
       source.indexOf("await assertDashboardPrerequisites();"),
@@ -78,8 +77,12 @@ describe("dashboard executable session", () => {
     const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
     expect(source).toContain("expectedBuildSignature: buildSignature,");
     expect(source).toContain('expectedSnapshotState: "current",');
-    expect(source).toContain("Reused healthy compatible dashboard session on port ${reusable.port}");
-    expect(source).toContain("await redirectLaunchPage(launchPage, dashboardUrl(reusable.port, reusable.token));");
+    expect(source).toContain(
+      "Reused healthy compatible dashboard session on port ${reusable.port}",
+    );
+    expect(source).toContain(
+      "await redirectLaunchPage(launchPage, dashboardUrl(reusable.port, reusable.token));",
+    );
     expect(source).toContain("const previousSessions = await previousDashboardSessions();");
     const excludedPorts = source.slice(
       source.indexOf("const excludedPorts = new Set(["),
@@ -91,13 +94,13 @@ describe("dashboard executable session", () => {
 
   it("opens preparation before checking freshness and keeps it through server health", async () => {
     const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
-    const lock = source.indexOf("await withLauncherLock(async () => {");
+    const lock = source.indexOf("await withLauncherLock(");
     const preparation = source.indexOf("launchPage = await startDashboardLaunchPage(0);");
     const freshness = source.indexOf("const buildSignature = await ensureFreshDashboardBuild();");
-    const server = source.indexOf("const { child, port, dbPath, snapshotCache } = await startDashboardServer(");
-    const redirectAfterServer = source.indexOf(
-      "await redirectLaunchPage(launchPage, dashboardUrl(port, token, snapshotCache === \"stale_seed\"));",
+    const server = source.indexOf(
+      "const { child, port, dbPath, snapshotCache } = await startDashboardServer(",
     );
+    const redirectAfterServer = source.indexOf("await redirectLaunchPage(", server);
 
     expect(lock).toBeGreaterThan(-1);
     expect(preparation).toBeLessThan(lock);
@@ -108,9 +111,13 @@ describe("dashboard executable session", () => {
 
   it("reports readiness failures as actionable without retrying a build storm", async () => {
     const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
-    const wait = source.slice(source.indexOf("async function waitForDashboard"), source.indexOf("function exists"));
+    const wait = source.slice(
+      source.indexOf("async function waitForDashboard"),
+      source.indexOf("function exists"),
+    );
     expect(wait).toContain("Dashboard data readiness returned ${readiness.status}");
     expect(wait).toContain("unavailable.retryable = false;");
+    expect(wait).toContain("timedOut.retryable = false;");
     expect(wait).toContain("if (error?.retryable === false) throw error;");
     expect(wait).toContain("await delay(100);");
   });
@@ -118,38 +125,67 @@ describe("dashboard executable session", () => {
   it("streams complete structured rebuild progress records even when stderr chunks split a line", async () => {
     const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
 
-    expect(source).toContain("let startupTelemetryBuffer = \"\";");
-    expect(source).toContain("startupTelemetryBuffer = `${startupTelemetryBuffer}${String(chunk)}`;");
+    expect(source).toContain('let startupTelemetryBuffer = "";');
+    expect(source).toContain(
+      "startupTelemetryBuffer = `${startupTelemetryBuffer}${String(chunk)}`;",
+    );
     expect(source).toContain('event?.event === "dashboard_sqlite_rebuild_progress"');
     expect(source).toContain('ZAIP_DASHBOARD_LAUNCH_PROGRESS: "1"');
   });
 
   it("uses one durable cache and an append-only worker log for a stale snapshot refresh", async () => {
     const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
+    const refresh = await readFile(
+      new URL("./start-dashboard-refresh.mjs", import.meta.url),
+      "utf8",
+    );
+    expect(source).toContain(
+      'const sqliteSnapshotCacheDirectory = join(sqliteReadModelDirectory, "cache");',
+    );
+    expect(refresh).toContain("ZAIP_WORKSPACE: workspaceRoot,");
+    expect(refresh).toContain("ZAIP_SQLITE_CACHE_DIR: cacheDirectory,");
+    expect(source).toContain(
+      'const refreshLogPath = join(sessionDirectory, "dashboard-sqlite-refresh.log");',
+    );
+    expect(refresh).toContain('stdio: ["ignore", descriptor, descriptor]');
+    expect(refresh).toContain("worker log ${refreshLogPath}");
+  });
 
-    expect(source).toContain('const sqliteSnapshotCacheDirectory = join(sqliteReadModelDirectory, "cache");');
-    expect(source).toContain("ZAIP_SQLITE_CACHE_DIR: sqliteSnapshotCacheDirectory,");
-    expect(source).toContain('const refreshLogPath = join(sessionDirectory, "dashboard-sqlite-refresh.log");');
-    expect(source).toContain("stdio: [\"ignore\", refreshLogDescriptor, refreshLogDescriptor]");
-    expect(source).toContain("worker log ${refreshLogPath}");
+  it("persists the refresh worker PID before another launcher click may coalesce it", async () => {
+    const refresh = await readFile(
+      new URL("./start-dashboard-refresh.mjs", import.meta.url),
+      "utf8",
+    );
+
+    expect(refresh).toContain("await acquireRefreshLock(lockPath, isProcessAlive)");
+    expect(refresh).toContain("if (await isRunning())");
+    expect(refresh).toContain("await writeJsonAtomic(refreshStatusPath, {");
+    expect(refresh).toContain("await stopProcessTree(worker.pid).catch(() => {});");
+    const runningBarrier = refresh.slice(0, refresh.indexOf('worker.once("error"'));
+    expect(runningBarrier).not.toContain("void writeJsonAtomic(refreshStatusPath, {");
   });
 
-  it("keeps a visible, actionable handoff watchdog instead of closing the preparation page before navigation", async () => {
-    const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
+  it("keeps the automatic handoff status visible instead of offering an unreliable local link", async () => {
+    const [source, launcherSource] = await Promise.all([
+      readFile(new URL("./start-dashboard-launch-page.mjs", import.meta.url), "utf8"),
+      readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8"),
+    ]);
 
-    expect(source).toContain('id="handoff-link"');
+    expect(source).toContain("O dashboard está pronto. Abrindo a tela principal automaticamente…");
+    expect(source).not.toContain('id="handoff-link"');
     expect(source).toContain("function showHandoff(target)");
     expect(source).toContain("setTimeout(()=>location.replace(next.target),0)");
     expect(source).toContain("closeAfterHandoffGrace: (graceMs = 12_000)");
-    expect(source).toContain("launchPage.closeAfterHandoffGrace();");
-    expect(source).not.toContain("await launchPage.close();\n  if (!redirected");
+    expect(launcherSource).toContain("launchPage.closeAfterHandoffGrace();");
+    expect(launcherSource).not.toContain("await launchPage.close();\n  if (!redirected");
   });
 
   it("tears down prior owned sessions only after the new browser handoff", async () => {
     const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
-    const redirect = source.indexOf(
-      "await redirectLaunchPage(launchPage, dashboardUrl(port, token, snapshotCache === \"stale_seed\"));",
+    const server = source.indexOf(
+      "const { child, port, dbPath, snapshotCache } = await startDashboardServer(",
     );
+    const redirect = source.indexOf("await redirectLaunchPage(", server);
     const teardown = source.indexOf("for (const previous of previousSessions)");
 
     expect(redirect).toBeGreaterThan(-1);
@@ -217,7 +253,9 @@ describe("dashboard executable session", () => {
     );
 
     const ok = source.indexOf('if (status.StartsWith("ok", StringComparison.OrdinalIgnoreCase))');
-    const warning = source.indexOf('if (status.StartsWith("warning", StringComparison.OrdinalIgnoreCase))');
+    const warning = source.indexOf(
+      'if (status.StartsWith("warning", StringComparison.OrdinalIgnoreCase))',
+    );
     const okBranch = source.slice(ok, warning);
 
     expect(ok).toBeGreaterThan(-1);
@@ -227,7 +265,10 @@ describe("dashboard executable session", () => {
 
   it("publishes ok only after Node observed both health and readiness", async () => {
     const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
-    const wait = source.slice(source.indexOf("async function waitForDashboard"), source.indexOf("function exists"));
+    const wait = source.slice(
+      source.indexOf("async function waitForDashboard"),
+      source.indexOf("function exists"),
+    );
 
     expect(wait).toContain("dashboardHealthUrl(port)");
     expect(wait).toContain("/api/v2/ready");
@@ -260,13 +301,22 @@ describe("dashboard executable session", () => {
     ]);
   });
 
+  it("keeps a Linux browser fallback when xdg-open is unavailable", () => {
+    const target = "http://127.0.0.1:4317/?token=local-session-token";
+
+    expect(browserLaunchCommands(target, "linux")).toEqual([
+      ["xdg-open", [target]],
+      ["gio", ["open", target]],
+    ]);
+  });
+
   it("falls back to another browser command when the first option fails", async () => {
     let calls = 0;
     const spawnImpl = () => {
-      calls += 1;
+      const attempt = ++calls;
       const child = new EventEmitter();
       child.unref = () => {};
-      queueMicrotask(() => child.emit(calls === 1 ? "error" : "spawn", new Error("failed")));
+      queueMicrotask(() => child.emit(attempt === 1 ? "error" : "spawn", new Error("failed")));
       return child;
     };
 
@@ -274,58 +324,6 @@ describe("dashboard executable session", () => {
     expect(calls).toBe(2);
   });
 
-  it("serves a viewport-covering centered progress overlay while the runtime starts", async () => {
-    const launchPage = await startDashboardLaunchPage(0);
-    try {
-      const page = await fetch(`http://${host}:${launchPage.port}/?token=temporary`);
-      const health = await fetch(`http://${host}:${launchPage.port}/api/v2/health`);
-
-      expect(page.status).toBe(200);
-      const html = await page.text();
-      expect(html).toContain('class="launch-overlay"');
-      expect(html).toContain("position:fixed;inset:0;width:100vw;height:100vh");
-      expect(html).toContain("display:grid;place-items:center");
-      expect(html).toContain('aria-live="polite" role="status"');
-      expect(html).toContain("abra o dashboard agora");
-      expect(html).toContain("function showHandoff(target)");
-      const progress = await fetch(`http://${host}:${launchPage.port}/api/v2/progress`);
-      await expect(progress.json()).resolves.toMatchObject({
-        phase: "Iniciando o launcher local",
-        percent: expect.any(Number),
-      });
-      expect(health.status).toBe(503);
-      await expect(health.json()).resolves.toEqual({
-        kind: "zaip-dashboard-launcher",
-        status: "starting",
-      });
-
-      launchPage.redirect("http://127.0.0.1:4317/?token=reused-session");
-      const ready = await fetch(`http://${host}:${launchPage.port}/api/v2/ready`);
-      await expect(ready.json()).resolves.toEqual({
-        target: "http://127.0.0.1:4317/?token=reused-session",
-      });
-      await expect(launchPage.waitForRedirect(10)).resolves.toBe(true);
-    } finally {
-      await launchPage.close();
-    }
-  });
-
-  it("bounds launch-page shutdown when a browser connection never finishes polling", async () => {
-    const launchPage = await startDashboardLaunchPage(0);
-    const connection = connect({ host, port: launchPage.port });
-    await new Promise((resolveConnected, rejectConnected) => {
-      connection.once("connect", resolveConnected);
-      connection.once("error", rejectConnected);
-    });
-    const closed = new Promise((resolveClosed) => connection.once("close", resolveClosed));
-    const startedAt = Date.now();
-    await launchPage.close({ forceAfterMs: 20 });
-    await closed;
-
-    expect(Date.now() - startedAt).toBeLessThan(500);
-    expect(connection.destroyed).toBe(true);
-  });
-
   it("reuses a healthy session owned by the same workspace", async () => {
     const directory = await temporaryDirectory();
     const path = join(directory, "dashboard-session.json");
@@ -611,16 +609,23 @@ describe("dashboard executable session", () => {
   it("opens preparation before waiting and only reuses after checking the current build", async () => {
     const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
     const preparation = source.indexOf("launchPage = await startDashboardLaunchPage(0);");
-    const lock = source.indexOf("await withLauncherLock(async () => {");
-    const buildSignature = source.indexOf("const buildSignature = await ensureFreshDashboardBuild();");
+    const lock = source.indexOf("await withLauncherLock(");
+    const buildSignature = source.indexOf(
+      "const buildSignature = await ensureFreshDashboardBuild();",
+    );
     const reusable = source.indexOf("const reusable = await findReusableDashboardSession({");
 
     expect(preparation).toBeLessThan(lock);
     expect(buildSignature).toBeGreaterThan(lock);
     expect(reusable).toBeGreaterThan(buildSignature);
-    expect(source).toContain("await redirectLaunchPage(launchPage, dashboardUrl(reusable.port, reusable.token));");
-    expect(source).toContain('snapshotState: snapshotCache === "stale_seed" ? "updating" : "current",');
-    expect(source).toContain("if (launchPage !== null) await launchPage.close().catch(() => {});");
+    expect(source).toContain(
+      "await redirectLaunchPage(launchPage, dashboardUrl(reusable.port, reusable.token));",
+    );
+    expect(source).toContain(
+      'snapshotState: snapshotCache === "stale_seed" ? "updating" : "current",',
+    );
+    expect(source).toContain("launchPage.setFailure({");
+    expect(source).toContain("launchPage.closeAfterFailureObservation();");
     expect(source).toContain('await writeLauncherStatus("ok");');
   });
 
@@ -641,8 +646,9 @@ describe("dashboard executable session", () => {
       "utf8",
     );
 
-    expect(source).toContain("DateTime.UtcNow.AddSeconds(135)");
-    expect(source).toContain("mais de 135 segundos");
+    expect(source).toContain("DateTime.UtcNow.AddSeconds(420)");
+    expect(source).toContain("lock window (210 s)");
+    expect(source).toContain("bounded 180 s server");
   });
 });
 

package/templates/.agents/dashboard/packages/ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/dashboard-ui",
-  "version": "1.0.8",
+  "version": "1.3.0",
   "private": true,
   "type": "module",
   "exports": {

package/templates/.agents/dashboard/packages/windows-launcher/Program.cs

@@ -82,7 +82,10 @@ namespace ZaipDashboardLauncher
             // The Node launcher coalesces concurrent clicks and may wait for a
             // healthy build/handoff.  Keep this wrapper alive for that bounded
             // handoff instead of showing a second failure dialog.
-            var deadline = DateTime.UtcNow.AddSeconds(135);
+            // A waiting click can spend the Node lock window (210 s) behind
+            // the current leader, then still needs the bounded 180 s server
+            // startup window if that leader fails before publishing a session.
+            var deadline = DateTime.UtcNow.AddSeconds(420);
             while (DateTime.UtcNow < deadline)
             {
                 try
@@ -122,7 +125,7 @@ namespace ZaipDashboardLauncher
                 }
                 Thread.Sleep(100);
             }
-            return ReportFailure("O dashboard demorou mais de 135 segundos para abrir. As tentativas foram interrompidas; tente novamente.");
+            return ReportFailure("O dashboard ainda não publicou uma sessão pronta após 420 segundos. O processo local pode continuar registrando detalhes no log temporário; feche esta mensagem e tente novamente após verificar o log.");
         }
 
         private static bool VerifyDashboardLaunch(string workspaceRoot, out string error)

package/templates/.agents/dashboard/tests/e2e/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/dashboard-e2e",
-  "version": "1.0.8",
+  "version": "1.3.0",
   "private": true,
   "type": "module",
   "scripts": {

package/templates/.agents/dashboard/tests/e2e/playwright.config.ts

@@ -22,12 +22,15 @@ export default defineConfig({
     cwd: workspaceRoot,
     url: `${baseURL}/api/v2/health`,
     reuseExistingServer: false,
-    timeout: 30_000,
+    timeout: 120_000,
     env: {
       ZAIP_UI_TOKEN: "e2e-token",
       ZAIP_SERVER_PORT: serverPort,
       ZAIP_WORKSPACE: workspaceRoot,
       ZAIP_UI_ROOT: resolve(workspaceRoot, ".agents/dashboard/apps/frontend/dist"),
+      // Match the Windows launcher: first paint uses the latest validated
+      // immutable seed while canonical refresh work stays off the served path.
+      ZAIP_SQLITE_PREFER_LAST_VALID_SEED: "1",
     },
   },
 });

package/templates/.agents/dashboard/tests/e2e/specs/cost-monitor-loading.spec.ts

@@ -0,0 +1,142 @@
+import { expect, test } from "@playwright/test";
+
+declare global {
+  interface Window {
+    __costAbortRaceProbe: {
+      abortObserved: boolean;
+      overlayPresentAtSwitch: boolean | null;
+      shellInertAtSwitch: boolean | null;
+      switched: boolean;
+    };
+  }
+}
+
+test("releases an aborted Cost group load and keeps Operation reachable", async ({ page }) => {
+  await page.addInitScript(() => {
+    const probe = {
+      abortObserved: false,
+      overlayPresentAtSwitch: null as boolean | null,
+      shellInertAtSwitch: null as boolean | null,
+      switched: false,
+    };
+    const originalFetch = window.fetch.bind(window);
+    Object.assign(window, { __costAbortRaceProbe: probe });
+    window.fetch = (input, init) => {
+      const requestUrl = new URL(
+        typeof input === "string" ? input : input instanceof URL ? input.href : input.url,
+        window.location.href,
+      );
+      if (
+        !probe.switched &&
+        requestUrl.pathname === "/api/v2/sqlite-views" &&
+        requestUrl.searchParams.get("view") === "cost_monitor_daily"
+      ) {
+        const executionsTab = Array.from(
+          document.querySelectorAll<HTMLButtonElement>(".cost-tabs button"),
+        ).find((button) => button.textContent?.trim() === "Execuções");
+        if (executionsTab !== undefined) {
+          probe.overlayPresentAtSwitch =
+            document.querySelector(".period-transition-overlay") !== null;
+          probe.shellInertAtSwitch = executionsTab.closest("[inert]") !== null;
+          init?.signal?.addEventListener("abort", () => {
+            probe.abortObserved = true;
+          });
+          probe.switched = true;
+          executionsTab.click();
+        }
+      }
+      return originalFetch(input, init);
+    };
+  });
+
+  await openDashboard(page);
+  await expectGlobalMonthPreset(page);
+  const capabilityNav = page.getByRole("navigation", { name: "Áreas do dashboard" });
+  await capabilityNav.getByRole("button", { name: /Monitor de Custos/ }).click();
+  const costTabs = page.locator(".cost-tabs");
+  await expect(costTabs).toBeVisible();
+  await expect
+    .poll(() => page.evaluate(() => window.__costAbortRaceProbe))
+    .toMatchObject({
+      abortObserved: true,
+      overlayPresentAtSwitch: false,
+      shellInertAtSwitch: false,
+      switched: true,
+    });
+
+  const executionsTab = costTabs.getByRole("button", { exact: true, name: "Execuções" });
+  await expect(executionsTab).toHaveAttribute("aria-pressed", "true");
+  await expect(page.locator(".period-transition-overlay")).toHaveCount(0, { timeout: 15_000 });
+
+  await capabilityNav.getByRole("button", { name: /Operação/ }).click();
+  await expect(page.getByLabel("Kanban de trabalho")).toBeVisible();
+  await expect(page.locator(".period-transition-overlay")).toHaveCount(0);
+});
+
+test("loads every Cost Monitor tab before returning to Operation", async ({ page }) => {
+  const pageErrors: string[] = [];
+  const failedApiResponses: string[] = [];
+  page.on("pageerror", (error) => pageErrors.push(error.message));
+  page.on("response", (response) => {
+    if (
+      response.url().includes("/api/v2/") &&
+      !response.url().includes("/api/v2/reconcile-open-work") &&
+      response.status() >= 400
+    )
+      failedApiResponses.push(`${response.status()} ${response.url()}`);
+  });
+
+  await openDashboard(page);
+  await expectGlobalMonthPreset(page);
+  const capabilityNav = page.getByRole("navigation", { name: "Áreas do dashboard" });
+  await capabilityNav.getByRole("button", { name: /Monitor de Custos/ }).click();
+  const costTabs = page.locator(".cost-tabs");
+  await expect(costTabs).toBeVisible();
+
+  for (const [tab, view] of [
+    ["Diário", "daily"],
+    ["Mensal", "monthly"],
+    ["Anual", "annual"],
+    ["Visão geral", "overview"],
+    ["Execuções", "executions"],
+    ["Invocações de Agentes", "agentCalls"],
+    ["Zaip Agentes", "agents"],
+    ["Modelos LLM", "models"],
+    ["Provedores", "providers"],
+    ["Tarefas", "tasks"],
+    ["SPEC", "specs"],
+    ["PRD", "prds"],
+    ["Conversas", "conversations"],
+  ] as const) {
+    await expect(page.locator(".period-transition-overlay")).toHaveCount(0, { timeout: 30_000 });
+    const button = costTabs.getByRole("button", { exact: true, name: tab });
+    await button.click();
+    await expect(button).toHaveAttribute("aria-pressed", "true");
+    await expect(page.locator(".period-transition-overlay")).toHaveCount(0, { timeout: 30_000 });
+    await expect(page.locator(`.cost-content-${view}`)).toBeVisible();
+    await expect(page.locator(".cost-period-error")).toHaveCount(0);
+  }
+
+  await capabilityNav.getByRole("button", { name: /Operação/ }).click();
+  await expect(page.getByLabel("Kanban de trabalho")).toBeVisible();
+  await expect(page.locator(".period-transition-overlay")).toHaveCount(0);
+  expect(pageErrors).toEqual([]);
+  expect(failedApiResponses).toEqual([]);
+});
+
+async function expectGlobalMonthPreset(page: import("@playwright/test").Page) {
+  await expect(
+    page.locator(".dashboard-global-controls").getByRole("combobox", { name: "Período" }),
+  ).toHaveValue("this-month");
+}
+
+async function openDashboard(page: import("@playwright/test").Page) {
+  const operations = page.waitForResponse(
+    (response) =>
+      response.status() === 200 &&
+      response.url().includes("/api/v2/operations") &&
+      response.url().includes("scope=quick"),
+  );
+  await page.goto("/?token=e2e-token");
+  return operations;
+}