@zalify/cli 0.7.1 → 0.9.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 join5 } from "node:path";
+import { dirname as dirname2, join as join7 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/auth.ts
@@ -11600,8 +11600,13 @@ async function whoami() {
   console.log(live ? "status     ✓ key verified" : `status     ! not verified — ${liveError}`);
 }
 
-// src/assets.ts
+// src/hash.ts
 import { createHash } from "node:crypto";
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+// src/assets.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, existsSync as existsSync2, readdirSync } from "node:fs";
 import { join as join2, resolve } from "node:path";
 var BATCH = 10;
@@ -11667,7 +11672,7 @@ async function assetsPush(storeDir) {
   }
   const files = readdirSync(imagesDir).filter((f) => f.endsWith(".png")).map((name) => {
     const bytes = readFileSync2(join2(imagesDir, name));
-    return { name, bytes, checksum: createHash("sha256").update(bytes).digest("hex") };
+    return { name, bytes, checksum: sha256(bytes) };
   }).filter((f) => index[f.name]?.checksum !== f.checksum);
   if (!files.length) {
     console.log("Everything already pushed.");
@@ -11848,7 +11853,6 @@ async function workspaceSet(slugOrId) {
 }
 
 // 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;
@@ -11882,7 +11886,7 @@ async function saveProduced(imagesDir, indexPath, index, file2, asset) {
   index[file2] = {
     assetId: asset.id,
     url: asset.url,
-    checksum: createHash2("sha256").update(bytes).digest("hex")
+    checksum: sha256(bytes)
   };
   writeFileSync4(indexPath, JSON.stringify(index, null, 2) + `
 `);
@@ -12057,8 +12061,597 @@ async function imagesGenerate(storeDir) {
 }
 
 // src/shopify.ts
-import { readFileSync as readFileSync4, existsSync as existsSync4 } from "node:fs";
-import { basename, join as join4, resolve as resolve3 } from "node:path";
+import { readFileSync as readFileSync6, existsSync as existsSync6 } from "node:fs";
+import { basename as basename3, join as join6, resolve as resolve5 } from "node:path";
+
+// src/storefront.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import { basename as basename2, join as join5, resolve as resolve4 } from "node:path";
+
+// src/theme.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import {
+  cpSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  mkdtempSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
+  renameSync,
+  rmSync as rmSync3,
+  statSync,
+  unlinkSync,
+  writeFileSync as writeFileSync5
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join as join4, resolve as resolve3 } from "node:path";
+var TEMPLATES_PKG = "@zalify/theme-templates";
+var REGISTRY = "https://registry.npmjs.org";
+var MANIFEST_PATH = ".zalify/theme.json";
+var PROTECTED_DIRS = ["theme/", ".git/", ".zalify/", "node_modules/", ".next/"];
+function isProtected(rel) {
+  if (rel === ".env" || rel.startsWith(".env.") && rel !== ".env.example")
+    return true;
+  return PROTECTED_DIRS.some((p) => rel === p.slice(0, -1) || rel.startsWith(p));
+}
+async function fetchPackument() {
+  const res = await fetch(`${REGISTRY}/${TEMPLATES_PKG}`, {
+    headers: { Accept: "application/vnd.npm.install-v1+json" }
+  });
+  if (res.status === 404) {
+    throw new Error(`${TEMPLATES_PKG} not found on npm — it may not be published yet.
+` + `  For local testing pass --tarball <path-to-.tgz>.`);
+  }
+  if (!res.ok)
+    throw new Error(`npm registry ${res.status} for ${TEMPLATES_PKG}`);
+  return await res.json();
+}
+async function downloadTarball(url) {
+  const res = await fetch(url);
+  if (!res.ok)
+    throw new Error(`tarball download ${res.status}: ${url}`);
+  const file2 = join4(mkdtempSync(join4(tmpdir(), "zalify-theme-")), "pkg.tgz");
+  writeFileSync5(file2, Buffer.from(await res.arrayBuffer()));
+  return file2;
+}
+function extractTarball(file2) {
+  const dir2 = mkdtempSync(join4(tmpdir(), "zalify-theme-x-"));
+  const result = spawnSync2("tar", ["-xzf", resolve3(file2), "-C", dir2], {
+    encoding: "utf8"
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(`tar extract failed for ${file2}: ${result.stderr || result.error?.message}`);
+  }
+  const root = join4(dir2, "package");
+  if (!existsSync4(root))
+    throw new Error(`unexpected tarball layout in ${file2} (no package/)`);
+  return root;
+}
+async function acquireTemplatePkg(localTarball, version) {
+  if (localTarball) {
+    const root = extractTarball(localTarball);
+    const v = JSON.parse(readFileSync4(join4(root, "package.json"), "utf8")).version;
+    return { root, version: v };
+  }
+  const packument = await fetchPackument();
+  const target = version ?? packument["dist-tags"].latest;
+  const entry = packument.versions[target];
+  if (!entry)
+    throw new Error(`${TEMPLATES_PKG}@${target} does not exist on npm`);
+  return { root: extractTarball(await downloadTarball(entry.dist.tarball)), version: target };
+}
+function readTemplateManifest(pkgRoot, template) {
+  const path9 = join4(pkgRoot, "templates", template, MANIFEST_PATH);
+  if (!existsSync4(path9)) {
+    throw new Error(`template "${template}" has no ${MANIFEST_PATH} — this ${TEMPLATES_PKG} version predates the upgrade contract`);
+  }
+  return JSON.parse(readFileSync4(path9, "utf8"));
+}
+function resolveVariant(manifest, variant) {
+  const resolved = { ...manifest, files: { ...manifest.files }, variant };
+  if (variant === "editor" && manifest.editorFiles) {
+    Object.assign(resolved.files, manifest.editorFiles);
+  }
+  delete resolved.editorFiles;
+  return resolved;
+}
+function templateFilePath(templateDir, rel, variant) {
+  const stashed = rel.replace(/(^|\/)\.gitignore$/, "$1gitignore");
+  if (variant === "editor") {
+    for (const candidate of [rel, stashed]) {
+      const overlay = join4(templateDir, "__editor__", candidate);
+      if (existsSync4(overlay))
+        return overlay;
+    }
+  }
+  for (const candidate of [rel, stashed]) {
+    const path9 = join4(templateDir, candidate);
+    if (existsSync4(path9))
+      return path9;
+  }
+  throw new Error(`file listed in manifest but missing from template: ${rel}`);
+}
+function readProjectManifest(dir2) {
+  const path9 = join4(dir2, MANIFEST_PATH);
+  if (!existsSync4(path9)) {
+    throw new Error(`no ${MANIFEST_PATH} in ${dir2} — not a scaffolded Zalify storefront.
+` + `  Scaffold one with \`zalify theme create\`.`);
+  }
+  return JSON.parse(readFileSync4(path9, "utf8"));
+}
+function writeJson(path9, value) {
+  writeFileSync5(path9, JSON.stringify(value, null, 2) + `
+`);
+}
+async function themeCreate(dir2, opts) {
+  const targetDir = resolve3(dir2);
+  if (existsSync4(targetDir) && readdirSync2(targetDir).length > 0) {
+    throw new Error(`${dir2} already exists and is not empty`);
+  }
+  const { root, version } = await acquireTemplatePkg(opts.tarball, opts.to);
+  const frameworks = JSON.parse(readFileSync4(join4(root, "templates.json"), "utf8"));
+  const template = opts.template ?? "nextjs";
+  const meta = frameworks.frameworks[template];
+  if (!meta) {
+    throw new Error(`unknown template "${template}" — expected one of: ${Object.keys(frameworks.frameworks).join(", ")}`);
+  }
+  const templateDir = join4(root, "templates", template);
+  console.log(`Scaffolding ${meta.label} (${TEMPLATES_PKG}@${version}) into ${dir2}`);
+  mkdirSync2(targetDir, { recursive: true });
+  cpSync(templateDir, targetDir, { recursive: true });
+  const overlayDir = join4(targetDir, "__editor__");
+  const useEditor = Boolean(opts.editor) && existsSync4(overlayDir);
+  if (opts.editor && !useEditor) {
+    console.log(`  ! --editor has no effect for ${template} — no editor overlay in this template`);
+  }
+  if (useEditor)
+    cpSync(overlayDir, targetDir, { recursive: true });
+  rmSync3(overlayDir, { recursive: true, force: true });
+  (function restoreGitignores(d) {
+    for (const entry of readdirSync2(d)) {
+      const full = join4(d, entry);
+      if (statSync(full).isDirectory())
+        restoreGitignores(full);
+      else if (entry === "gitignore")
+        renameSync(full, join4(d, ".gitignore"));
+    }
+  })(targetDir);
+  const pkgPath = join4(targetDir, "package.json");
+  const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+  pkg.name = basename(targetDir).toLowerCase().replaceAll(/[^a-z0-9-_.]+/g, "-").replaceAll(/^[-.]+|[-.]+$/g, "") || "zalify-storefront";
+  writeJson(pkgPath, pkg);
+  if (meta.env) {
+    const lines = [
+      "# Leave the store variables empty to run against https://mock.shop",
+      "# demo data. Fill them in to connect your Shopify store.",
+      `${meta.env.domain}=${opts.storeDomain ?? ""}`,
+      `${meta.env.token}=${opts.storefrontToken ?? ""}`
+    ];
+    if (meta.env.sessionSecret) {
+      lines.push("# Session cookie signing key — unique to this project.", `${meta.env.sessionSecret}=${randomBytes2(32).toString("hex")}`);
+    }
+    writeFileSync5(join4(targetDir, ".env"), lines.join(`
+`) + `
+`);
+  }
+  const manifest = readProjectManifest(targetDir);
+  writeJson(join4(targetDir, MANIFEST_PATH), resolveVariant(manifest, useEditor ? "editor" : "default"));
+  if (opts.git !== false) {
+    const git = (args) => spawnSync2("git", args, { cwd: targetDir, stdio: "ignore" });
+    if (git(["init", "-b", "main"]).status === 0) {
+      git(["add", "-A"]);
+      git(["commit", "-m", "Initial commit from zalify theme create"]);
+      console.log("  ✓ initialized git repository");
+    } else {
+      console.log("  ! git init failed — skipping repository setup");
+    }
+  }
+  if (opts.install !== false) {
+    const pm = spawnSync2("pnpm", ["--version"], { stdio: "ignore" }).status === 0 ? "pnpm" : "npm";
+    console.log(`  Installing dependencies with ${pm}…`);
+    const result = spawnSync2(pm, ["install"], { cwd: targetDir, stdio: "inherit" });
+    if (result.status !== 0) {
+      console.log(`  ! ${pm} install failed — run it manually inside the project`);
+    }
+  }
+  console.log(`
+Done. Next steps:`);
+  console.log(`  cd ${dir2}`);
+  if (opts.install === false)
+    console.log("  pnpm install");
+  for (const step of meta.nextSteps)
+    console.log(`  ${step}`);
+  if (meta.env) {
+    console.log(`
+Runs on mock.shop demo data out of the box — edit .env to connect your store.`);
+  }
+  console.log("Your theme customizations live in theme/ — see theme/README.md.");
+}
+function themeStatus(dir2 = ".") {
+  const projectDir = resolve3(dir2);
+  const manifest = readProjectManifest(projectDir);
+  console.log(`${manifest.template} theme, ${TEMPLATES_PKG}@${manifest.version}` + (manifest.variant === "editor" ? " (editor variant)" : ""));
+  let clean = 0;
+  const edited = [];
+  const missing = [];
+  for (const [rel, expected] of Object.entries(manifest.files)) {
+    const full = join4(projectDir, rel);
+    if (!existsSync4(full))
+      missing.push(rel);
+    else if (sha256(readFileSync4(full)) !== expected)
+      edited.push(rel);
+    else
+      clean++;
+  }
+  for (const rel of edited)
+    console.log(`  ! edited  ${rel}`);
+  for (const rel of missing)
+    console.log(`  ✗ missing ${rel}`);
+  console.log(`${clean} clean, ${edited.length} edited, ${missing.length} missing ` + `of ${Object.keys(manifest.files).length} theme-owned files`);
+  if (edited.length) {
+    console.log("Edited files are 3-way-merged on `zalify theme upgrade` (conflicts marked).");
+  }
+}
+function looksBinary(...buffers) {
+  return buffers.some((b) => b.subarray(0, 8000).includes(0));
+}
+async function themeUpgrade(dir2 = ".", opts = {}) {
+  const projectDir = resolve3(dir2);
+  const local = readProjectManifest(projectDir);
+  const variant = local.variant ?? "default";
+  const target = await acquireTemplatePkg(opts.tarball, opts.to);
+  if (target.version === local.version && !opts.tarball) {
+    console.log(`Already at ${TEMPLATES_PKG}@${local.version} — nothing to do.`);
+    return;
+  }
+  const base = await acquireTemplatePkg(opts.baseTarball, local.version);
+  if (base.version !== local.version) {
+    console.log(`  ! base tarball is ${base.version}, project manifest says ${local.version} — using it anyway`);
+  }
+  const oldManifest = resolveVariant(readTemplateManifest(base.root, local.template), variant);
+  const newManifest = resolveVariant(readTemplateManifest(target.root, local.template), variant);
+  const oldDir = join4(base.root, "templates", local.template);
+  const newDir = join4(target.root, "templates", local.template);
+  console.log(`Upgrading ${local.template} theme ${local.version} → ${target.version}` + (opts.dryRun ? " (dry run)" : ""));
+  const counts = {
+    overwrite: 0,
+    add: 0,
+    merge: 0,
+    conflict: 0,
+    delete: 0,
+    "keep-edited": 0,
+    "keep-warn": 0
+  };
+  const conflicts = [];
+  const allPaths = [...new Set([...Object.keys(oldManifest.files), ...Object.keys(newManifest.files)])].sort();
+  for (const rel of allPaths) {
+    if (isProtected(rel))
+      continue;
+    const oldHash = oldManifest.files[rel];
+    const newHash = newManifest.files[rel];
+    const localPath = join4(projectDir, rel);
+    const localExists = existsSync4(localPath);
+    const localBytes = localExists ? readFileSync4(localPath) : null;
+    const localHash = localBytes ? sha256(localBytes) : null;
+    const write = (bytes) => {
+      if (opts.dryRun)
+        return;
+      mkdirSync2(dirname(localPath), { recursive: true });
+      writeFileSync5(localPath, bytes);
+    };
+    if (oldHash && newHash) {
+      if (oldHash === newHash) {
+        if (!localExists)
+          console.log(`  ! missing ${rel} (theme file was deleted locally; unchanged upstream — leaving as is)`);
+        continue;
+      }
+      const newBytes = readFileSync4(templateFilePath(newDir, rel, variant));
+      if (!localExists) {
+        write(newBytes);
+        counts.add++;
+        console.log(`  + ${opts.dryRun ? "would restore" : "restored"} ${rel}`);
+      } else if (localHash === oldHash) {
+        write(newBytes);
+        counts.overwrite++;
+        console.log(`  ✓ ${opts.dryRun ? "would update" : "updated"} ${rel}`);
+      } else if (localHash === newHash) {} else {
+        const oldBytes = readFileSync4(templateFilePath(oldDir, rel, variant));
+        if (looksBinary(localBytes, oldBytes, newBytes)) {
+          if (!opts.dryRun)
+            writeFileSync5(`${localPath}.new`, newBytes);
+          counts.conflict++;
+          conflicts.push(rel);
+          console.log(`  ✗ conflict ${rel} (binary — new version written to ${rel}.new)`);
+          continue;
+        }
+        if (opts.dryRun) {
+          counts.merge++;
+          console.log(`  ~ would merge ${rel}`);
+          continue;
+        }
+        const scratch = mkdtempSync(join4(tmpdir(), "zalify-merge-"));
+        const basePath = join4(scratch, "base");
+        const newPath = join4(scratch, "new");
+        writeFileSync5(basePath, oldBytes);
+        writeFileSync5(newPath, newBytes);
+        const result = spawnSync2("git", ["merge-file", "-L", "current", "-L", `base (${base.version})`, "-L", `new (${target.version})`, localPath, basePath, newPath], { encoding: "utf8" });
+        rmSync3(scratch, { recursive: true, force: true });
+        if (result.error || result.status === null || result.status < 0) {
+          writeFileSync5(`${localPath}.new`, newBytes);
+          counts.conflict++;
+          conflicts.push(rel);
+          console.log(`  ✗ conflict ${rel} (merge unavailable — new version written to ${rel}.new)`);
+        } else if (result.status > 0) {
+          counts.conflict++;
+          conflicts.push(rel);
+          console.log(`  ✗ conflict ${rel} (${result.status} conflict marker(s) left in file)`);
+        } else {
+          counts.merge++;
+          console.log(`  ✓ merged ${rel} (kept your edits)`);
+        }
+      }
+    } else if (oldHash && !newHash) {
+      if (!localExists)
+        continue;
+      if (localHash === oldHash) {
+        if (!opts.dryRun)
+          unlinkSync(localPath);
+        counts.delete++;
+        console.log(`  - ${opts.dryRun ? "would remove" : "removed"} ${rel} (deleted upstream)`);
+      } else {
+        counts["keep-warn"]++;
+        console.log(`  ! kept ${rel} (deleted upstream, but you edited it)`);
+      }
+    } else if (!oldHash && newHash) {
+      if (!localExists) {
+        write(readFileSync4(templateFilePath(newDir, rel, variant)));
+        counts.add++;
+        console.log(`  + ${opts.dryRun ? "would add" : "added"} ${rel}`);
+      } else if (localHash !== newHash) {
+        counts["keep-warn"]++;
+        console.log(`  ! kept ${rel} (upstream added a file where yours exists)`);
+      }
+    }
+  }
+  const depsChanged = mergePackageJson(projectDir, oldDir, newDir, opts.dryRun ?? false);
+  if (!opts.dryRun) {
+    writeJson(join4(projectDir, MANIFEST_PATH), { ...newManifest, version: target.version });
+  }
+  const summary = Object.entries(counts).filter(([, n]) => n > 0).map(([k, n]) => `${n} ${k.replace("-", " ")}`).join(", ");
+  console.log(`
+${opts.dryRun ? "Would apply" : "Done"}: ${summary || "no file changes"}.`);
+  if (conflicts.length) {
+    console.log(`Resolve ${conflicts.length} conflict(s), then re-run \`zalify theme status\`:`);
+    for (const rel of conflicts)
+      console.log(`  ${rel}`);
+  }
+  if (depsChanged && !opts.dryRun) {
+    if (opts.install) {
+      const pm = spawnSync2("pnpm", ["--version"], { stdio: "ignore" }).status === 0 ? "pnpm" : "npm";
+      console.log(`Dependencies changed — running ${pm} install…`);
+      spawnSync2(pm, ["install"], { cwd: projectDir, stdio: "inherit" });
+    } else {
+      console.log("Dependencies changed — run `pnpm install`.");
+    }
+  }
+}
+function mergePackageJson(projectDir, oldDir, newDir, dryRun) {
+  const read = (p) => JSON.parse(readFileSync4(join4(p, "package.json"), "utf8"));
+  const localPkg = read(projectDir);
+  const oldPkg = read(oldDir);
+  const newPkg = read(newDir);
+  const eq = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+  let changed = false;
+  let depsChanged = false;
+  const mergeSection = (section) => {
+    const localS = localPkg[section] ?? {};
+    const oldS = oldPkg[section] ?? {};
+    const newS = newPkg[section] ?? {};
+    for (const key of new Set([...Object.keys(oldS), ...Object.keys(newS)])) {
+      if (eq(oldS[key], newS[key]))
+        continue;
+      if (!eq(localS[key], oldS[key]) && key in localS) {
+        if (!eq(localS[key], newS[key])) {
+          console.log(`  ! kept package.json ${section}.${key} = ${JSON.stringify(localS[key])} (template wants ${JSON.stringify(newS[key] ?? "removed")})`);
+        }
+        continue;
+      }
+      changed = true;
+      if (section === "dependencies" || section === "devDependencies")
+        depsChanged = true;
+      if (key in newS) {
+        localS[key] = newS[key];
+        console.log(`  ✓ package.json ${section}.${key} → ${JSON.stringify(newS[key])}`);
+      } else {
+        delete localS[key];
+        console.log(`  - package.json ${section}.${key} removed`);
+      }
+    }
+    if (Object.keys(localS).length)
+      localPkg[section] = localS;
+  };
+  for (const section of ["dependencies", "devDependencies", "scripts"])
+    mergeSection(section);
+  for (const key of ["engines", "packageManager", "type"]) {
+    if (eq(oldPkg[key], newPkg[key]))
+      continue;
+    if (!eq(localPkg[key], oldPkg[key]))
+      continue;
+    changed = true;
+    if (key in newPkg)
+      localPkg[key] = newPkg[key];
+    else
+      delete localPkg[key];
+    console.log(`  ✓ package.json ${key} updated`);
+  }
+  if (changed && !dryRun) {
+    writeFileSync5(join4(projectDir, "package.json"), JSON.stringify(localPkg, null, 2) + `
+`);
+  }
+  return depsChanged;
+}
+
+// src/storefront.ts
+function apiError2(status, json, appUrl) {
+  if (status === 402) {
+    return new Error(`${json.error ?? "Upgrade required"}
+` + `  Storefront hosting is a paid feature — upgrade the workspace in ${appUrl}`);
+  }
+  if (json.code === "NO_CONNECTION") {
+    return new Error(`${json.error}
+  Connect the workspace to its Shopify store first, then re-run.`);
+  }
+  if (json.code === "SLUG_TAKEN") {
+    return new Error(`${json.error}
+  Pick a different directory/slug name.`);
+  }
+  if (status === 404) {
+    return new Error("The storefronts API is not deployed yet (404). Update app.zalify.com first.");
+  }
+  if (status === 503) {
+    return new Error(json.error ?? "Storefront provisioning is not configured on the server.");
+  }
+  return new Error(`storefronts API ${status}: ${JSON.stringify(json)}`);
+}
+async function post(auth, path9, body) {
+  const res = await fetch(`${auth.appUrl}${path9}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${auth.key}` },
+    body: JSON.stringify({ workspaceId: auth.workspaceId, ...body })
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok)
+    throw apiError2(res.status, json, auth.appUrl);
+  return json;
+}
+async function get(auth, path9) {
+  const sep = path9.includes("?") ? "&" : "?";
+  const res = await fetch(`${auth.appUrl}${path9}${sep}workspaceId=${auth.workspaceId}`, {
+    headers: { Authorization: `Bearer ${auth.key}` }
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok)
+    throw apiError2(res.status, json, auth.appUrl);
+  return json;
+}
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function pollUntilReady(auth, id) {
+  let lastMessage = "";
+  const deadline = Date.now() + 10 * 60000;
+  while (Date.now() < deadline) {
+    const view = await get(auth, `/api/storefronts/${id}`);
+    const message = view.statusMessage ?? view.status;
+    if (message !== lastMessage) {
+      console.log(`  … ${message}`);
+      lastMessage = message;
+    }
+    if (view.status === "READY")
+      return view;
+    if (view.status === "FAILED") {
+      throw new Error(`Provisioning failed: ${view.statusMessage ?? "unknown reason"}`);
+    }
+    await sleep2(3000);
+  }
+  throw new Error("Provisioning timed out after 10 minutes — check the Temporal UI.");
+}
+async function storefrontCreate(dir2, opts) {
+  const auth = requireActive();
+  const slug = basename2(resolve4(dir2)).toLowerCase().replaceAll(/[^a-z0-9-]+/g, "-").replaceAll(/^-+|-+$/g, "") || "storefront";
+  console.log(`Provisioning storefront "${slug}" (workspace "${auth.workspaceName}")`);
+  const { storefrontId } = await post(auth, "/api/storefronts", {
+    slug,
+    theme: opts.theme ?? "nextjs",
+    ...opts.to ? { themeVersion: opts.to } : {}
+  });
+  const view = await pollUntilReady(auth, storefrontId);
+  console.log(`  ✓ provisioned: ${view.githubRepo} → https://${view.domain}`);
+  await themeCreate(dir2, {
+    template: view.theme,
+    editor: opts.editor,
+    storeDomain: view.storeDomain ?? "",
+    storefrontToken: view.storefrontToken ?? "",
+    to: opts.to,
+    install: opts.install,
+    git: opts.git
+  });
+  if (opts.git !== false && view.githubRepo) {
+    const { token, repo } = await post(auth, `/api/storefronts/${storefrontId}/push-token`, {});
+    const run = (args) => spawnSync3("git", args, { cwd: resolve4(dir2), stdio: "ignore" });
+    run(["remote", "add", "origin", `https://github.com/${repo}.git`]);
+    const push = spawnSync3("git", ["push", "-u", `https://x-access-token:${token}@github.com/${repo}.git`, "main"], { cwd: resolve4(dir2), stdio: "inherit" });
+    if (push.status !== 0) {
+      throw new Error(`git push to ${repo} failed — resolve and push manually.`);
+    }
+    run(["branch", "--set-upstream-to=origin/main", "main"]);
+    console.log(`  ✓ pushed to github.com/${repo} — Vercel deploys on push`);
+  }
+  if (view.domain) {
+    console.log(`  Waiting for https://${view.domain} …`);
+    const deadline = Date.now() + 5 * 60000;
+    while (Date.now() < deadline) {
+      try {
+        const res = await fetch(`https://${view.domain}/`, { redirect: "manual" });
+        if (res.ok) {
+          console.log(`
+Live: https://${view.domain}`);
+          break;
+        }
+      } catch {}
+      await sleep2(1e4);
+    }
+  }
+  console.log(`
+Next steps:
+` + `  - author your theme in ${dir2}/theme/ (see theme/README.md), commit + push
+` + `  - zalify shopify import stores/<slug> --prune   # catalog (auto-flushes the site cache)
+` + `  - zalify theme status ${dir2}                    # drift check anytime`);
+}
+async function storefrontList() {
+  const auth = requireActive();
+  const { storefronts } = await get(auth, "/api/storefronts");
+  if (!storefronts.length) {
+    console.log(`No storefronts in workspace "${auth.workspaceName}".`);
+    return;
+  }
+  for (const s of storefronts) {
+    const site = s.domain ? `https://${s.domain}` : "-";
+    console.log(`${s.status === "READY" ? "✓" : s.status === "FAILED" ? "✗" : "…"} ${s.slug}  ${site}  (${s.status.toLowerCase()}${s.githubRepo ? `, ${s.githubRepo}` : ""})`);
+  }
+}
+function resolveSlug(slugOrDir) {
+  const storeJson = join5(resolve4(slugOrDir), "store.json");
+  if (existsSync5(storeJson)) {
+    const parsed = JSON.parse(readFileSync5(storeJson, "utf8"));
+    if (parsed.slug)
+      return parsed.slug;
+  }
+  return basename2(slugOrDir);
+}
+async function storefrontRevalidate(slugOrDir) {
+  const auth = requireActive();
+  const slug = resolveSlug(slugOrDir);
+  const { storefronts } = await get(auth, "/api/storefronts");
+  const match = storefronts.find((s) => s.slug === slug);
+  if (!match)
+    throw new Error(`No storefront "${slug}" in workspace "${auth.workspaceName}".`);
+  await post(auth, `/api/storefronts/${match.id}/revalidate`, {});
+  console.log(`✓ flushed cache on https://${match.domain}`);
+}
+async function maybeRevalidateStorefront(auth, storeDir) {
+  try {
+    const slug = resolveSlug(storeDir);
+    const { storefronts } = await get(auth, "/api/storefronts");
+    const match = storefronts.find((s) => s.slug === slug && s.status === "READY");
+    if (!match)
+      return;
+    await post(auth, `/api/storefronts/${match.id}/revalidate`, {});
+    console.log(`✓ site cache flushed (https://${match.domain})`);
+  } catch {}
+}
+
+// src/shopify.ts
 function proxyError(auth, status, json) {
   if (json.code === "SCOPES_MISSING") {
     const granted = new Set(json.grantedScopes ?? []);
@@ -12099,10 +12692,10 @@ async function gql(auth, query, variables = {}) {
   return json.data;
 }
 function readJson(path9, label) {
-  if (!existsSync4(path9)) {
+  if (!existsSync6(path9)) {
     throw new Error(`No ${label} at ${path9}`);
   }
-  return JSON.parse(readFileSync4(path9, "utf8"));
+  return JSON.parse(readFileSync6(path9, "utf8"));
 }
 function joinErrors(errs) {
   return errs.map((e) => e.message).join("; ");
@@ -12128,8 +12721,8 @@ async function findProductId(auth, handle) {
 }
 async function shopifyImport(storeDir, options = {}) {
   const auth = requireActive();
-  const dir2 = resolve3(storeDir);
-  const catalog = readJson(join4(dir2, "catalog.json"), "catalog.json");
+  const dir2 = resolve5(storeDir);
+  const catalog = readJson(join6(dir2, "catalog.json"), "catalog.json");
   const { locations } = await gql(auth, `{ locations(first: 1) { nodes { id name } } }`);
   const locationId = locations.nodes[0]?.id;
   console.log(`Importing ${catalog.products.length} product(s) into the Shopify store connected to ` + `workspace "${auth.workspaceName}" (location: ${locations.nodes[0]?.name ?? "none"})`);
@@ -12234,15 +12827,16 @@ async function shopifyImport(storeDir, options = {}) {
     console.warn(`  ! could not publish to Online Store (write_publications scope missing?): ${e instanceof Error ? e.message : String(e)}`);
   }
   console.log("Done.");
+  await maybeRevalidateStorefront(auth, dir2);
 }
 async function shopifyUploadImages(storeDir) {
   const auth = requireActive();
-  const dir2 = resolve3(storeDir);
-  const manifest = readJson(join4(dir2, "images", "manifest.json"), "images/manifest.json");
+  const dir2 = resolve5(storeDir);
+  const manifest = readJson(join6(dir2, "images", "manifest.json"), "images/manifest.json");
   console.log(`Uploading images to the Shopify store connected to workspace "${auth.workspaceName}"`);
   for (const entry of manifest.images) {
-    const filePath = join4(dir2, "images", entry.file);
-    if (!existsSync4(filePath)) {
+    const filePath = join6(dir2, "images", entry.file);
+    if (!existsSync6(filePath)) {
       console.log(`  - ${entry.handle}: ${entry.file} not generated yet, skipped`);
       continue;
     }
@@ -12253,13 +12847,13 @@ async function shopifyUploadImages(storeDir) {
       console.error(`  ✗ ${entry.handle}: product not found in store`);
       continue;
     }
-    const stem = basename(entry.file, ".png");
+    const stem = basename3(entry.file, ".png");
     const already = product.media.nodes.some((m) => m.image?.url?.includes(stem) || entry.alt && m.alt === entry.alt);
     if (already) {
       console.log(`  - ${entry.file}: already attached, skipped`);
       continue;
     }
-    const bytes = readFileSync4(filePath);
+    const bytes = readFileSync6(filePath);
     const staged = await gql(auth, `mutation($input: [StagedUploadInput!]!) {
         stagedUploadsCreate(input: $input) {
           stagedTargets { url resourceUrl parameters { name value } }
@@ -12269,7 +12863,7 @@ async function shopifyUploadImages(storeDir) {
       input: [
         {
           resource: "IMAGE",
-          filename: basename(entry.file),
+          filename: basename3(entry.file),
           mimeType: "image/png",
           httpMethod: "PUT",
           fileSize: String(bytes.length)
@@ -12311,12 +12905,13 @@ async function shopifyUploadImages(storeDir) {
       console.log(`  ✓ ${entry.file}`);
   }
   console.log("Done.");
+  await maybeRevalidateStorefront(auth, dir2);
 }
 
 // src/cli.ts
-var __dirname4 = dirname(fileURLToPath3(import.meta.url));
+var __dirname4 = dirname2(fileURLToPath3(import.meta.url));
 var require2 = createRequire2(import.meta.url);
-var pkg = require2(join5(__dirname4, "..", "package.json"));
+var pkg = require2(join7(__dirname4, "..", "package.json"));
 try {
   updateNotifier({ pkg }).notify({
     isGlobal: true,
@@ -12371,6 +12966,26 @@ shopify.command("import <store-dir>").description("Import <store-dir>/catalog.js
 shopify.command("upload-images <store-dir>").description("Upload <store-dir>/images/* to matching products per images/manifest.json (skips files already attached)").action(async (storeDir) => {
   await shopifyUploadImages(storeDir);
 });
+var storefront = program2.command("storefront").description("Provision and manage fully-hosted standalone storefronts (repo + Vercel via Zalify)");
+storefront.command("create <dir>").description("One-command launch: Zalify provisions the GitHub repo + Vercel project (env, domain, storefront token), then scaffolds locally and pushes").option("-t, --theme <name>", "theme", "nextjs").option("--editor", "include the Zalify canvas-editor (z1) wiring").option("--to <version>", "template version (default: latest)").option("--no-install", "skip dependency install").option("--no-git", "skip git init/push").action(async (dir2, options) => {
+  await storefrontCreate(dir2, options);
+});
+storefront.command("list", { isDefault: true }).description("List the workspace's provisioned storefronts").action(async () => {
+  await storefrontList();
+});
+storefront.command("revalidate <slug-or-store-dir>").description("Flush the storefront site's data cache (secret stays server-side)").action(async (slugOrDir) => {
+  await storefrontRevalidate(slugOrDir);
+});
+var theme = program2.command("theme").description("Scaffold and upgrade standalone Zalify storefronts (Shopify-theme model)");
+theme.command("create <dir>").description("Scaffold a standalone storefront from the published theme templates").option("-t, --template <name>", "liquid | hydrogen | nextjs", "nextjs").option("--editor", "include the Zalify canvas-editor (z1) wiring").option("--store-domain <domain>", "your-store.myshopify.com (default: mock.shop demo data)").option("--storefront-token <token>", "public Storefront API access token").option("--to <version>", "template version (default: latest)").option("--no-install", "skip dependency install").option("--no-git", "skip git init + initial commit").option("--tarball <path>", "use a local @zalify/theme-templates .tgz instead of npm").action(async (dir2, options) => {
+  await themeCreate(dir2, options);
+});
+theme.command("status [dir]").description("List theme-owned files edited since scaffolding (.zalify/theme.json checksums)").action((dir2) => {
+  themeStatus(dir2);
+});
+theme.command("upgrade [dir]").description("Upgrade to a newer theme version: untouched files overwritten, edited files 3-way-merged, theme/ + .env never touched").option("--to <version>", "target template version (default: latest)").option("--dry-run", "classify and report without writing anything").option("--install", "run install when dependencies changed").option("--tarball <path>", "target version as a local .tgz (testing)").option("--base-tarball <path>", "base version as a local .tgz (testing)").action(async (dir2, options) => {
+  await themeUpgrade(dir2, options);
+});
 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.7.1",
+  "version": "0.9.0",
   "description": "Zalify CLI - command-line interface for Zalify",
   "type": "module",
   "main": "dist/cli.js",