@zaip-ai/cli 1.3.0 → 1.3.2

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

@@ -0,0 +1,140 @@
+import { spawn } from "node:child_process";
+import { closeSync, mkdirSync, openSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+export async function refreshIsRunning(statusPath, isProcessAlive) {
+  try {
+    const value = JSON.parse(await readFile(statusPath, "utf8"));
+    return (
+      value?.status === "running" &&
+      Number.isInteger(value.pid) &&
+      (await isProcessAlive(value.pid))
+    );
+  } catch {
+    return false;
+  }
+}
+
+async function acquireRefreshLock(lockPath, isProcessAlive) {
+  try {
+    const descriptor = openSync(lockPath, "wx");
+    writeSync(descriptor, String(process.pid));
+    closeSync(descriptor);
+    return true;
+  } catch (error) {
+    if (error?.code !== "EEXIST") throw error;
+    const ownerPid = Number.parseInt(await readFile(lockPath, "utf8").catch(() => ""), 10);
+    if (Number.isInteger(ownerPid) && (await isProcessAlive(ownerPid))) return false;
+    if (!Number.isInteger(ownerPid) && Date.now() - statSync(lockPath).mtimeMs < 30_000)
+      return false;
+    try {
+      unlinkSync(lockPath);
+    } catch (unlinkError) {
+      if (unlinkError?.code !== "ENOENT") throw unlinkError;
+    }
+    return acquireRefreshLock(lockPath, isProcessAlive);
+  }
+}
+
+export async function startSeedRefresh(options) {
+  const {
+    appendLog,
+    cacheDirectory,
+    isRunning,
+    isProcessAlive,
+    lockPath,
+    packageRoot,
+    randomBytes,
+    refreshLogPath,
+    refreshStatusPath,
+    sqliteDirectory,
+    stopProcessTree,
+    writeJsonAtomic,
+    workspaceRoot,
+  } = options;
+  if (!(await acquireRefreshLock(lockPath, isProcessAlive))) {
+    appendLog("Skipped duplicate background SQLite seed refresh; a worker is already running.");
+    return;
+  }
+  try {
+    if (await isRunning()) {
+      appendLog("Skipped duplicate background SQLite seed refresh; a worker is already running.");
+      return;
+    }
+    const refreshPath = resolve(
+      sqliteDirectory,
+      `refresh-${process.pid}-${randomBytes(4).toString("hex")}.sqlite`,
+    );
+    mkdirSync(dirname(refreshStatusPath), { recursive: true });
+    const descriptor = openSync(refreshLogPath, "a");
+    let worker;
+    try {
+      worker = spawn(
+        process.execPath,
+        [resolve(packageRoot, "scripts/rebuild-sqlite-read-model.mjs")],
+        {
+          cwd: workspaceRoot,
+          env: {
+            ...process.env,
+            ZAIP_WORKSPACE: workspaceRoot,
+            ZAIP_SQLITE_DB_PATH: refreshPath,
+            ZAIP_SQLITE_PREFER_LAST_VALID_SEED: "0",
+            ZAIP_DASHBOARD_LAUNCH_PROGRESS: "0",
+            ZAIP_SQLITE_REFRESH_CLEANUP: "1",
+            ZAIP_SQLITE_CACHE_DIR: cacheDirectory,
+          },
+          stdio: ["ignore", descriptor, descriptor],
+          detached: true,
+          windowsHide: true,
+        },
+      );
+    } finally {
+      closeSync(descriptor);
+    }
+    if (!Number.isInteger(worker.pid)) {
+      worker.kill();
+      throw new Error("Background SQLite seed refresh did not provide a worker PID.");
+    }
+    try {
+      await writeJsonAtomic(refreshStatusPath, {
+        status: "running",
+        pid: worker.pid,
+        path: refreshPath,
+        cacheDirectory,
+        startedAt: new Date().toISOString(),
+      });
+    } catch (error) {
+      await stopProcessTree(worker.pid).catch(() => {});
+      throw error;
+    }
+    worker.once("error", (error) => {
+      appendLog(`Background SQLite seed refresh failed to start: ${error.message}`);
+      void writeJsonAtomic(refreshStatusPath, {
+        status: "failed",
+        error: error.message,
+        finishedAt: new Date().toISOString(),
+      }).catch(() => {});
+    });
+    worker.once("exit", (code) => {
+      const status = code === 0 ? "completed" : "failed";
+      appendLog(
+        `Background SQLite seed refresh ${status} (${code ?? "unknown"}); inspect ${refreshLogPath}.`,
+      );
+      void writeJsonAtomic(refreshStatusPath, {
+        status,
+        exitCode: code ?? null,
+        logPath: refreshLogPath,
+        finishedAt: new Date().toISOString(),
+      }).catch(() => {});
+    });
+    worker.unref();
+    appendLog(
+      `Started background SQLite seed refresh at ${refreshPath}; cache ${cacheDirectory}; worker log ${refreshLogPath}.`,
+    );
+  } finally {
+    try {
+      unlinkSync(lockPath);
+    } catch {}
+  }
+}