@zalify/cli 0.7.1 → 0.8.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 join6 } 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) + `
 `);
@@ -12313,10 +12317,434 @@ async function shopifyUploadImages(storeDir) {
   console.log("Done.");
 }
 
+// src/theme.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import {
+  cpSync,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync2,
+  mkdtempSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync5,
+  renameSync,
+  rmSync as rmSync3,
+  statSync,
+  unlinkSync,
+  writeFileSync as writeFileSync5
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { basename as basename2, dirname, join as join5, resolve as resolve4 } 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 = join5(mkdtempSync(join5(tmpdir(), "zalify-theme-")), "pkg.tgz");
+  writeFileSync5(file2, Buffer.from(await res.arrayBuffer()));
+  return file2;
+}
+function extractTarball(file2) {
+  const dir2 = mkdtempSync(join5(tmpdir(), "zalify-theme-x-"));
+  const result = spawnSync2("tar", ["-xzf", resolve4(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 = join5(dir2, "package");
+  if (!existsSync5(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(readFileSync5(join5(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 = join5(pkgRoot, "templates", template, MANIFEST_PATH);
+  if (!existsSync5(path9)) {
+    throw new Error(`template "${template}" has no ${MANIFEST_PATH} — this ${TEMPLATES_PKG} version predates the upgrade contract`);
+  }
+  return JSON.parse(readFileSync5(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 = join5(templateDir, "__editor__", candidate);
+      if (existsSync5(overlay))
+        return overlay;
+    }
+  }
+  for (const candidate of [rel, stashed]) {
+    const path9 = join5(templateDir, candidate);
+    if (existsSync5(path9))
+      return path9;
+  }
+  throw new Error(`file listed in manifest but missing from template: ${rel}`);
+}
+function readProjectManifest(dir2) {
+  const path9 = join5(dir2, MANIFEST_PATH);
+  if (!existsSync5(path9)) {
+    throw new Error(`no ${MANIFEST_PATH} in ${dir2} — not a scaffolded Zalify storefront.
+` + `  Scaffold one with \`zalify theme create\`.`);
+  }
+  return JSON.parse(readFileSync5(path9, "utf8"));
+}
+function writeJson(path9, value) {
+  writeFileSync5(path9, JSON.stringify(value, null, 2) + `
+`);
+}
+async function themeCreate(dir2, opts) {
+  const targetDir = resolve4(dir2);
+  if (existsSync5(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(readFileSync5(join5(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 = join5(root, "templates", template);
+  console.log(`Scaffolding ${meta.label} (${TEMPLATES_PKG}@${version}) into ${dir2}`);
+  mkdirSync2(targetDir, { recursive: true });
+  cpSync(templateDir, targetDir, { recursive: true });
+  const overlayDir = join5(targetDir, "__editor__");
+  const useEditor = Boolean(opts.editor) && existsSync5(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 = join5(d, entry);
+      if (statSync(full).isDirectory())
+        restoreGitignores(full);
+      else if (entry === "gitignore")
+        renameSync(full, join5(d, ".gitignore"));
+    }
+  })(targetDir);
+  const pkgPath = join5(targetDir, "package.json");
+  const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
+  pkg.name = basename2(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(join5(targetDir, ".env"), lines.join(`
+`) + `
+`);
+  }
+  const manifest = readProjectManifest(targetDir);
+  writeJson(join5(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 = resolve4(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 = join5(projectDir, rel);
+    if (!existsSync5(full))
+      missing.push(rel);
+    else if (sha256(readFileSync5(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 = resolve4(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 = join5(base.root, "templates", local.template);
+  const newDir = join5(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 = join5(projectDir, rel);
+    const localExists = existsSync5(localPath);
+    const localBytes = localExists ? readFileSync5(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 = readFileSync5(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 = readFileSync5(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(join5(tmpdir(), "zalify-merge-"));
+        const basePath = join5(scratch, "base");
+        const newPath = join5(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(readFileSync5(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(join5(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(readFileSync5(join5(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(join5(projectDir, "package.json"), JSON.stringify(localPkg, null, 2) + `
+`);
+  }
+  return depsChanged;
+}
+
 // 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(join6(__dirname4, "..", "package.json"));
 try {
   updateNotifier({ pkg }).notify({
     isGlobal: true,
@@ -12371,6 +12799,16 @@ 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 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.8.0",
   "description": "Zalify CLI - command-line interface for Zalify",
   "type": "module",
   "main": "dist/cli.js",