@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/packages/local-runtime/src/work-priority-contract.test.ts

@@ -0,0 +1,33 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+const source = readFileSync(new URL("server.ts", import.meta.url), "utf8");
+const projectionSource = readFileSync(new URL("server-projections.ts", import.meta.url), "utf8");
+
+describe("work priority API contract", () => {
+  it("requires the normal local-session authorization before accepting priority writes", () => {
+    const auth = source.slice(
+      source.indexOf("app.use(`${API_PREFIX}/*`"),
+      source.indexOf('app.on(["GET", "HEAD"], `${API_PREFIX}/health`'),
+    );
+    expect(auth).toContain("context.req.path === `${API_PREFIX}/work-priority`");
+    expect(auth).toContain('return context.json({ error: "Invalid local session" }, 401)');
+  });
+
+  it("writes priority without building a projection, while reads discard stale IDs", () => {
+    const route = source.slice(
+      source.indexOf("app.put(`${API_PREFIX}/work-priority`"),
+      source.indexOf('app.on(["GET", "HEAD"], `${API_PREFIX}/snapshot`'),
+    );
+    expect(route).not.toContain("buildCanonicalOperationsProjection");
+    expect(route).not.toContain("knownWorkIds(");
+    expect(route).toContain("await canonicalFilesystem.writeTextAtomic(");
+    expect(route).toContain("WORK_PRIORITY_PATH");
+    expect(projectionSource).toMatch(/\[\s*\.\.\.new Set\(\s*input\.item_ids\.filter/);
+    const read = projectionSource.slice(
+      projectionSource.indexOf("async function readWorkPriority"),
+      projectionSource.indexOf("function knownWorkIds"),
+    );
+    expect(read).toContain("priority.item_ids.filter((id) => knownIds.has(id))");
+  });
+});

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

@@ -0,0 +1,41 @@
+export async function collectPreviousDashboardSessions({
+  candidateSessionPath,
+  candidateRegistryPath,
+  probe,
+  readDashboardSession,
+  readPortRegistry,
+  workspaceRoot,
+  workspaceKey,
+}) {
+  const session = await readDashboardSession(candidateSessionPath);
+  const registryEntries = (await readPortRegistry(candidateRegistryPath)).map((entry) => ({
+    ...entry,
+    workspace: workspaceRoot,
+    workspaceKey,
+  }));
+  const candidates = [session, ...registryEntries].filter(
+    (candidate) =>
+      candidate?.workspace === workspaceRoot &&
+      candidate?.workspaceKey === workspaceKey &&
+      Number.isInteger(candidate?.port) &&
+      Number.isInteger(candidate?.rootPid) &&
+      candidate.rootPid > 0,
+  );
+  const latestByPort = new Map();
+  for (const candidate of candidates) {
+    const current = latestByPort.get(candidate.port);
+    if (
+      current === undefined ||
+      String(candidate.openedAt ?? candidate.createdAt ?? "").localeCompare(
+        String(current.openedAt ?? current.createdAt ?? ""),
+      ) > 0
+    )
+      latestByPort.set(candidate.port, candidate);
+  }
+  const reachable = await Promise.all(
+    [...latestByPort.values()].map(async (candidate) =>
+      (await probe(candidate.port)) ? candidate : null,
+    ),
+  );
+  return reachable.filter(Boolean);
+}

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

@@ -0,0 +1,210 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+
+export function teardownWarning(status) {
+  return status === "close_failed";
+}
+
+export function registeredListenerMatches(session, listenerPid) {
+  return (
+    Number.isInteger(session?.serverPid) &&
+    session.serverPid > 0 &&
+    Number.isInteger(listenerPid) &&
+    listenerPid === session.serverPid
+  );
+}
+
+export async function stopOwnedDashboardProcess(
+  session,
+  {
+    probeDashboardPort,
+    workspaceKey,
+    fetchImpl,
+    host,
+    packageRoot,
+    delay,
+    listeningProcessIdImpl = listeningProcessId,
+    isProcessAliveImpl = isProcessAlive,
+    stopProcessTreeImpl = stopProcessTree,
+  },
+) {
+  const initiallyReachable = await probeDashboardPort(
+    session?.port,
+    fetchImpl,
+    workspaceKey,
+    false,
+  );
+  const listenerPid = await listeningProcessIdImpl(session?.port, host);
+  // A failed health probe alone does not prove the port was released.  Read
+  // the listener before recording a terminal status so a foreign process (or
+  // a transient runtime response) can never be persisted as closed.
+  if (!initiallyReachable && listenerPid === null) return "closed";
+  if (!registeredListenerMatches(session, listenerPid)) return "skipped_unowned";
+  // The server PID is the ownership boundary.  Killing the recorded launcher
+  // root with taskkill /t can also terminate a newly handed-off generation on
+  // Windows when the old launcher process tree is still being reaped.  The
+  // old launcher exits naturally after its server is gone.
+  const rootIsKnownLauncher = false;
+  await stopProcessTreeImpl(session.serverPid);
+  const deadline = Date.now() + 5_000;
+  let lastTeardownAttemptAt = Date.now();
+  while (Date.now() < deadline) {
+    const listenerStillMatches = registeredListenerMatches(
+      session,
+      await listeningProcessIdImpl(session.port, host),
+    );
+    if (
+      !(await probeDashboardPort(session.port, fetchImpl, workspaceKey, false)) &&
+      !(await isProcessAliveImpl(session.serverPid)) &&
+      (!rootIsKnownLauncher || !(await isProcessAliveImpl(session.rootPid))) &&
+      !listenerStillMatches
+    )
+      return "closed";
+    // Windows can report taskkill complete before the listener disappears.
+    // Retry only while the original registered server PID is still listening;
+    // a reused or foreign PID remains protected by the ownership check above.
+    if (listenerStillMatches && Date.now() - lastTeardownAttemptAt >= 500) {
+      await stopProcessTreeImpl(session.serverPid);
+      if (rootIsKnownLauncher) await stopProcessTreeImpl(session.rootPid);
+      lastTeardownAttemptAt = Date.now();
+    }
+    await delay(100);
+  }
+  return "close_failed";
+}
+
+export async function listeningProcessId(port, host = "127.0.0.1") {
+  if (!Number.isInteger(port) || port <= 0) return null;
+  if (process.platform === "win32") {
+    return commandOutput("powershell.exe", [
+      "-NoProfile",
+      "-Command",
+      `(Get-NetTCPConnection -LocalAddress '${host}' -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty OwningProcess)`,
+    ]).then(firstProcessId);
+  }
+  return commandOutput("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"]).then(firstProcessId);
+}
+
+export async function isKnownDashboardLauncher(pid, packageRoot) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  const command =
+    process.platform === "win32"
+      ? await commandOutput("powershell.exe", [
+          "-NoProfile",
+          "-Command",
+          `(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}' -ErrorAction SilentlyContinue).CommandLine`,
+        ])
+      : await readFile(`/proc/${pid}/cmdline`, "utf8").catch(() => "");
+  return command.includes("start-dashboard") && command.includes(packageRoot);
+}
+
+export async function isAncestorProcess(ancestorPid, descendantPid, parentOf = processParentId) {
+  if (!Number.isInteger(ancestorPid) || !Number.isInteger(descendantPid)) return false;
+  const visited = new Set();
+  let current = descendantPid;
+  while (Number.isInteger(current) && current > 0 && !visited.has(current)) {
+    if (current === ancestorPid) return true;
+    visited.add(current);
+    current = await parentOf(current);
+  }
+  return false;
+}
+
+async function processParentId(pid) {
+  if (process.platform === "win32") {
+    return commandOutput("powershell.exe", [
+      "-NoProfile",
+      "-Command",
+      `(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}' -ErrorAction SilentlyContinue).ParentProcessId`,
+    ]).then(firstProcessId);
+  }
+  const stat = await readFile(`/proc/${pid}/stat`, "utf8").catch(() => "");
+  const match = stat.match(/^\d+\s+\(.+\)\s+\S\s+(\d+)/);
+  return match === null ? null : firstProcessId(match[1]);
+}
+
+async function commandOutput(command, args) {
+  return new Promise((resolveOutput) => {
+    const child = spawn(command, args, { stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+    let output = "";
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      output += chunk;
+    });
+    child.once("error", () => resolveOutput(""));
+    child.once("exit", () => resolveOutput(output));
+  });
+}
+
+function firstProcessId(output) {
+  const value = Number.parseInt(output.trim().split(/\s+/)[0] ?? "", 10);
+  return Number.isInteger(value) && value > 0 ? value : null;
+}
+
+export async function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  if (process.platform === "win32") {
+    return new Promise((resolveAlive) => {
+      const query = spawn("tasklist", ["/fi", `PID eq ${pid}`, "/fo", "csv", "/nh"], {
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true,
+      });
+      let output = "";
+      query.stdout?.setEncoding("utf8");
+      query.stdout?.on("data", (chunk) => {
+        output += chunk;
+      });
+      query.once("error", () => resolveAlive(true));
+      query.once("exit", () => resolveAlive(output.includes(`"${pid}"`)));
+    });
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+
+export async function stopProcessTree(pid) {
+  if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) return;
+  if (process.platform === "win32") {
+    await new Promise((resolveStop) => {
+      const killer = spawn("taskkill", ["/pid", String(pid), "/t", "/f"], {
+        stdio: "ignore",
+        windowsHide: true,
+      });
+      killer.once("error", () => resolveStop());
+      killer.once("exit", () => resolveStop());
+    });
+    return;
+  }
+  const children = await childProcessIds(pid);
+  await Promise.all(children.map((childPid) => stopProcessTree(childPid)));
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    // A stale recorded PID is already stopped.
+  }
+}
+
+async function childProcessIds(pid) {
+  return new Promise((resolveChildren) => {
+    const query = spawn("pgrep", ["-P", String(pid)], { stdio: ["ignore", "pipe", "ignore"] });
+    let output = "";
+    query.stdout?.setEncoding("utf8");
+    query.stdout?.on("data", (chunk) => {
+      output += chunk;
+    });
+    query.once("error", () => resolveChildren([]));
+    query.once("exit", () =>
+      resolveChildren(
+        output
+          .split(/\s+/)
+          .map((value) => Number.parseInt(value, 10))
+          .filter((value) => Number.isInteger(value) && value > 0),
+      ),
+    );
+  });
+}