@zaip-ai/cli 1.3.8 → 1.4.2

package/templates/.agents/dashboard/packages/local-runtime/scripts/build-sqlite-runtime.mjs

@@ -1,4 +1,4 @@
-import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 
@@ -39,6 +39,10 @@ const buildOptions = {
       "node_modules/.pnpm/hono@4.12.34/node_modules/hono/dist/helper/websocket/index.js",
     ),
     hono: resolve(root, "node_modules/.pnpm/hono@4.12.34/node_modules/hono/dist/index.js"),
+    "hono/streaming": resolve(
+      root,
+      "node_modules/.pnpm/hono@4.12.34/node_modules/hono/dist/helper/streaming/index.js",
+    ),
     zod: resolve(root, "node_modules/.pnpm/zod@4.4.3/node_modules/zod"),
     "@zaip-ai/core": resolve(root, "packages/core/src/index.ts"),
     "@zaip-ai/costs": resolve(root, "packages/costs/src/index.ts"),
@@ -103,7 +107,15 @@ await writeFile(
   (await readFile(distributedServer, "utf8")).replace(/[ \t]+$/gm, ""),
   "utf8",
 );
-await copyFile(distributedServer, resolve(packageRoot, "server.mjs"));
+// Replace the entrypoint atomically: Windows may keep the previous file mapped
+// in a running reader even after that reader has closed its file descriptor.
+const stagedServer = resolve(packageRoot, `server.mjs.${process.pid}.tmp`);
+try {
+  await copyFile(distributedServer, stagedServer);
+  await rename(stagedServer, resolve(packageRoot, "server.mjs"));
+} finally {
+  await rm(stagedServer, { force: true });
+}
 if (process.env.ZAIP_RUNTIME_METAFILE === "1") {
   await writeFile(
     resolve(packageRoot, "dist/server.cjs.metafile.json"),

package/templates/.agents/dashboard/packages/local-runtime/scripts/rebuild-sqlite-read-model.mjs

@@ -1,5 +1,4 @@
-import { rm } from "node:fs/promises";
-import { relative, resolve } from "node:path";
+import { resolve } from "node:path";
 
 const workspaceRoot = resolve(
   process.env.ZAIP_WORKSPACE ?? resolve(import.meta.dirname, "../../../../.."),
@@ -7,27 +6,8 @@ const workspaceRoot = resolve(
 process.env.ZAIP_UI_ROOT ??= resolve(workspaceRoot, ".agents/dashboard/apps/frontend/dist");
 const { default: runtime } = await import("../dist/server.cjs");
 const { rebuildSqliteReadModel, validateSqliteReadModelSchema } = runtime;
-const cleanupPath =
-  process.env.ZAIP_SQLITE_REFRESH_CLEANUP === "1" ? process.env.ZAIP_SQLITE_DB_PATH : null;
-try {
-  const result = await rebuildSqliteReadModel(workspaceRoot);
-  const schema = validateSqliteReadModelSchema(result.path);
-  process.stdout.write(
-    `${JSON.stringify({ storage_mode: "sqlite_read_model", ...result, schema })}\n`,
-  );
-} finally {
-  // The background seed refresher owns only its generated refresh-*.sqlite
-  // path. Cleanup belongs to this worker so a launcher exit cannot leak it.
-  if (typeof cleanupPath === "string") {
-    const refreshDirectory = resolve(workspaceRoot, ".local", "dashboard-sqlite");
-    const candidate = resolve(cleanupPath);
-    const name = relative(refreshDirectory, candidate);
-    const safeGeneratedRefresh =
-      name !== "" &&
-      !name.startsWith("..") &&
-      !name.includes("/") &&
-      !name.includes("\\") &&
-      /^refresh-\d+-[0-9a-f]+\.sqlite$/i.test(name);
-    if (safeGeneratedRefresh) await rm(candidate, { force: true }).catch(() => {});
-  }
-}
+const result = await rebuildSqliteReadModel(workspaceRoot);
+const schema = validateSqliteReadModelSchema(result.path);
+process.stdout.write(
+  `${JSON.stringify({ storage_mode: "sqlite_read_model", ...result, schema })}\n`,
+);

package/templates/.agents/dashboard/packages/local-runtime/scripts/validate-sqlite-read-model.mjs

@@ -5,7 +5,7 @@ import { DatabaseSync } from "node:sqlite";
 const workspaceRoot = resolve(import.meta.dirname, "../../../../..");
 const databasePath =
   process.env.ZAIP_SQLITE_DB_PATH ??
-  resolve(workspaceRoot, ".local/dashboard-sqlite/read-model.sqlite");
+  resolve(workspaceRoot, ".local/sqlite/zaip-aios-dashboard.sqlite");
 const runtime = await import("../dist/server.cjs");
 const schema = runtime.validateSqliteReadModelSchema(databasePath);
 const database = new DatabaseSync(databasePath, { readOnly: true });

package/templates/.agents/dashboard/packages/local-runtime/scripts/verify-persistent-launch.mjs

@@ -0,0 +1,268 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { performance } from "node:perf_hooks";
+import { DatabaseSync } from "node:sqlite";
+
+// Exercise the shipped Windows entrypoint, not a test-only server. This command
+// does not edit sources. Its isolated browser owns the tested session.
+const workspace = resolve(
+  process.env.ZAIP_WORKSPACE ?? resolve(import.meta.dirname, "../../../../.."),
+);
+const databasePath = resolve(workspace, ".local/sqlite/zaip-aios-dashboard.sqlite");
+const executable = resolve(workspace, ".agents/dashboard/zaip-dashboard-windows.exe");
+const workspaceKey = createHash("sha256")
+  .update(`${workspace}:dashboard-sqlite`)
+  .digest("hex")
+  .slice(0, 16);
+const sessionPath = join(
+  tmpdir(),
+  "zaip-aios",
+  `dashboard-sqlite-${workspaceKey}`,
+  "dashboard-sqlite-session.json",
+);
+const launchTimeoutMs = positiveNumber(process.env.ZAIP_VERIFY_LAUNCH_TIMEOUT_MS, 180_000);
+const refreshTimeoutMs = positiveNumber(process.env.ZAIP_VERIFY_REFRESH_TIMEOUT_MS, 180_000);
+const warmBudgetMs = positiveNumber(process.env.ZAIP_VERIFY_WARM_BUDGET_MS, 15_000);
+const { chromium } = await import("@playwright/test");
+const browser = await chromium.launch({ headless: true });
+const pages = [];
+const pageErrors = [];
+
+function positiveNumber(value, fallback) {
+  const number = value === undefined ? fallback : Number(value);
+  assert.ok(
+    Number.isFinite(number) && number > 0,
+    "Verification timeouts must be positive numbers",
+  );
+  return number;
+}
+
+async function session() {
+  const value = JSON.parse(await readFile(sessionPath, "utf8"));
+  assert.equal(value.workspaceKey, workspaceKey, "The launcher must select this workspace");
+  assert.equal(
+    resolve(value.dbPath),
+    databasePath,
+    "The launcher must use the official persistent database",
+  );
+  assert.ok(Number.isInteger(value.serverPid) && value.serverPid > 0);
+  return value;
+}
+
+async function api(value, route) {
+  const response = await fetch(`http://127.0.0.1:${value.port}/api/v2/${route}`, {
+    headers: { "x-zaip-session": value.token },
+    signal: AbortSignal.timeout(10_000),
+  });
+  const body = await response.json();
+  return { status: response.status, body };
+}
+
+async function launch() {
+  const started = performance.now();
+  if (process.env.ZAIP_VERIFY_EXISTING_SESSION === "1") {
+    const current = await session();
+    const page = await browser.newPage({ viewport: { width: 1440, height: 960 } });
+    pages.push(page);
+    page.on("pageerror", (error) => pageErrors.push(error.message));
+    await page.goto(
+      `http://127.0.0.1:${current.port}/?token=${encodeURIComponent(current.token)}`,
+      { waitUntil: "domcontentloaded", timeout: 30_000 },
+    );
+    await page.getByRole("navigation", { name: "Áreas do dashboard" }).waitFor({ timeout: 30_000 });
+    await page.getByText("Status das tarefas", { exact: true }).waitFor({ timeout: 30_000 });
+    return { current, page, elapsedMs: null, visibleMs: Math.round(performance.now() - started) };
+  }
+  const claimPath = join(sessionPath, "..", "dashboard-sqlite-launch.json");
+  const previousClaim = JSON.parse(await readFile(claimPath, "utf8").catch(() => "null"));
+  const page = await browser.newPage({ viewport: { width: 1440, height: 960 } });
+  pages.push(page);
+  page.on("pageerror", (error) => pageErrors.push(error.message));
+  let wrapperError;
+  const handoff = new Promise((resolveLaunch, reject) => {
+    const child = spawn(executable, [], {
+      cwd: workspace,
+      env: { ...process.env, ZAIP_UI_NO_BROWSER: "1" },
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    const timeout = setTimeout(() => {
+      // Stop only the wrapper this verification started. Do not terminate the
+      // dashboard, its writer, another launcher, or another workspace.
+      child.kill();
+      reject(new Error(`Executable did not finish its handoff within ${launchTimeoutMs}ms`));
+    }, launchTimeoutMs);
+    child.once("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("exit", (code) => {
+      clearTimeout(timeout);
+      if (code === 0) resolveLaunch();
+      else reject(new Error(`Dashboard executable exited with code ${code}`));
+    });
+  });
+  // Attach to preparation immediately, including while the runtime is building.
+  // The browser is the session owner and must remain connected through refresh.
+  void handoff.catch((error) => {
+    wrapperError = error;
+  });
+  let attached = false;
+  while (performance.now() - started < launchTimeoutMs) {
+    if (wrapperError) throw wrapperError;
+    const claim = JSON.parse(await readFile(claimPath, "utf8").catch(() => "null"));
+    if (claim?.claimId && claim.claimId !== previousClaim?.claimId) {
+      try {
+        await page.goto(`http://127.0.0.1:${claim.launchPort}/`, {
+          waitUntil: "domcontentloaded",
+          timeout: 10_000,
+        });
+        attached = true;
+        break;
+      } catch {
+        /* The owner can publish its claim just before listening. */
+      }
+    }
+    await new Promise((done) => setTimeout(done, 100));
+  }
+  assert.ok(attached, "The verification browser must attach to the latest launch");
+  await handoff;
+  const elapsedMs = Math.round(performance.now() - started);
+  const current = await session();
+  const health = await api(current, "health");
+  assert.equal(health.status, 200);
+  assert.equal(health.body.workspaceKey, workspaceKey);
+  assert.equal(health.body.status, "ok");
+  await page.getByRole("navigation", { name: "Áreas do dashboard" }).waitFor({ timeout: 30_000 });
+  await page.getByText("Status das tarefas", { exact: true }).waitFor({ timeout: 30_000 });
+  return { elapsedMs, current, health, page, visibleMs: Math.round(performance.now() - started) };
+}
+
+async function awaitCurrentSnapshot(current) {
+  const started = performance.now();
+  let latest;
+  while (performance.now() - started < refreshTimeoutMs) {
+    latest = await api(current, "health");
+    if (latest.status === 200 && latest.body.snapshot_state === "current") {
+      const readiness = await api(current, "ready");
+      if (
+        readiness.status === 200 &&
+        readiness.body.status === "ready" &&
+        readiness.body.snapshot_state === "current"
+      ) {
+        return { elapsedMs: Math.round(performance.now() - started), health: latest.body };
+      }
+    }
+    await new Promise((done) => setTimeout(done, 1_000));
+  }
+  throw new Error(
+    `Canonical refresh did not reach current within ${refreshTimeoutMs}ms; last state=${latest?.body?.snapshot_state}`,
+  );
+}
+
+async function databaseInventory() {
+  const paths = [];
+  async function visit(directory) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      const path = join(directory, entry.name);
+      if (entry.isDirectory()) await visit(path);
+      else if (entry.isFile() && /\.(?:sqlite|db)$/i.test(entry.name)) paths.push(resolve(path));
+    }
+  }
+  await visit(resolve(workspace, ".local/sqlite"));
+  paths.sort();
+  assert.ok(
+    paths.includes(databasePath),
+    "The dashboard database must exist at its stable path in the shared SQLite folder",
+  );
+  const database = new DatabaseSync(databasePath, { readOnly: true });
+  try {
+    const integrity = database.prepare("PRAGMA quick_check").all();
+    assert.deepEqual(
+      integrity.map((row) => row.quick_check),
+      ["ok"],
+    );
+    const metadata = Object.fromEntries(
+      database
+        .prepare(
+          "SELECT key, value FROM zaip_vw_read_model_metadata WHERE key IN ('schema_version', 'source_file_count', 'canonical_run_count', 'last_synced_at', 'last_sync_at', 'source_checked_at', 'snapshot_day')",
+        )
+        .all()
+        .map(({ key, value }) => [key, value]),
+    );
+    const info = await stat(databasePath);
+    return {
+      path: databasePath,
+      paths,
+      bytes: info.size,
+      birthtime_ms: info.birthtimeMs,
+      integrity: "ok",
+      metadata,
+    };
+  } finally {
+    database.close();
+  }
+}
+
+try {
+  const first = await launch();
+  const initialRefresh = await awaitCurrentSnapshot(first.current);
+  const beforeSecond = await databaseInventory();
+  const second = await launch();
+  // Session ownership can change with the latest click; storage must stay fixed.
+  assert.ok(
+    second.elapsedMs <= warmBudgetMs,
+    `Warm handoff took ${second.elapsedMs}ms; budget=${warmBudgetMs}ms`,
+  );
+  const finalRefresh = await awaitCurrentSnapshot(second.current);
+  const final = await databaseInventory();
+  // Other purposes may create/update their own databases independently.
+  assert.equal(final.path, beforeSecond.path);
+  assert.equal(
+    final.birthtime_ms,
+    beforeSecond.birthtime_ms,
+    "The database must be updated in place",
+  );
+  assert.deepEqual(pageErrors, [], "Dashboard must render without uncaught JavaScript errors");
+  if (process.env.ZAIP_VERIFY_SCREENSHOT) {
+    await second.page.screenshot({
+      path: resolve(process.env.ZAIP_VERIFY_SCREENSHOT),
+      fullPage: true,
+    });
+  }
+  const browserCheck = {
+    status: "passed",
+    mode: "isolated_headless",
+    first_visible_ms: first.visibleMs,
+    warm_visible_ms: second.visibleMs,
+  };
+  process.stdout.write(
+    `${JSON.stringify({
+      status: "passed",
+      mode:
+        process.env.ZAIP_VERIFY_EXISTING_SESSION === "1"
+          ? "existing_session"
+          : "two_executable_launches",
+      checked_at: new Date().toISOString(),
+      entrypoint: executable,
+      browser_opened: false,
+      first_handoff_ms: first.elapsedMs,
+      first_refresh_wait_ms: initialRefresh.elapsedMs,
+      warm_handoff_ms: second.elapsedMs,
+      warm_budget_ms: warmBudgetMs,
+      final_refresh_wait_ms: finalRefresh.elapsedMs,
+      server_pid: second.current.serverPid,
+      server_reused: second.current.serverPid === first.current.serverPid,
+      port: second.current.port,
+      database: final,
+      browser_check: browserCheck,
+    })}\n`,
+  );
+} finally {
+  for (const page of pages) await page.close().catch(() => {});
+  await browser.close();
+}