@zalify/cli 0.8.0 → 0.9.1

package/dist/cli.js

@@ -11293,7 +11293,7 @@ function updateNotifier(options) {
 
 // src/cli.ts
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname2, join as join6 } from "node:path";
+import { dirname as dirname2, join as join7 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/auth.ts
@@ -12061,272 +12061,24 @@ 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";
-function proxyError(auth, status, json) {
-  if (json.code === "SCOPES_MISSING") {
-    const granted = new Set(json.grantedScopes ?? []);
-    const missing = (json.requiredScopes ?? []).filter((s) => !granted.has(s));
-    return new Error(`Your Shopify connection is missing newly added permissions: ${missing.join(", ") || "(unknown)"}.
-` + `  Reconnect the store (one-time approval): ${json.reconnectUrl ?? `${auth.appUrl}/store/${auth.workspaceSlug}/settings/integrations`}
-` + `  Then re-run this command.`);
-  }
-  if (status === 404) {
-    return new Error("Shopify Admin proxy not found (404) — the /api/shopify/admin endpoint " + "is probably not deployed yet on this Zalify app. Try again after the next deploy.");
-  }
-  if (status === 402 || json.code === "UPGRADE_REQUIRED") {
-    return new Error(`${json.error ?? "Paid plan required."}
-  Upgrade: ${auth.appUrl}/store/${auth.workspaceSlug}/settings/billing`);
-  }
-  if (status === 409) {
-    return new Error(`${json.error ?? "No Shopify store is connected to this workspace."}
-` + `  Connect one: ${auth.appUrl}/store/${auth.workspaceSlug}/settings/integrations`);
-  }
-  return new Error(`shopify/admin ${status}: ${JSON.stringify(json)}`);
-}
-async function gql(auth, query, variables = {}) {
-  const res = await fetch(`${auth.appUrl}/api/shopify/admin`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${auth.key}`
-    },
-    body: JSON.stringify({ workspaceId: auth.workspaceId, query, variables })
-  });
-  const json = await res.json().catch(() => ({}));
-  if (!res.ok)
-    throw proxyError(auth, res.status, json);
-  if (json.errors)
-    throw new Error(JSON.stringify(json.errors));
-  if (!json.data)
-    throw new Error(`shopify/admin: empty response`);
-  return json.data;
-}
-function readJson(path9, label) {
-  if (!existsSync4(path9)) {
-    throw new Error(`No ${label} at ${path9}`);
-  }
-  return JSON.parse(readFileSync4(path9, "utf8"));
-}
-function joinErrors(errs) {
-  return errs.map((e) => e.message).join("; ");
-}
-var PRODUCT_SET = `
-  mutation productSet($input: ProductSetInput!) {
-    productSet(input: $input, synchronous: true) {
-      product { id handle }
-      userErrors { field message }
-    }
-  }`;
-var COLLECTION_CREATE = `
-  mutation collectionCreate($input: CollectionInput!) {
-    collectionCreate(input: $input) {
-      collection { id handle }
-      userErrors { field message }
-    }
-  }`;
-async function findProductId(auth, handle) {
-  const data = await gql(auth, `query($q: String!) { products(first: 1, query: $q) { nodes { id handle } } }`, { q: `handle:${handle}` });
-  const node = data.products.nodes[0];
-  return node && node.handle === handle ? node.id : null;
-}
-async function shopifyImport(storeDir, options = {}) {
-  const auth = requireActive();
-  const dir2 = resolve3(storeDir);
-  const catalog = readJson(join4(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"})`);
-  const productIds = [];
-  for (const p of catalog.products) {
-    const options_ = p.options ?? [];
-    const optionValues = options_.map((name, idx) => ({
-      name,
-      position: idx + 1,
-      values: [...new Set(p.variants.map((v) => v.options[idx]))].map((v) => ({ name: v }))
-    }));
-    const input = {
-      handle: p.handle,
-      title: p.title,
-      descriptionHtml: p.descriptionHtml ?? "",
-      vendor: p.vendor ?? catalog.vendor,
-      productType: p.type ?? "",
-      tags: p.tags ?? [],
-      status: "ACTIVE",
-      productOptions: optionValues.length ? optionValues : [{ name: "Title", position: 1, values: [{ name: "Default Title" }] }],
-      variants: p.variants.map((v) => ({
-        optionValues: options_.length ? options_.map((name, idx) => ({ optionName: name, name: v.options[idx] })) : [{ optionName: "Title", name: "Default Title" }],
-        price: v.price,
-        compareAtPrice: v.compareAtPrice ?? null,
-        inventoryItem: {
-          sku: v.sku ?? "",
-          tracked: true,
-          measurement: { weight: { value: v.grams ?? 0, unit: "GRAMS" } }
-        },
-        inventoryQuantities: locationId ? [{ locationId, name: "available", quantity: v.inventory ?? 25 }] : []
-      }))
-    };
-    const existingId = await findProductId(auth, p.handle);
-    if (existingId)
-      input.id = existingId;
-    const data = await gql(auth, PRODUCT_SET, { input });
-    const errs = data.productSet.userErrors;
-    if (errs.length) {
-      console.error(`  ✗ ${p.handle}: ${joinErrors(errs)}`);
-    } else if (data.productSet.product) {
-      productIds.push(data.productSet.product.id);
-      console.log(`  ✓ ${existingId ? "updated" : "created"} ${p.handle} (${p.variants.length} variants)`);
-    }
-  }
-  if (options.prune) {
-    const wanted = new Set(catalog.products.map((p) => p.handle));
-    const data = await gql(auth, `query($q: String!) { products(first: 100, query: $q) { nodes { id handle } } }`, { q: `vendor:${catalog.vendor}` });
-    for (const node of data.products.nodes) {
-      if (wanted.has(node.handle))
-        continue;
-      const del = await gql(auth, `mutation($input: ProductDeleteInput!) {
-          productDelete(input: $input) { deletedProductId userErrors { field message } }
-        }`, { input: { id: node.id } });
-      const errs = del.productDelete.userErrors;
-      if (errs.length)
-        console.error(`  ✗ prune ${node.handle}: ${joinErrors(errs)}`);
-      else
-        console.log(`  ✓ pruned ${node.handle}`);
-    }
-  }
-  for (const c of catalog.collections ?? []) {
-    const existing = await gql(auth, `query($q: String!) { collections(first: 1, query: $q) { nodes { id handle } } }`, { q: `handle:${c.handle}` });
-    if (existing.collections.nodes[0]?.handle === c.handle) {
-      console.log(`  - collection ${c.handle} exists, skipped`);
-      continue;
-    }
-    const data = await gql(auth, COLLECTION_CREATE, {
-      input: {
-        handle: c.handle,
-        title: c.title,
-        descriptionHtml: c.descriptionHtml ?? "",
-        ruleSet: {
-          appliedDisjunctively: false,
-          rules: [
-            {
-              column: "TAG",
-              relation: "EQUALS",
-              condition: c.rule?.tag ?? `collection:${c.handle}`
-            }
-          ]
-        }
-      }
-    });
-    const errs = data.collectionCreate.userErrors;
-    if (errs.length)
-      console.error(`  ✗ collection ${c.handle}: ${joinErrors(errs)}`);
-    else
-      console.log(`  ✓ collection ${c.handle}`);
-  }
-  try {
-    const pubs = await gql(auth, `{ publications(first: 10) { nodes { id name } } }`);
-    const online = pubs.publications.nodes.find((n) => n.name === "Online Store");
-    if (online) {
-      for (const id of productIds) {
-        await gql(auth, `mutation($id: ID!, $input: [PublicationInput!]!) {
-            publishablePublish(id: $id, input: $input) { userErrors { field message } }
-          }`, { id, input: [{ publicationId: online.id }] });
-      }
-      console.log(`  ✓ published ${productIds.length} products to Online Store`);
-    }
-  } catch (e) {
-    console.warn(`  ! could not publish to Online Store (write_publications scope missing?): ${e instanceof Error ? e.message : String(e)}`);
-  }
-  console.log("Done.");
-}
-async function shopifyUploadImages(storeDir) {
-  const auth = requireActive();
-  const dir2 = resolve3(storeDir);
-  const manifest = readJson(join4(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)) {
-      console.log(`  - ${entry.handle}: ${entry.file} not generated yet, skipped`);
-      continue;
-    }
-    const found = await gql(auth, `query($q: String!) { products(first: 1, query: $q) { nodes { id handle
-        media(first: 50) { nodes { alt ... on MediaImage { image { url } } } } } } }`, { q: `handle:${entry.handle}` });
-    const product = found.products.nodes[0];
-    if (!product || product.handle !== entry.handle) {
-      console.error(`  ✗ ${entry.handle}: product not found in store`);
-      continue;
-    }
-    const stem = basename(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 staged = await gql(auth, `mutation($input: [StagedUploadInput!]!) {
-        stagedUploadsCreate(input: $input) {
-          stagedTargets { url resourceUrl parameters { name value } }
-          userErrors { field message }
-        }
-      }`, {
-      input: [
-        {
-          resource: "IMAGE",
-          filename: basename(entry.file),
-          mimeType: "image/png",
-          httpMethod: "PUT",
-          fileSize: String(bytes.length)
-        }
-      ]
-    });
-    const target = staged.stagedUploadsCreate.stagedTargets?.[0];
-    if (!target) {
-      console.error(`  ✗ ${entry.handle}: staged upload failed: ${JSON.stringify(staged.stagedUploadsCreate.userErrors)}`);
-      continue;
-    }
-    const headers = { "Content-Type": "image/png" };
-    for (const p of target.parameters)
-      headers[p.name] = p.value;
-    const up = await fetch(target.url, {
-      method: "PUT",
-      headers,
-      body: new Uint8Array(bytes)
-    });
-    if (!up.ok) {
-      console.error(`  ✗ ${entry.handle}: upload PUT failed (${up.status})`);
-      continue;
-    }
-    const media = await gql(auth, `mutation($productId: ID!, $media: [CreateMediaInput!]!) {
-        productCreateMedia(productId: $productId, media: $media) {
-          media { alt }
-          mediaUserErrors { field message }
-        }
-      }`, {
-      productId: product.id,
-      media: [
-        { originalSource: target.resourceUrl, alt: entry.alt ?? "", mediaContentType: "IMAGE" }
-      ]
-    });
-    const errs = media.productCreateMedia.mediaUserErrors;
-    if (errs.length)
-      console.error(`  ✗ ${entry.handle}: ${joinErrors(errs)}`);
-    else
-      console.log(`  ✓ ${entry.file}`);
-  }
-  console.log("Done.");
-}
+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 existsSync5,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync2,
   mkdtempSync,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync4,
   renameSync,
   rmSync as rmSync3,
   statSync,
@@ -12334,7 +12086,7 @@ import {
   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";
+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";
@@ -12360,27 +12112,27 @@ 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");
+  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(join5(tmpdir(), "zalify-theme-x-"));
-  const result = spawnSync2("tar", ["-xzf", resolve4(file2), "-C", dir2], {
+  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 = join5(dir2, "package");
-  if (!existsSync5(root))
+  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(readFileSync5(join5(root, "package.json"), "utf8")).version;
+    const v = JSON.parse(readFileSync4(join4(root, "package.json"), "utf8")).version;
     return { root, version: v };
   }
   const packument = await fetchPackument();
@@ -12391,11 +12143,11 @@ async function acquireTemplatePkg(localTarball, version) {
   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)) {
+  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(readFileSync5(path9, "utf8"));
+  return JSON.parse(readFileSync4(path9, "utf8"));
 }
 function resolveVariant(manifest, variant) {
   const resolved = { ...manifest, files: { ...manifest.files }, variant };
@@ -12409,48 +12161,48 @@ 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))
+      const overlay = join4(templateDir, "__editor__", candidate);
+      if (existsSync4(overlay))
         return overlay;
     }
   }
   for (const candidate of [rel, stashed]) {
-    const path9 = join5(templateDir, candidate);
-    if (existsSync5(path9))
+    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 = join5(dir2, MANIFEST_PATH);
-  if (!existsSync5(path9)) {
+  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(readFileSync5(path9, "utf8"));
+  return JSON.parse(readFileSync4(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) {
+  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(readFileSync5(join5(root, "templates.json"), "utf8"));
+  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 = join5(root, "templates", template);
+  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 = join5(targetDir, "__editor__");
-  const useEditor = Boolean(opts.editor) && existsSync5(overlayDir);
+  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`);
   }
@@ -12459,16 +12211,16 @@ async function themeCreate(dir2, opts) {
   rmSync3(overlayDir, { recursive: true, force: true });
   (function restoreGitignores(d) {
     for (const entry of readdirSync2(d)) {
-      const full = join5(d, entry);
+      const full = join4(d, entry);
       if (statSync(full).isDirectory())
         restoreGitignores(full);
       else if (entry === "gitignore")
-        renameSync(full, join5(d, ".gitignore"));
+        renameSync(full, join4(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";
+  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 = [
@@ -12480,12 +12232,12 @@ async function themeCreate(dir2, opts) {
     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(`
+    writeFileSync5(join4(targetDir, ".env"), lines.join(`
 `) + `
 `);
   }
   const manifest = readProjectManifest(targetDir);
-  writeJson(join5(targetDir, MANIFEST_PATH), resolveVariant(manifest, useEditor ? "editor" : "default"));
+  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) {
@@ -12518,17 +12270,17 @@ 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 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 = join5(projectDir, rel);
-    if (!existsSync5(full))
+    const full = join4(projectDir, rel);
+    if (!existsSync4(full))
       missing.push(rel);
-    else if (sha256(readFileSync5(full)) !== expected)
+    else if (sha256(readFileSync4(full)) !== expected)
       edited.push(rel);
     else
       clean++;
@@ -12546,7 +12298,7 @@ function looksBinary(...buffers) {
   return buffers.some((b) => b.subarray(0, 8000).includes(0));
 }
 async function themeUpgrade(dir2 = ".", opts = {}) {
-  const projectDir = resolve4(dir2);
+  const projectDir = resolve3(dir2);
   const local = readProjectManifest(projectDir);
   const variant = local.variant ?? "default";
   const target = await acquireTemplatePkg(opts.tarball, opts.to);
@@ -12560,8 +12312,8 @@ async function themeUpgrade(dir2 = ".", opts = {}) {
   }
   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);
+  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,
@@ -12579,9 +12331,9 @@ async function themeUpgrade(dir2 = ".", opts = {}) {
       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 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)
@@ -12595,7 +12347,7 @@ async function themeUpgrade(dir2 = ".", opts = {}) {
           console.log(`  ! missing ${rel} (theme file was deleted locally; unchanged upstream — leaving as is)`);
         continue;
       }
-      const newBytes = readFileSync5(templateFilePath(newDir, rel, variant));
+      const newBytes = readFileSync4(templateFilePath(newDir, rel, variant));
       if (!localExists) {
         write(newBytes);
         counts.add++;
@@ -12605,7 +12357,7 @@ async function themeUpgrade(dir2 = ".", opts = {}) {
         counts.overwrite++;
         console.log(`  ✓ ${opts.dryRun ? "would update" : "updated"} ${rel}`);
       } else if (localHash === newHash) {} else {
-        const oldBytes = readFileSync5(templateFilePath(oldDir, rel, variant));
+        const oldBytes = readFileSync4(templateFilePath(oldDir, rel, variant));
         if (looksBinary(localBytes, oldBytes, newBytes)) {
           if (!opts.dryRun)
             writeFileSync5(`${localPath}.new`, newBytes);
@@ -12619,9 +12371,9 @@ async function themeUpgrade(dir2 = ".", opts = {}) {
           console.log(`  ~ would merge ${rel}`);
           continue;
         }
-        const scratch = mkdtempSync(join5(tmpdir(), "zalify-merge-"));
-        const basePath = join5(scratch, "base");
-        const newPath = join5(scratch, "new");
+        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" });
@@ -12654,7 +12406,7 @@ async function themeUpgrade(dir2 = ".", opts = {}) {
       }
     } else if (!oldHash && newHash) {
       if (!localExists) {
-        write(readFileSync5(templateFilePath(newDir, rel, variant)));
+        write(readFileSync4(templateFilePath(newDir, rel, variant)));
         counts.add++;
         console.log(`  + ${opts.dryRun ? "would add" : "added"} ${rel}`);
       } else if (localHash !== newHash) {
@@ -12665,7 +12417,7 @@ async function themeUpgrade(dir2 = ".", opts = {}) {
   }
   const depsChanged = mergePackageJson(projectDir, oldDir, newDir, opts.dryRun ?? false);
   if (!opts.dryRun) {
-    writeJson(join5(projectDir, MANIFEST_PATH), { ...newManifest, version: target.version });
+    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(`
@@ -12686,7 +12438,7 @@ ${opts.dryRun ? "Would apply" : "Done"}: ${summary || "no file changes"}.`);
   }
 }
 function mergePackageJson(projectDir, oldDir, newDir, dryRun) {
-  const read = (p) => JSON.parse(readFileSync5(join5(p, "package.json"), "utf8"));
+  const read = (p) => JSON.parse(readFileSync4(join4(p, "package.json"), "utf8"));
   const localPkg = read(projectDir);
   const oldPkg = read(oldDir);
   const newPkg = read(newDir);
@@ -12735,20 +12487,437 @@ function mergePackageJson(projectDir, oldDir, newDir, dryRun) {
     console.log(`  ✓ package.json ${key} updated`);
   }
   if (changed && !dryRun) {
-    writeFileSync5(join5(projectDir, "package.json"), JSON.stringify(localPkg, null, 2) + `
+    writeFileSync5(join4(projectDir, "package.json"), JSON.stringify(localPkg, null, 2) + `
 `);
   }
   return depsChanged;
 }
 
-// src/cli.ts
-var __dirname4 = dirname2(fileURLToPath3(import.meta.url));
-var require2 = createRequire2(import.meta.url);
-var pkg = require2(join6(__dirname4, "..", "package.json"));
-try {
-  updateNotifier({ pkg }).notify({
-    isGlobal: true,
-    message: "Update available {currentVersion} → {latestVersion}\nRun `zalify self-update`"
+// 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", `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(["update-ref", "refs/remotes/origin/main", "HEAD"]);
+    run(["config", "branch.main.remote", "origin"]);
+    run(["config", "branch.main.merge", "refs/heads/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 ?? []);
+    const missing = (json.requiredScopes ?? []).filter((s) => !granted.has(s));
+    return new Error(`Your Shopify connection is missing newly added permissions: ${missing.join(", ") || "(unknown)"}.
+` + `  Reconnect the store (one-time approval): ${json.reconnectUrl ?? `${auth.appUrl}/store/${auth.workspaceSlug}/settings/integrations`}
+` + `  Then re-run this command.`);
+  }
+  if (status === 404) {
+    return new Error("Shopify Admin proxy not found (404) — the /api/shopify/admin endpoint " + "is probably not deployed yet on this Zalify app. Try again after the next deploy.");
+  }
+  if (status === 402 || json.code === "UPGRADE_REQUIRED") {
+    return new Error(`${json.error ?? "Paid plan required."}
+  Upgrade: ${auth.appUrl}/store/${auth.workspaceSlug}/settings/billing`);
+  }
+  if (status === 409) {
+    return new Error(`${json.error ?? "No Shopify store is connected to this workspace."}
+` + `  Connect one: ${auth.appUrl}/store/${auth.workspaceSlug}/settings/integrations`);
+  }
+  return new Error(`shopify/admin ${status}: ${JSON.stringify(json)}`);
+}
+async function gql(auth, query, variables = {}) {
+  const res = await fetch(`${auth.appUrl}/api/shopify/admin`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${auth.key}`
+    },
+    body: JSON.stringify({ workspaceId: auth.workspaceId, query, variables })
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok)
+    throw proxyError(auth, res.status, json);
+  if (json.errors)
+    throw new Error(JSON.stringify(json.errors));
+  if (!json.data)
+    throw new Error(`shopify/admin: empty response`);
+  return json.data;
+}
+function readJson(path9, label) {
+  if (!existsSync6(path9)) {
+    throw new Error(`No ${label} at ${path9}`);
+  }
+  return JSON.parse(readFileSync6(path9, "utf8"));
+}
+function joinErrors(errs) {
+  return errs.map((e) => e.message).join("; ");
+}
+var PRODUCT_SET = `
+  mutation productSet($input: ProductSetInput!) {
+    productSet(input: $input, synchronous: true) {
+      product { id handle }
+      userErrors { field message }
+    }
+  }`;
+var COLLECTION_CREATE = `
+  mutation collectionCreate($input: CollectionInput!) {
+    collectionCreate(input: $input) {
+      collection { id handle }
+      userErrors { field message }
+    }
+  }`;
+async function findProductId(auth, handle) {
+  const data = await gql(auth, `query($q: String!) { products(first: 1, query: $q) { nodes { id handle } } }`, { q: `handle:${handle}` });
+  const node = data.products.nodes[0];
+  return node && node.handle === handle ? node.id : null;
+}
+async function shopifyImport(storeDir, options = {}) {
+  const auth = requireActive();
+  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"})`);
+  const productIds = [];
+  for (const p of catalog.products) {
+    const options_ = p.options ?? [];
+    const optionValues = options_.map((name, idx) => ({
+      name,
+      position: idx + 1,
+      values: [...new Set(p.variants.map((v) => v.options[idx]))].map((v) => ({ name: v }))
+    }));
+    const input = {
+      handle: p.handle,
+      title: p.title,
+      descriptionHtml: p.descriptionHtml ?? "",
+      vendor: p.vendor ?? catalog.vendor,
+      productType: p.type ?? "",
+      tags: p.tags ?? [],
+      status: "ACTIVE",
+      productOptions: optionValues.length ? optionValues : [{ name: "Title", position: 1, values: [{ name: "Default Title" }] }],
+      variants: p.variants.map((v) => ({
+        optionValues: options_.length ? options_.map((name, idx) => ({ optionName: name, name: v.options[idx] })) : [{ optionName: "Title", name: "Default Title" }],
+        price: v.price,
+        compareAtPrice: v.compareAtPrice ?? null,
+        inventoryItem: {
+          sku: v.sku ?? "",
+          tracked: true,
+          measurement: { weight: { value: v.grams ?? 0, unit: "GRAMS" } }
+        },
+        inventoryQuantities: locationId ? [{ locationId, name: "available", quantity: v.inventory ?? 25 }] : []
+      }))
+    };
+    const existingId = await findProductId(auth, p.handle);
+    if (existingId)
+      input.id = existingId;
+    const data = await gql(auth, PRODUCT_SET, { input });
+    const errs = data.productSet.userErrors;
+    if (errs.length) {
+      console.error(`  ✗ ${p.handle}: ${joinErrors(errs)}`);
+    } else if (data.productSet.product) {
+      productIds.push(data.productSet.product.id);
+      console.log(`  ✓ ${existingId ? "updated" : "created"} ${p.handle} (${p.variants.length} variants)`);
+    }
+  }
+  if (options.prune) {
+    const wanted = new Set(catalog.products.map((p) => p.handle));
+    const data = await gql(auth, `query($q: String!) { products(first: 100, query: $q) { nodes { id handle } } }`, { q: `vendor:${catalog.vendor}` });
+    for (const node of data.products.nodes) {
+      if (wanted.has(node.handle))
+        continue;
+      const del = await gql(auth, `mutation($input: ProductDeleteInput!) {
+          productDelete(input: $input) { deletedProductId userErrors { field message } }
+        }`, { input: { id: node.id } });
+      const errs = del.productDelete.userErrors;
+      if (errs.length)
+        console.error(`  ✗ prune ${node.handle}: ${joinErrors(errs)}`);
+      else
+        console.log(`  ✓ pruned ${node.handle}`);
+    }
+  }
+  for (const c of catalog.collections ?? []) {
+    const existing = await gql(auth, `query($q: String!) { collections(first: 1, query: $q) { nodes { id handle } } }`, { q: `handle:${c.handle}` });
+    if (existing.collections.nodes[0]?.handle === c.handle) {
+      console.log(`  - collection ${c.handle} exists, skipped`);
+      continue;
+    }
+    const data = await gql(auth, COLLECTION_CREATE, {
+      input: {
+        handle: c.handle,
+        title: c.title,
+        descriptionHtml: c.descriptionHtml ?? "",
+        ruleSet: {
+          appliedDisjunctively: false,
+          rules: [
+            {
+              column: "TAG",
+              relation: "EQUALS",
+              condition: c.rule?.tag ?? `collection:${c.handle}`
+            }
+          ]
+        }
+      }
+    });
+    const errs = data.collectionCreate.userErrors;
+    if (errs.length)
+      console.error(`  ✗ collection ${c.handle}: ${joinErrors(errs)}`);
+    else
+      console.log(`  ✓ collection ${c.handle}`);
+  }
+  try {
+    const pubs = await gql(auth, `{ publications(first: 10) { nodes { id name } } }`);
+    const online = pubs.publications.nodes.find((n) => n.name === "Online Store");
+    if (online) {
+      for (const id of productIds) {
+        await gql(auth, `mutation($id: ID!, $input: [PublicationInput!]!) {
+            publishablePublish(id: $id, input: $input) { userErrors { field message } }
+          }`, { id, input: [{ publicationId: online.id }] });
+      }
+      console.log(`  ✓ published ${productIds.length} products to Online Store`);
+    }
+  } catch (e) {
+    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 = 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 = join6(dir2, "images", entry.file);
+    if (!existsSync6(filePath)) {
+      console.log(`  - ${entry.handle}: ${entry.file} not generated yet, skipped`);
+      continue;
+    }
+    const found = await gql(auth, `query($q: String!) { products(first: 1, query: $q) { nodes { id handle
+        media(first: 50) { nodes { alt ... on MediaImage { image { url } } } } } } }`, { q: `handle:${entry.handle}` });
+    const product = found.products.nodes[0];
+    if (!product || product.handle !== entry.handle) {
+      console.error(`  ✗ ${entry.handle}: product not found in store`);
+      continue;
+    }
+    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 = readFileSync6(filePath);
+    const staged = await gql(auth, `mutation($input: [StagedUploadInput!]!) {
+        stagedUploadsCreate(input: $input) {
+          stagedTargets { url resourceUrl parameters { name value } }
+          userErrors { field message }
+        }
+      }`, {
+      input: [
+        {
+          resource: "IMAGE",
+          filename: basename3(entry.file),
+          mimeType: "image/png",
+          httpMethod: "PUT",
+          fileSize: String(bytes.length)
+        }
+      ]
+    });
+    const target = staged.stagedUploadsCreate.stagedTargets?.[0];
+    if (!target) {
+      console.error(`  ✗ ${entry.handle}: staged upload failed: ${JSON.stringify(staged.stagedUploadsCreate.userErrors)}`);
+      continue;
+    }
+    const headers = { "Content-Type": "image/png" };
+    for (const p of target.parameters)
+      headers[p.name] = p.value;
+    const up = await fetch(target.url, {
+      method: "PUT",
+      headers,
+      body: new Uint8Array(bytes)
+    });
+    if (!up.ok) {
+      console.error(`  ✗ ${entry.handle}: upload PUT failed (${up.status})`);
+      continue;
+    }
+    const media = await gql(auth, `mutation($productId: ID!, $media: [CreateMediaInput!]!) {
+        productCreateMedia(productId: $productId, media: $media) {
+          media { alt }
+          mediaUserErrors { field message }
+        }
+      }`, {
+      productId: product.id,
+      media: [
+        { originalSource: target.resourceUrl, alt: entry.alt ?? "", mediaContentType: "IMAGE" }
+      ]
+    });
+    const errs = media.productCreateMedia.mediaUserErrors;
+    if (errs.length)
+      console.error(`  ✗ ${entry.handle}: ${joinErrors(errs)}`);
+    else
+      console.log(`  ✓ ${entry.file}`);
+  }
+  console.log("Done.");
+  await maybeRevalidateStorefront(auth, dir2);
+}
+
+// src/cli.ts
+var __dirname4 = dirname2(fileURLToPath3(import.meta.url));
+var require2 = createRequire2(import.meta.url);
+var pkg = require2(join7(__dirname4, "..", "package.json"));
+try {
+  updateNotifier({ pkg }).notify({
+    isGlobal: true,
+    message: "Update available {currentVersion} → {latestVersion}\nRun `zalify self-update`"
   });
 } catch {}
 var program2 = new Command;
@@ -12799,6 +12968,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 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);

package/package.json

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