@zaip-ai/cli 6.3.0 → 7.6.0

package/templates/.agents/design/design-system-maker/runtime/launch-identity.mjs

@@ -0,0 +1,100 @@
+import { realpath } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { bytes, hash, read } from "./io.mjs";
+
+export const leasePath = ".local/design-system-maker/lease.json";
+export async function hostConfiguration(workspace, location) {
+  if (location && !location.startsWith(".local/"))
+    throw new Error("Host configuration must be project-local");
+  const content = location ? await read(workspace, location, 65536) : bytes({});
+  const value = JSON.parse(content.toString("utf8"));
+  if (
+    !value ||
+    Array.isArray(value) ||
+    typeof value !== "object" ||
+    Object.keys(value).some((key) => !["fixture_origins", "captures"].includes(key))
+  )
+    throw new Error("Unsupported host configuration");
+  return { value, host_configuration_id: hash(content) };
+}
+export function supported(version) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(version);
+  return !!match && (+match[1] > 22 || (+match[1] === 22 && +match[2] >= 16));
+}
+export async function installation(workspace) {
+  if (!supported(process.versions.node))
+    throw new Error("Maker requires Node >=22.16; no automatic installation");
+  const root = await realpath(workspace);
+  const installed = await realpath(resolve(dirname(fileURLToPath(import.meta.url)), ".."));
+  if (installed !== (await realpath(resolve(root, ".agents/design/design-system-maker"))))
+    throw new Error("Launcher installation does not belong to this workspace");
+  const manifest = JSON.parse(
+    (await read(root, ".agents/design/design-system-maker/build.json", 65536)).toString("utf8"),
+  );
+  if (
+    manifest.schema_version !== 1 ||
+    !/^[a-f0-9]{64}$/.test(manifest.build_id) ||
+    !Array.isArray(manifest.sources) ||
+    manifest.sources.length > 128 ||
+    hash(bytes(manifest.sources)) !== manifest.build_id
+  )
+    throw new Error("Invalid Maker build manifest");
+  for (const item of [...manifest.sources, manifest.executable]) {
+    if (
+      !item ||
+      !/^[a-f0-9]{64}$/.test(item.sha256) ||
+      ![
+        ".agents/design/design-system-maker/",
+        ".agents/tools/visual-url/",
+        ".agents/config/src/",
+      ].some((prefix) => item.path.startsWith(prefix))
+    )
+      throw new Error("Invalid Maker build source");
+    const actual = hash(await read(root, item.path, 2097152));
+    if (actual !== item.sha256 && actual !== item.source_sha256)
+      throw new Error(`Maker build integrity mismatch: ${item.path}`);
+  }
+  const physical = process.platform === "win32" ? root.toLowerCase() : root;
+  return {
+    schema_version: 1,
+    workspace_hash: hash(Buffer.from(physical)),
+    installation_id: hash(
+      Buffer.from(process.platform === "win32" ? installed.toLowerCase() : installed),
+    ),
+    build_id: manifest.build_id,
+    node_version: process.versions.node,
+    node_identity: hash(Buffer.from(await realpath(process.execPath))),
+  };
+}
+export function validLease(lease) {
+  if (
+    lease?.schema_version !== 1 ||
+    !/^http:\/\/127\.0\.0\.1:[1-9]\d{0,4}$/.test(lease.origin) ||
+    new URL(lease.origin).port > 65535 ||
+    !Number.isInteger(lease.pid) ||
+    lease.pid < 1 ||
+    ![
+      lease.instance_id,
+      lease.stop_token,
+      lease.workspace_hash,
+      lease.installation_id,
+      lease.build_id,
+      lease.node_identity,
+      lease.host_configuration_id,
+    ].every((value) => /^[a-f0-9]{64}$/.test(value)) ||
+    !supported(lease.node_version)
+  )
+    throw new Error("Invalid launcher lease; identity unavailable");
+  return lease;
+}
+export function sameIdentity(expected, actual) {
+  return [
+    "workspace_hash",
+    "installation_id",
+    "build_id",
+    "node_identity",
+    "node_version",
+    "host_configuration_id",
+  ].every((key) => expected[key] === actual[key]);
+}

package/templates/.agents/design/design-system-maker/runtime/launch-protocol.mjs

@@ -0,0 +1,88 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { request } from "node:http";
+import { bytes, hash } from "./io.mjs";
+import { validLease } from "./launch-identity.mjs";
+
+export async function control(lease, operation = "probe") {
+  validLease(lease);
+  return new Promise((resolve, reject) => {
+    const req = request(
+      `${lease.origin}/.zaip-maker/control`,
+      {
+        method: "POST",
+        headers: {
+          "X-Maker-Control": lease.stop_token,
+          "X-Maker-Operation": operation,
+          "Content-Length": "0",
+        },
+        timeout: 1500,
+      },
+      (response) => {
+        const chunks = [];
+        let size = 0;
+        response.on("data", (chunk) => {
+          size += chunk.length;
+          if (size > 8192) {
+            response.destroy();
+            reject(new Error("Control response bound"));
+          } else chunks.push(chunk);
+        });
+        response.on("error", reject);
+        response.on("end", () => {
+          try {
+            const result = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+            if (
+              response.statusCode !== 200 ||
+              result.instance_id !== lease.instance_id ||
+              result.pid !== lease.pid ||
+              result.build_id !== lease.build_id ||
+              result.installation_id !== lease.installation_id ||
+              result.workspace_hash !== lease.workspace_hash ||
+              result.node_identity !== lease.node_identity ||
+              result.node_version !== lease.node_version ||
+              result.host_configuration_id !== lease.host_configuration_id ||
+              result.origin !== lease.origin
+            )
+              throw new Error("Authenticated launcher identity mismatch");
+            resolve(result);
+          } catch (error) {
+            reject(error);
+          }
+        });
+      },
+    );
+    req.on("timeout", () => req.destroy(new Error("Control readiness timeout")));
+    req.on("error", reject);
+    req.end();
+  });
+}
+export function launchControl(identity) {
+  const instance_id = randomBytes(32).toString("hex");
+  const stop_token = randomBytes(32).toString("hex");
+  const publicIdentity = { ...identity, instance_id };
+  return {
+    identity: publicIdentity,
+    stop_token,
+    authenticate(headers) {
+      const supplied = headers["x-maker-control"];
+      return (
+        !headers.origin &&
+        !headers.referer &&
+        !headers["sec-fetch-site"] &&
+        typeof supplied === "string" &&
+        supplied.length === 64 &&
+        timingSafeEqual(Buffer.from(supplied), Buffer.from(stop_token))
+      );
+    },
+    lease(origin) {
+      return {
+        ...publicIdentity,
+        pid: process.pid,
+        origin,
+        stop_token,
+        created_at: new Date().toISOString(),
+        identity_checksum: hash(bytes(publicIdentity)),
+      };
+    },
+  };
+}

package/templates/.agents/design/design-system-maker/runtime/launch-server.mjs

@@ -0,0 +1,51 @@
+import { realpath } from "node:fs/promises";
+import { bytes, write } from "./io.mjs";
+import { hostConfiguration, installation, leasePath } from "./launch-identity.mjs";
+import { launchControl } from "./launch-protocol.mjs";
+import { startServer } from "./server.mjs";
+
+let workspace;
+try {
+  const args = process.argv.slice(2);
+  const options = {};
+  for (let i = 0; i < args.length; i += 2) {
+    if (
+      !["--workspace", "--host-config"].includes(args[i]) ||
+      !args[i + 1] ||
+      Object.hasOwn(options, args[i])
+    )
+      throw new Error("Invalid server arguments");
+    options[args[i]] = args[i + 1];
+  }
+  workspace = await realpath(options["--workspace"]);
+  const configuration = await hostConfiguration(workspace, options["--host-config"]);
+  const identity = {
+    ...(await installation(workspace)),
+    host_configuration_id: configuration.host_configuration_id,
+  };
+  const control = launchControl(identity);
+  const server = await startServer({
+    workspace,
+    host_configuration: configuration.value,
+    launch_control: control,
+  });
+  await write(workspace, leasePath, bytes(control.lease(server.origin)));
+  process.once("SIGINT", () =>
+    server.close().catch(() => {
+      process.exitCode = 1;
+    }),
+  );
+  process.once("SIGTERM", () =>
+    server.close().catch(() => {
+      process.exitCode = 1;
+    }),
+  );
+} catch (error) {
+  if (workspace)
+    await write(
+      workspace,
+      ".local/design-system-maker/server-error.json",
+      bytes({ pid: process.pid, error: error.message, at: new Date().toISOString() }),
+    ).catch(() => {});
+  process.exitCode = 1;
+}

package/templates/.agents/design/design-system-maker/runtime/launch.mjs

@@ -0,0 +1,107 @@
+import { spawn } from "node:child_process";
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { pathToFileURL } from "node:url";
+import { json, path } from "./io.mjs";
+import {
+  hostConfiguration,
+  installation,
+  leasePath,
+  sameIdentity,
+  validLease,
+} from "./launch-identity.mjs";
+import { control } from "./launch-protocol.mjs";
+import { acquire } from "./lock.mjs";
+
+export async function launch(workspace, hostConfig) {
+  workspace = await realpath(workspace);
+  const configuration = await hostConfiguration(workspace, hostConfig);
+  const identity = {
+    ...(await installation(workspace)),
+    host_configuration_id: configuration.host_configuration_id,
+  };
+  if (hostConfig && !/^\.local\//.test(hostConfig))
+    throw new Error("Host configuration must be project-local");
+  if (hostConfig) await path(workspace, hostConfig);
+  let release;
+  const deadline = Date.now() + 15000;
+  while (!release && Date.now() < deadline) {
+    try {
+      release = await acquire(`${workspace}/.local/design-system-maker/startup`);
+    } catch (error) {
+      if (!/EADDRINUSE/.test(error.message)) throw error;
+      await delay(80);
+    }
+  }
+  if (!release) throw new Error("Maker startup exclusion deadline; no alternative lock authority");
+  try {
+    let previous = await json(workspace, leasePath);
+    if (previous) {
+      validLease(previous);
+      const healthy = await control(previous).catch((error) => {
+        if (["ECONNREFUSED", "ECONNRESET", "ENOENT"].includes(error.code)) return null;
+        throw error;
+      });
+      if (healthy) {
+        if (!sameIdentity(identity, previous))
+          throw new Error(
+            "An authenticated Maker of a different build/runtime is active; stop it explicitly before upgrade",
+          );
+        return { ok: true, reused: true, ...healthy };
+      }
+    }
+    const child = spawn(
+      process.execPath,
+      [
+        resolve(workspace, ".agents/design/design-system-maker/runtime/launch-server.mjs"),
+        "--workspace",
+        workspace,
+        ...(hostConfig ? ["--host-config", hostConfig] : []),
+      ],
+      { cwd: workspace, detached: true, windowsHide: true, stdio: "ignore" },
+    );
+    let spawnError;
+    child.once("error", (error) => {
+      spawnError = error;
+    });
+    child.unref();
+    const readyDeadline = Date.now() + 12000;
+    while (Date.now() < readyDeadline) {
+      if (spawnError) throw spawnError;
+      previous = await json(workspace, leasePath);
+      if (previous && previous.pid === child.pid && sameIdentity(identity, previous)) {
+        const healthy = await control(previous);
+        return { ok: true, reused: false, ...healthy };
+      }
+      const diagnostic = await json(workspace, ".local/design-system-maker/server-error.json");
+      if (diagnostic?.pid === child.pid) throw new Error(diagnostic.error);
+      await delay(80);
+    }
+    throw new Error("Maker readiness deadline; no unknown process was terminated");
+  } finally {
+    await release();
+  }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  try {
+    const args = process.argv.slice(2);
+    const options = {};
+    for (let i = 0; i < args.length; i += 2) {
+      if (
+        !["--workspace", "--host-config"].includes(args[i]) ||
+        !args[i + 1] ||
+        Object.hasOwn(options, args[i])
+      )
+        throw new Error("Invalid launcher arguments");
+      options[args[i]] = args[i + 1];
+    }
+    if (!options["--workspace"]) throw new Error("Explicit workspace required");
+    process.stdout.write(
+      `${JSON.stringify(await launch(options["--workspace"], options["--host-config"]))}\n`,
+    );
+  } catch (error) {
+    process.stdout.write(`${JSON.stringify({ ok: false, error: error.message })}\n`);
+    process.exitCode = 1;
+  }
+}

package/templates/.agents/design/design-system-maker/runtime/local-actions.mjs

@@ -0,0 +1,184 @@
+import { safeText } from "./contracts.mjs";
+import { composeProposal } from "./design-compose.mjs";
+import { markdownProposal } from "./design-markdown.mjs";
+import { bytes, hash, read } from "./io.mjs";
+import { advanceJob, queuedJob } from "./job-progress.mjs";
+import { packLocal } from "./local-artifacts.mjs";
+import { sourceRequest } from "./local-request.mjs";
+import { summary } from "./presentation.mjs";
+import { repositoryProposal, sensitivePath } from "./repository-source.mjs";
+
+export function localActions({ store, serialize, checkpoint }) {
+  async function reference(ref) {
+    const value = await store.get(ref.id, ref.revision);
+    if (!value || (await store.trashStatus(ref.id)).state === "trashed")
+      throw new Error("Selected source unavailable");
+    const content = await store.artifact(ref.id, ref.revision, "DESIGN.md");
+    if (hash(content) !== ref.design_hash)
+      throw new Error("Selected DESIGN revision/hash mismatch");
+    return { value, content };
+  }
+  return {
+    async local(input) {
+      const request = sourceRequest(input),
+        requestHash = hash(bytes(request)),
+        jobId = `job-${request.operation_id}`;
+      return serialize(async () => {
+        const replay = await store.readJob(jobId);
+        if (replay) {
+          if (replay.request_hash !== requestHash)
+            throw new Error("Operation ID reused with different request");
+          const value = await store.get(replay.entry_id, replay.result_revision);
+          return {
+            id: replay.id,
+            jobId: replay.id,
+            entry_id: replay.entry_id,
+            status: replay.status,
+            job: replay,
+            entry: value ? summary(value) : null,
+            replayed: true,
+          };
+        }
+        const previous = await store.get(request.id);
+        if (
+          (previous?.revision ?? 0) !== request.expected_revision ||
+          previous?.status === "collecting" ||
+          (await store.trashStatus(request.id)).state === "trashed"
+        )
+          throw new Error("Entry revision conflict or unavailable destination");
+        let proposal;
+        const at = new Date().toISOString(),
+          extractionId = `maker-${request.operation_id}`;
+        if (request.kind === "repository")
+          proposal = await repositoryProposal(store.workspace, extractionId, request.paths, at);
+        else if (request.kind === "import-design") {
+          if (sensitivePath(request.path)) throw new Error("Secret/dotenv source prohibited");
+          const content = await read(store.workspace, request.path, 262144);
+          if (hash(content) !== request.expected_hash)
+            throw new Error("Markdown source hash mismatch");
+          proposal = markdownProposal(extractionId, content, {
+            type: "design-markdown",
+            url: null,
+            locator: request.path,
+            observed_at: at,
+            source_hash: hash(content),
+            source_preserved: false,
+            files: [{ path: request.path, hash: hash(content), bytes: content.length }],
+            references: [],
+          });
+        } else if (request.kind === "rebuild-document") {
+          const selected = await reference(request.reference);
+          proposal = markdownProposal(extractionId, selected.content, {
+            type: "design-markdown",
+            url: null,
+            locator: `collection/${request.reference.id}/r-${request.reference.revision}/DESIGN.md`,
+            observed_at: at,
+            source_hash: hash(selected.content),
+            source_preserved: false,
+            files: [],
+            references: [request.reference],
+          });
+        } else {
+          const inputs = [];
+          for (const ref of request.sources) {
+            const selected = await reference(ref);
+            const model = markdownProposal(`read-${ref.id}`.slice(0, 64), selected.content, {
+              type: "design-markdown",
+              url: null,
+              locator: `collection/${ref.id}/r-${ref.revision}/DESIGN.md`,
+              observed_at: at,
+              source_hash: ref.design_hash,
+              source_preserved: false,
+              files: [],
+              references: [ref],
+            }).local_visual_model;
+            inputs.push({ reference: ref, model });
+          }
+          proposal = composeProposal(extractionId, inputs, request.facets, at);
+        }
+        const packed = packLocal(proposal);
+        let currentJob = {
+          ...queuedJob({
+            schema_version: 1,
+            id: jobId,
+            entry_id: request.id,
+            status: "queued",
+            created_at: at,
+            updated_at: at,
+            result_revision: null,
+            error: null,
+          }),
+          request_hash: requestHash,
+        };
+        const collecting = {
+          schema_version: 1,
+          id: request.id,
+          slug: request.id,
+          name: previous?.name ?? request.name,
+          url: null,
+          source: proposal.source,
+          status: "collecting",
+          revision: request.expected_revision + 1,
+          created_at: previous?.created_at ?? at,
+          updated_at: at,
+          job_id: jobId,
+          request_hash: requestHash,
+          artifacts: [],
+          proposal_summary: null,
+          error: null,
+        };
+        try {
+          await store.commit(collecting, request.expected_revision);
+          await checkpoint?.("local-after-collecting-before-job");
+          await store.writeJob(currentJob);
+          currentJob = advanceJob(currentJob, { phase: "build-report", status: "running" });
+          await store.writeJob(currentJob);
+          const completed = {
+            ...collecting,
+            revision: collecting.revision + 1,
+            status: "partial",
+            updated_at: new Date().toISOString(),
+            artifacts: packed.inventory,
+            proposal_summary: packed.summary,
+          };
+          await store.commit(completed, collecting.revision, packed.artifacts);
+          currentJob = {
+            ...advanceJob(currentJob, { phase: "completed" }),
+            result_revision: completed.revision,
+            status: "completed",
+            error: null,
+          };
+          await store.writeJob(currentJob);
+          return {
+            id: jobId,
+            jobId,
+            entry_id: completed.id,
+            status: "completed",
+            job: currentJob,
+            entry: summary(completed),
+          };
+        } catch (error) {
+          const latest = await store.get(request.id);
+          if (latest?.status === "collecting") {
+            const message = safeText(error.message, 512),
+              failed = {
+                ...latest,
+                revision: latest.revision + 1,
+                status: "failed",
+                updated_at: new Date().toISOString(),
+                error: message,
+              };
+            await store.commit(failed, latest.revision);
+            await store.writeJob({
+              ...advanceJob(currentJob, { phase: "failed" }),
+              status: "failed",
+              result_revision: failed.revision,
+              error: message,
+            });
+          }
+          throw error;
+        }
+      });
+    },
+  };
+}