@zalify/cli 0.4.0 → 0.6.0

package/dist/cli.js

@@ -11293,7 +11293,7 @@ function updateNotifier(options) {
 
 // src/cli.ts
 import { createRequire as createRequire2 } from "node:module";
-import { dirname, join as join3 } from "node:path";
+import { dirname, join as join4 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/auth.ts
@@ -11847,10 +11847,219 @@ async function workspaceSet(slugOrId) {
   console.log(`✓ Active workspace: ${found[1].name} (${found[1].slug})`);
 }
 
+// src/images.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, existsSync as existsSync3, rmSync as rmSync2 } from "node:fs";
+import { join as join3, resolve as resolve2 } from "node:path";
+var MAX_JOBS_PER_REQUEST = 40;
+var POLL_INTERVAL_MS = 5000;
+var POLL_TIMEOUT_MS = 30 * 60 * 1000;
+var STREAM_BATCH = 20;
+function buildPrompt(manifest, entry) {
+  const style = entry.type === "model" ? manifest.modelStyle ?? manifest.style : manifest.style;
+  return `${style}
+
+${entry.prompt}`;
+}
+function apiError(auth, label, status, json) {
+  if (json.code === "UPGRADE_REQUIRED") {
+    return new Error(`${json.error ?? "Paid plan required."}
+  Upgrade: ${auth.appUrl}/store/${auth.workspaceSlug}/settings/billing`);
+  }
+  return new Error(`${label} ${status}: ${JSON.stringify(json)}`);
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function saveProduced(imagesDir, indexPath, index, file2, asset) {
+  const img = await fetch(asset.url);
+  if (!img.ok) {
+    console.error(`  ✗ ${file2}: download ${img.status}`);
+    return false;
+  }
+  const bytes = Buffer.from(await img.arrayBuffer());
+  writeFileSync4(join3(imagesDir, file2), bytes);
+  index[file2] = {
+    assetId: asset.id,
+    url: asset.url,
+    checksum: createHash2("sha256").update(bytes).digest("hex")
+  };
+  writeFileSync4(indexPath, JSON.stringify(index, null, 2) + `
+`);
+  return true;
+}
+async function submitJob(auth, manifest, entries) {
+  const res = await fetch(`${auth.appUrl}/api/cli/images/jobs`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${auth.key}`
+    },
+    body: JSON.stringify({
+      workspaceId: auth.workspaceId,
+      jobs: entries.map((e) => ({
+        prompt: buildPrompt(manifest, e),
+        size: "1024x1024",
+        count: 1
+      }))
+    })
+  });
+  if (res.status === 404)
+    return null;
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok)
+    throw apiError(auth, "images/jobs", res.status, json);
+  if (!json.jobId)
+    throw new Error(`images/jobs: no jobId in response`);
+  return json.jobId;
+}
+async function pollJob(auth, jobId, files, imagesDir, indexPath, index, counters) {
+  const handled = new Set;
+  const reported = new Set;
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  while (true) {
+    const res = await fetch(`${auth.appUrl}/api/cli/images/jobs/${jobId}?workspaceId=${encodeURIComponent(auth.workspaceId)}`, { headers: { Authorization: `Bearer ${auth.key}` } });
+    const json = await res.json().catch(() => ({}));
+    if (!res.ok)
+      throw apiError(auth, `images/jobs/${jobId}`, res.status, json);
+    const total = json.total || files.length;
+    for (const item of json.produced ?? []) {
+      if (handled.has(item.jobIndex))
+        continue;
+      handled.add(item.jobIndex);
+      const file2 = files[item.jobIndex];
+      if (!file2)
+        continue;
+      if (await saveProduced(imagesDir, indexPath, index, file2, item.asset)) {
+        counters.produced++;
+        console.log(`  ✓ ${file2} (${handled.size + reported.size}/${total})`);
+      } else {
+        counters.failed++;
+      }
+    }
+    for (const f of json.failed ?? []) {
+      if (reported.has(f.jobIndex))
+        continue;
+      reported.add(f.jobIndex);
+      counters.failed++;
+      console.error(`  ✗ ${files[f.jobIndex] ?? `job ${f.jobIndex}`}: ${f.message}`);
+    }
+    if (json.status === "done")
+      return;
+    if (Date.now() >= deadline) {
+      throw new Error(`Timed out after 30 minutes waiting for job ${jobId}. ` + `The job keeps running server-side — re-run \`zalify images generate\` to resume.`);
+    }
+    await sleep(POLL_INTERVAL_MS);
+  }
+}
+async function streamingGenerate(auth, manifest, missing, imagesDir, indexPath, index, counters) {
+  for (let i = 0;i < missing.length; i += STREAM_BATCH) {
+    const batch = missing.slice(i, i + STREAM_BATCH);
+    const res = await fetch(`${auth.appUrl}/api/assets/generate`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${auth.key}`
+      },
+      body: JSON.stringify({
+        workspaceId: auth.workspaceId,
+        jobs: batch.map((e) => ({
+          prompt: buildPrompt(manifest, e),
+          count: 1,
+          size: "1024x1024"
+        }))
+      })
+    });
+    if (!res.ok || !res.body) {
+      const json = await res.json().catch(() => ({}));
+      throw apiError(auth, "generate", res.status, json);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder;
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim())
+          continue;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (event.type === "image") {
+          const entry = batch[event.jobIndex];
+          if (!entry)
+            continue;
+          if (await saveProduced(imagesDir, indexPath, index, entry.file, event.asset)) {
+            counters.produced++;
+            console.log(`  ✓ ${entry.file} (${counters.produced + counters.failed}/${missing.length})`);
+          } else {
+            counters.failed++;
+          }
+        } else if (event.type === "error") {
+          const entry = batch[event.jobIndex];
+          counters.failed++;
+          console.error(`  ✗ ${entry?.file ?? `job ${event.jobIndex}`}: ${event.message}`);
+        }
+      }
+    }
+  }
+}
+async function imagesGenerate(storeDir) {
+  const auth = requireActive();
+  const imagesDir = join3(resolve2(storeDir), "images");
+  const manifestPath = join3(imagesDir, "manifest.json");
+  if (!existsSync3(manifestPath)) {
+    throw new Error(`No images/manifest.json in ${storeDir}`);
+  }
+  const manifest = JSON.parse(readFileSync3(manifestPath, "utf8"));
+  const indexPath = join3(imagesDir, "assets.json");
+  const index = existsSync3(indexPath) ? JSON.parse(readFileSync3(indexPath, "utf8")) : {};
+  const jobStatePath = join3(imagesDir, ".imagegen-job.json");
+  const counters = { produced: 0, failed: 0 };
+  if (existsSync3(jobStatePath)) {
+    const state = JSON.parse(readFileSync3(jobStatePath, "utf8"));
+    console.log(`Resuming job ${state.jobId}`);
+    await pollJob(auth, state.jobId, state.files, imagesDir, indexPath, index, counters);
+    rmSync2(jobStatePath, { force: true });
+    console.log(`Done: ${counters.produced} generated (already in the asset library), ${counters.failed} failed${counters.failed ? " — re-run to retry" : ""}.`);
+    return;
+  }
+  const missing = manifest.images.filter((e) => !existsSync3(join3(imagesDir, e.file)));
+  if (missing.length === 0) {
+    console.log("All manifest images already exist locally.");
+    return;
+  }
+  console.log(`Generating ${missing.length} image(s) on Zalify (workspace "${auth.workspaceName}")…`);
+  for (let i = 0;i < missing.length; i += MAX_JOBS_PER_REQUEST) {
+    const chunk = missing.slice(i, i + MAX_JOBS_PER_REQUEST);
+    const jobId = await submitJob(auth, manifest, chunk);
+    if (jobId === null) {
+      console.log("job API unavailable — using streaming mode");
+      await streamingGenerate(auth, manifest, missing.slice(i), imagesDir, indexPath, index, counters);
+      break;
+    }
+    const state = { jobId, files: chunk.map((e) => e.file) };
+    writeFileSync4(jobStatePath, JSON.stringify(state, null, 2) + `
+`);
+    await pollJob(auth, jobId, state.files, imagesDir, indexPath, index, counters);
+    rmSync2(jobStatePath, { force: true });
+  }
+  console.log(`Done: ${counters.produced} generated (already in the asset library), ${counters.failed} failed${counters.failed ? " — re-run to retry" : ""}.`);
+}
+
 // src/cli.ts
 var __dirname4 = dirname(fileURLToPath3(import.meta.url));
 var require2 = createRequire2(import.meta.url);
-var pkg = require2(join3(__dirname4, "..", "package.json"));
+var pkg = require2(join4(__dirname4, "..", "package.json"));
 try {
   updateNotifier({ pkg }).notify({
     isGlobal: true,
@@ -11894,6 +12103,10 @@ workspace.command("list", { isDefault: true }).description("List authorized work
 workspace.command("set <slug-or-id>").description("Switch the active workspace (local, no re-login)").action(async (slugOrId) => {
   await workspaceSet(slugOrId);
 });
+var images = program2.command("images").description("Generate images on Zalify infrastructure");
+images.command("generate <store-dir>").description("Generate missing manifest images server-side (results land in the asset library and are downloaded locally)").action(async (storeDir) => {
+  await imagesGenerate(storeDir);
+});
 var assets = program2.command("assets").description("Sync images with the Zalify asset library");
 assets.command("push <store-dir>").description("Upload <store-dir>/images/*.png (sha256 dedup, writes assets.json)").action(async (storeDir) => {
   await assetsPush(storeDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalify/cli",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Zalify CLI - command-line interface for Zalify",
   "type": "module",
   "main": "dist/cli.js",