@zalify/cli 0.17.0 → 0.17.2

package/README.md

@@ -1,6 +1,7 @@
 # @zalify/cli
 
-Zalify CLI – command-line interface for Zalify.
+Zalify CLI — author a brand, launch its shop, run its ads, keep the theme
+current.
 
 ## Install
 
@@ -10,45 +11,119 @@ npm i -g zalify
 npm i -g @zalify/cli@latest
 ```
 
-## Usage
+Already installed? `zalify self-update`.
 
-### Authentication
+## The command model
 
-```bash
-zalify login                                   # opens the browser: pick a workspace, authorize
-zalify login --app-url http://localhost:3000   # against a local app.zalify.com
-zalify whoami                                  # show the authorized workspace
-zalify logout                                  # delete local credentials
-```
+Four nouns, four objects:
 
-`login` runs a loopback flow (like `gh auth login`): the CLI listens on a
-random localhost port, the browser opens `app.zalify.com/cli/auth`, and on
-approval a **workspace-scoped API key** is handed back to the CLI and stored
-in `~/.zalify/config.json` (0600). Keys are ordinary Zalify Public API keys —
-list and revoke them in **Settings → Developer**.
+| Noun | The object | What lives under it |
+| --- | --- | --- |
+| `brand` | the **data** | a brand folder: catalog, voice guide, image manifest |
+| `shop` | the **shop** | Zalify-hosted at `<slug>.z1.shop`: repo + deployment + domain |
+| `ads` | the **ad ops** | Autopilot brand instance: campaign intent repo (media plans, ads-as-code, policy) |
+| `theme` | the **code** | Shopify-theme model: scaffold a copy, measure drift, upgrade |
 
-### Assets
+Everything acting on a brand folder lives under `brand`. Brand and theme
+commands default their directory to the cwd; `shop refresh`/`open` resolve
+their shop from the cwd (`.zalify/site.json` in a scaffold, `store.json` in
+a brand folder); `ads` commands run arg-free from a checkout carrying
+`.zalify/brand-repo.json`.
 
-Sync a directory's `images/*.png` with the workspace asset library
-(the same storage that backs Assets in the Zalify app):
+## The golden path (new brand, start to live)
 
 ```bash
-zalify assets push <dir>      # upload new/changed files (sha256 dedup)
-zalify assets pull <dir>      # download files listed in images/assets.json
+zalify brand init stores/acme        # 1. author the data (no login needed)
+zalify login                         # 2. authorize; then: zalify workspace set <workspace>
+zalify shop create acme              # 3. live at acme.z1.shop in ~4 minutes
+cd stores/acme && zalify brand push --prune
+zalify brand images generate && zalify brand images attach
+zalify theme status                  # 6. stay current; `theme upgrade` keeps your edits
 ```
 
-`push` writes `<dir>/images/assets.json` — a committed index mapping each
-file to its asset id, public URL, and checksum. `pull` restores the binaries
-on a fresh clone, so image masters stay out of git.
+## Authentication
 
-## Commands
+```bash
+zalify login                                   # opens the browser: authorize once
+zalify login --app-url http://localhost:3000   # against a local app.zalify.com
+zalify whoami                                  # workspace, plan, and key details
+zalify logout                                  # delete local credentials
+```
 
-- **login** `[--app-url <url>]` – Browser-based authorization; stores a workspace API key locally.
-- **logout** – Deletes `~/.zalify/config.json` (revoke the key itself in Settings → Developer).
-- **whoami** – Shows the authorized workspace, app origin, and key prefix.
-- **assets push `<dir>`** – Uploads `<dir>/images/*.png` via presigned R2 PUTs; sha256 dedup; updates `assets.json`.
-- **assets pull `<dir>`** – Downloads files listed in `<dir>/images/assets.json` that are missing locally.
-- **version** – Prints `Zalify CLI version: x.x.x` and, if a newer version exists on npm, suggests running `npm i -g @zalify/cli@latest` to update.
+`login` runs a loopback flow (like `gh auth login`): the CLI listens on a
+random localhost port, the browser opens `app.zalify.com/cli/auth`, and on
+approval a **user key covering all your workspaces** is handed back and
+stored in `~/.zalify/config.json` (0600). Keys are ordinary Zalify Public
+API keys — list and revoke them in **Settings → Developer**. One login
+covers every workspace; `zalify workspace set` switches between them
+locally, no re-login.
+
+## Command reference
+
+### Auth & workspace
+
+| Command | What it does |
+| --- | --- |
+| `login [--app-url <url>]` | Browser-based authorization; stores a user key locally |
+| `logout` | Deletes `~/.zalify/config.json` (revoke the key itself in Settings → Developer) |
+| `whoami` | Verifies the stored key; shows workspace, plan, app origin, key prefix |
+| `workspace` / `workspace list` | List authorized workspaces (`*` = active) |
+| `workspace set <slug-or-id>` | Switch the active workspace (local, no re-login) |
+
+### `brand` — the data
+
+| Command | What it does |
+| --- | --- |
+| `brand init [dir] [--name <name>] [--vertical <v>] [--currency <code>]` | Scaffold a brand folder: catalog, voice guide, image manifest, `AUTHORING.md` rules. No login needed |
+| `brand validate [dir]` | Lint the brand folder against the authoring rules |
+| `brand push [dir] [--prune] [--shop <slug>]` | Push `catalog.json` to the connected Shopify store — products, smart collections, publish; idempotent. `--prune` deletes store products (by catalog vendor) absent from the catalog; `--shop` narrows the post-push refresh to one shop |
+| `brand images generate [dir]` | Generate the manifest's missing images on Zalify infrastructure (resumable) |
+| `brand images attach [dir] [--shop <slug>]` | Attach generated images to their Shopify products per the manifest (skips already-attached) |
+| `brand images push [dir]` | Upload image masters to the Zalify asset library — presigned R2 PUTs, sha256 dedup; writes `images/assets.json`, the committed index that keeps binaries out of git |
+| `brand images pull [dir]` | Download masters listed in `images/assets.json` that are missing locally (fresh-clone restore) |
+
+### `shop` — the hosted shop
+
+| Command | What it does |
+| --- | --- |
+| `shop create <dir> [-t <theme>] [--editor] [--to <version>] [--no-install] [--no-git]` | One-command launch: provision repo + deployment + domain + storefront token, scaffold locally, push, go live at `<slug>.z1.shop`. `--editor` wires in the Zalify canvas editor (z1) |
+| `shop` / `shop list` | List the workspace's hosted shops |
+| `shop refresh [slug-or-dir]` | Refresh the live shop's data cache (defaults to the shop linked to cwd) |
+| `shop open [slug-or-dir]` | Open the live shop in the browser (defaults to the shop linked to cwd) |
+| `shop domain-sync [slug-or-dir]` | Re-point the shop at the current root domain (the old domain 308-redirects) |
+
+`site …` remains as a hidden alias for one release and prints a pointer to
+its new home under `shop`.
+
+### `ads` — the ad ops
+
+| Command | What it does |
+| --- | --- |
+| `ads create <dir>` | Provision an Autopilot brand-instance GitHub repo (POST `/api/repos`, GitHub App), scaffold the starter locally (`identity.yaml`, `brand.yaml`, `policy/`, `campaigns/`, `media-plans/`, `signals/`, `decisions/`), and push with a short-lived repo-scoped token. Writes `.zalify/brand-repo.json` so later commands run arg-free. The directory name becomes the slug — use the workspace's store slug so the service's digest writer can find the repo |
+| `ads` / `ads list` | List the workspace's brand instances and their provisioning status |
+
+The engine commands — `plan` / `apply` / `creative` / `report` — join this
+group as `@zalify/ads-engine` merges in. Until then, drafting and applying
+happen on the Structure canvas in app.zalify.com; the instance repo is the
+durable intent layer that work lands in.
+
+### `theme` — the code
+
+| Command | What it does |
+| --- | --- |
+| `theme create <dir> [-t <template>] [--editor] [--store-domain <domain>] [--storefront-token <token>] [--to <version>] [--no-install] [--no-git] [--tarball <path>]` | Scaffold only — no Zalify hosting (the self-host path; `shop create` is the fully-hosted launch). Templates: `liquid` \| `hydrogen` \| `nextjs`. Without `--store-domain` it runs on mock.shop demo data |
+| `theme status [dir]` | Which theme files have you edited? Checksums vs `.zalify/theme.json` |
+| `theme upgrade [dir] [--to <version>] [--dry-run] [--install] [--tarball <path>] [--base-tarball <path>]` | Move to a newer theme version: untouched files overwritten, edited files 3-way-merged, `theme/` + `.env` never touched. `--dry-run` classifies and reports without writing |
+
+### Maintenance
+
+| Command | What it does |
+| --- | --- |
+| `version` | Print the CLI version and check npm for a newer one |
+| `self-update` | Update the CLI to the latest version (auto-detects pnpm/bun/npm) |
+
+Every invocation also runs a passive, non-blocking update check and prints
+a one-line notice when a newer version exists.
 
 ## Development
 
@@ -76,8 +151,6 @@ Release flow:
 
 ```bash
 npm version minor --no-git-tag-version   # or patch/major
-git commit -am "chore: release v0.x.0" && git push
+# bump zalify/package.json in step and pin its @zalify/cli dependency
+git commit -am "0.x.0" && git push
 ```
-
-`bun run release` (bump + local `npm publish`, needs `NODE_AUTH_TOKEN` in
-`.env`) remains as a manual fallback if CI is unavailable.

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 join9 } from "node:path";
+import { dirname as dirname2, join as join10 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/auth.ts
@@ -11762,37 +11762,123 @@ async function assetsPush(storeDir) {
 
 // src/self-update.ts
 import { spawnSync } from "node:child_process";
-import { realpathSync } from "node:fs";
-function detectManager() {
-  let binPath = process.argv[1] ?? "";
+import { existsSync as existsSync3, realpathSync } from "node:fs";
+import { delimiter, join as join3 } from "node:path";
+var PACKAGES = ["zalify", "@zalify/cli"];
+var real = (p) => {
   try {
-    binPath = realpathSync(binPath);
-  } catch {}
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+};
+function managerFor(binPath) {
   if (binPath.includes("/pnpm/") || binPath.includes("/.pnpm/")) {
-    return { cmd: "pnpm", args: ["add", "-g", "@zalify/cli@latest"] };
+    return {
+      cmd: "pnpm",
+      update: (spec) => ["add", "-g", spec],
+      remove: `pnpm rm -g ${PACKAGES.join(" ")}`
+    };
   }
   if (binPath.includes("/.bun/")) {
-    return { cmd: "bun", args: ["add", "-g", "@zalify/cli@latest"] };
+    return {
+      cmd: "bun",
+      update: (spec) => ["add", "-g", spec],
+      remove: `bun remove -g ${PACKAGES.join(" ")}`
+    };
   }
-  return { cmd: "npm", args: ["install", "-g", "@zalify/cli@latest"] };
+  return {
+    cmd: "npm",
+    update: (spec) => ["install", "-g", spec],
+    remove: `npm rm -g ${PACKAGES.join(" ")}`
+  };
+}
+function packageFor(binPath) {
+  return /\/node_modules\/zalify\//.test(binPath) || /\/zalify@\d/.test(binPath) ? "zalify" : "@zalify/cli";
+}
+function zalifysOnPath() {
+  const hits = [];
+  for (const dir2 of (process.env.PATH ?? "").split(delimiter)) {
+    if (!dir2)
+      continue;
+    const candidate = join3(dir2, "zalify");
+    if (existsSync3(candidate) && !hits.includes(candidate)) {
+      hits.push(candidate);
+    }
+  }
+  return hits;
 }
-function selfUpdate(currentVersion) {
-  const { cmd, args } = detectManager();
+function versionOf(bin) {
+  const res = spawnSync(bin, ["--version"], { encoding: "utf8" });
+  if (res.error || res.status !== 0)
+    return null;
+  return res.stdout?.trim() || null;
+}
+var HASH_HINT = "If `zalify -v` still shows the old version in this terminal, the shell\n" + "has cached the old location — run `hash -r` (zsh/bash) or open a new\n" + "terminal. A CLI cannot refresh its parent shell for you.";
+async function selfUpdate(currentVersion) {
+  const running = real(process.argv[1] ?? "");
+  const manager = managerFor(running);
+  const pkg = packageFor(running);
+  let latest = null;
+  try {
+    const info = await updateNotifier({
+      pkg: { name: "@zalify/cli", version: currentVersion }
+    }).fetchInfo();
+    latest = info?.latest ?? null;
+  } catch {}
+  const target = latest ? `${pkg}@${latest}` : `${pkg}@latest`;
   console.log(`Current version: ${currentVersion}`);
-  console.log(`Updating via: ${cmd} ${args.join(" ")}
+  console.log(`Updating via: ${manager.cmd} ${manager.update(target).join(" ")}
 `);
-  const result = spawnSync(cmd, args, { stdio: "inherit" });
+  const result = spawnSync(manager.cmd, manager.update(target), {
+    stdio: "inherit"
+  });
   if (result.error || result.status !== 0) {
     console.error(`
 Update failed${result.error ? `: ${result.error.message}` : ""}.` + `
-Try manually: ${cmd} ${args.join(" ")}`);
+Try manually: ${manager.cmd} ${manager.update(target).join(" ")}`);
     process.exit(result.status ?? 1);
   }
-  const check = spawnSync("zalify", ["--version"], { encoding: "utf8" });
-  const updated = check.stdout?.trim();
-  console.log(updated && updated !== currentVersion ? `
-✓ Updated ${currentVersion} → ${updated}` : `
-✓ Done${updated ? ` (version: ${updated})` : ""}`);
+  const hits = zalifysOnPath();
+  const first = hits[0];
+  const firstVersion = first ? versionOf(first) : null;
+  const mayBeHashed = hits.length > 1 || first && real(first) !== running;
+  if (!first || !firstVersion) {
+    console.log(`
+✓ Done`);
+    return;
+  }
+  const reachedLatest = latest ? firstVersion === latest : firstVersion !== currentVersion;
+  if (reachedLatest) {
+    console.log(firstVersion === currentVersion ? `
+✓ Already the latest (${firstVersion})` : `
+✓ Updated ${currentVersion} → ${firstVersion}`);
+    if (mayBeHashed)
+      console.log(`
+${HASH_HINT}`);
+    return;
+  }
+  if (latest) {
+    console.log(`
+✗ ${pkg} is now ${latest}, but your PATH still runs`);
+    console.log(`  ${first} (${firstVersion})`);
+    if (hits.length > 1) {
+      console.log(`
+Every zalify on your PATH:`);
+      for (const hit of hits) {
+        console.log(`  ${hit} → ${versionOf(hit) ?? "unreadable"}`);
+      }
+    }
+    console.log(`
+Remove the stale install (${managerFor(real(first)).remove}),`);
+    console.log("then run `hash -r` or open a new terminal.");
+    process.exit(1);
+  }
+  console.log(`
+✓ Done (version: ${firstVersion})`);
+  if (mayBeHashed)
+    console.log(`
+${HASH_HINT}`);
 }
 
 // src/workspace.ts
@@ -11867,8 +11953,8 @@ async function workspaceSet(slugOrId) {
 }
 
 // src/images.ts
-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";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, existsSync as existsSync4, rmSync as rmSync2 } from "node:fs";
+import { join as join4, resolve as resolve2 } from "node:path";
 var MAX_JOBS_PER_REQUEST = 40;
 var POLL_INTERVAL_MS = 5000;
 var POLL_TIMEOUT_MS = 30 * 60 * 1000;
@@ -11896,7 +11982,7 @@ async function saveProduced(imagesDir, indexPath, index, file2, asset) {
     return false;
   }
   const bytes = Buffer.from(await img.arrayBuffer());
-  writeFileSync4(join3(imagesDir, file2), bytes);
+  writeFileSync4(join4(imagesDir, file2), bytes);
   index[file2] = {
     assetId: asset.id,
     url: asset.url,
@@ -12033,17 +12119,17 @@ async function streamingGenerate(auth, manifest, missing, imagesDir, indexPath,
 }
 async function imagesGenerate(storeDir) {
   const auth = requireActive();
-  const imagesDir = join3(resolve2(storeDir), "images");
-  const manifestPath = join3(imagesDir, "manifest.json");
-  if (!existsSync3(manifestPath)) {
+  const imagesDir = join4(resolve2(storeDir), "images");
+  const manifestPath = join4(imagesDir, "manifest.json");
+  if (!existsSync4(manifestPath)) {
     throw new Error(`No images/manifest.json in ${storeDir}`);
   }
   const manifest = JSON.parse(readFileSync3(manifestPath, "utf8"));
-  const indexPath = join3(imagesDir, "assets.json");
-  const index = existsSync3(indexPath) ? JSON.parse(readFileSync3(indexPath, "utf8")) : {};
-  const jobStatePath = join3(imagesDir, ".imagegen-job.json");
+  const indexPath = join4(imagesDir, "assets.json");
+  const index = existsSync4(indexPath) ? JSON.parse(readFileSync3(indexPath, "utf8")) : {};
+  const jobStatePath = join4(imagesDir, ".imagegen-job.json");
   const counters = { produced: 0, failed: 0 };
-  if (existsSync3(jobStatePath)) {
+  if (existsSync4(jobStatePath)) {
     const state = JSON.parse(readFileSync3(jobStatePath, "utf8"));
     console.log(`Resuming job ${state.jobId}`);
     await pollJob(auth, state.jobId, state.files, imagesDir, indexPath, index, counters);
@@ -12051,7 +12137,7 @@ async function imagesGenerate(storeDir) {
     console.log(`Done: ${counters.produced} generated (already in the asset library), ${counters.failed} failed${counters.failed ? " — re-run to retry" : ""}.`);
     return;
   }
-  const missing = manifest.images.filter((e) => !existsSync3(join3(imagesDir, e.file)));
+  const missing = manifest.images.filter((e) => !existsSync4(join4(imagesDir, e.file)));
   if (missing.length === 0) {
     console.log("All manifest images already exist locally.");
     return;
@@ -12075,20 +12161,20 @@ async function imagesGenerate(storeDir) {
 }
 
 // src/shopify.ts
-import { readFileSync as readFileSync6, existsSync as existsSync6 } from "node:fs";
-import { basename as basename3, join as join6, resolve as resolve5 } from "node:path";
+import { readFileSync as readFileSync6, existsSync as existsSync7 } from "node:fs";
+import { basename as basename3, join as join7, resolve as resolve5 } from "node:path";
 
 // src/shop.ts
 import { spawn as spawn3, spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { basename as basename2, join as join5, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename2, join as join6, 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,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync2,
   mkdtempSync,
   readdirSync as readdirSync2,
@@ -12100,7 +12186,7 @@ import {
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { basename, dirname, join as join4, resolve as resolve3 } from "node:path";
+import { basename, dirname, join as join5, resolve as resolve3 } from "node:path";
 var TEMPLATES_PKG = "@zalify/theme-templates";
 var REGISTRY = "https://registry.npmjs.org";
 var MANIFEST_PATH = ".zalify/theme.json";
@@ -12126,27 +12212,27 @@ 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");
+  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(join4(tmpdir(), "zalify-theme-x-"));
+  const dir2 = mkdtempSync(join5(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))
+  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(readFileSync4(join4(root, "package.json"), "utf8")).version;
+    const v = JSON.parse(readFileSync4(join5(root, "package.json"), "utf8")).version;
     return { root, version: v };
   }
   const packument = await fetchPackument();
@@ -12157,8 +12243,8 @@ async function acquireTemplatePkg(localTarball, version) {
   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)) {
+  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(readFileSync4(path9, "utf8"));
@@ -12175,21 +12261,21 @@ 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))
+      const overlay = join5(templateDir, "__editor__", candidate);
+      if (existsSync5(overlay))
         return overlay;
     }
   }
   for (const candidate of [rel, stashed]) {
-    const path9 = join4(templateDir, candidate);
-    if (existsSync4(path9))
+    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 = join4(dir2, MANIFEST_PATH);
-  if (!existsSync4(path9)) {
+  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\`.`);
   }
@@ -12201,22 +12287,22 @@ function writeJson(path9, value) {
 }
 async function themeCreate(dir2, opts) {
   const targetDir = resolve3(dir2);
-  if (existsSync4(targetDir) && readdirSync2(targetDir).length > 0) {
+  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(readFileSync4(join4(root, "templates.json"), "utf8"));
+  const frameworks = JSON.parse(readFileSync4(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 = join4(root, "templates", template);
+  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 = join4(targetDir, "__editor__");
-  const useEditor = Boolean(opts.editor) && existsSync4(overlayDir);
+  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`);
   }
@@ -12225,14 +12311,14 @@ async function themeCreate(dir2, opts) {
   rmSync3(overlayDir, { recursive: true, force: true });
   (function restoreGitignores(d) {
     for (const entry of readdirSync2(d)) {
-      const full = join4(d, entry);
+      const full = join5(d, entry);
       if (statSync(full).isDirectory())
         restoreGitignores(full);
       else if (entry === "gitignore")
-        renameSync(full, join4(d, ".gitignore"));
+        renameSync(full, join5(d, ".gitignore"));
     }
   })(targetDir);
-  const pkgPath = join4(targetDir, "package.json");
+  const pkgPath = join5(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);
@@ -12246,12 +12332,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(join4(targetDir, ".env"), lines.join(`
+    writeFileSync5(join5(targetDir, ".env"), lines.join(`
 `) + `
 `);
   }
   const manifest = readProjectManifest(targetDir);
-  writeJson(join4(targetDir, MANIFEST_PATH), resolveVariant(manifest, useEditor ? "editor" : "default"));
+  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) {
@@ -12291,8 +12377,8 @@ function themeStatus(dir2 = ".") {
   const edited = [];
   const missing = [];
   for (const [rel, expected] of Object.entries(manifest.files)) {
-    const full = join4(projectDir, rel);
-    if (!existsSync4(full))
+    const full = join5(projectDir, rel);
+    if (!existsSync5(full))
       missing.push(rel);
     else if (sha256(readFileSync4(full)) !== expected)
       edited.push(rel);
@@ -12326,8 +12412,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 = join4(base.root, "templates", local.template);
-  const newDir = join4(target.root, "templates", local.template);
+  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,
@@ -12345,8 +12431,8 @@ async function themeUpgrade(dir2 = ".", opts = {}) {
       continue;
     const oldHash = oldManifest.files[rel];
     const newHash = newManifest.files[rel];
-    const localPath = join4(projectDir, rel);
-    const localExists = existsSync4(localPath);
+    const localPath = join5(projectDir, rel);
+    const localExists = existsSync5(localPath);
     const localBytes = localExists ? readFileSync4(localPath) : null;
     const localHash = localBytes ? sha256(localBytes) : null;
     const write = (bytes) => {
@@ -12385,9 +12471,9 @@ async function themeUpgrade(dir2 = ".", opts = {}) {
           console.log(`  ~ would merge ${rel}`);
           continue;
         }
-        const scratch = mkdtempSync(join4(tmpdir(), "zalify-merge-"));
-        const basePath = join4(scratch, "base");
-        const newPath = join4(scratch, "new");
+        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" });
@@ -12431,7 +12517,7 @@ async function themeUpgrade(dir2 = ".", opts = {}) {
   }
   const depsChanged = mergePackageJson(projectDir, oldDir, newDir, opts.dryRun ?? false);
   if (!opts.dryRun) {
-    writeJson(join4(projectDir, MANIFEST_PATH), { ...newManifest, version: target.version });
+    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(`
@@ -12452,7 +12538,7 @@ ${opts.dryRun ? "Would apply" : "Done"}: ${summary || "no file changes"}.`);
   }
 }
 function mergePackageJson(projectDir, oldDir, newDir, dryRun) {
-  const read = (p) => JSON.parse(readFileSync4(join4(p, "package.json"), "utf8"));
+  const read = (p) => JSON.parse(readFileSync4(join5(p, "package.json"), "utf8"));
   const localPkg = read(projectDir);
   const oldPkg = read(oldDir);
   const newPkg = read(newDir);
@@ -12501,7 +12587,7 @@ function mergePackageJson(projectDir, oldDir, newDir, dryRun) {
     console.log(`  ✓ package.json ${key} updated`);
   }
   if (changed && !dryRun) {
-    writeFileSync5(join4(projectDir, "package.json"), JSON.stringify(localPkg, null, 2) + `
+    writeFileSync5(join5(projectDir, "package.json"), JSON.stringify(localPkg, null, 2) + `
 `);
   }
   return depsChanged;
@@ -12597,9 +12683,9 @@ async function shopCreate(dir2, opts) {
     install: opts.install,
     git: opts.git
   });
-  writeFileSync6(join5(resolve4(dir2), ".zalify", "site.json"), JSON.stringify({ id: siteId, slug: view.slug, domain: view.domain, repo: view.githubRepo }, null, 2) + `
+  writeFileSync6(join6(resolve4(dir2), ".zalify", "site.json"), JSON.stringify({ id: siteId, slug: view.slug, domain: view.domain, repo: view.githubRepo }, null, 2) + `
 `);
-  writeFileSync6(join5(resolve4(dir2), "theme", "pixel.json"), JSON.stringify({ workspaceId: auth.workspaceId }, null, 2) + `
+  writeFileSync6(join6(resolve4(dir2), "theme", "pixel.json"), JSON.stringify({ workspaceId: auth.workspaceId }, null, 2) + `
 `);
   if (opts.git !== false && view.githubRepo) {
     const { token, repo } = await request(auth, "POST", `/api/sites/${siteId}/push-token`, {});
@@ -12640,14 +12726,14 @@ Next steps:
 }
 async function resolveSite(auth, slugOrDir) {
   const fromDir = (dir2) => {
-    const link = join5(dir2, ".zalify", "site.json");
-    if (existsSync5(link)) {
+    const link = join6(dir2, ".zalify", "site.json");
+    if (existsSync6(link)) {
       const parsed = JSON.parse(readFileSync5(link, "utf8"));
       if (parsed.slug)
         return parsed.slug;
     }
-    const storeJson = join5(dir2, "store.json");
-    if (existsSync5(storeJson)) {
+    const storeJson = join6(dir2, "store.json");
+    if (existsSync6(storeJson)) {
       const parsed = JSON.parse(readFileSync5(storeJson, "utf8"));
       if (parsed.slug)
         return parsed.slug;
@@ -12655,7 +12741,7 @@ async function resolveSite(auth, slugOrDir) {
     return null;
   };
   let slug = null;
-  if (slugOrDir && existsSync5(resolve4(slugOrDir)))
+  if (slugOrDir && existsSync6(resolve4(slugOrDir)))
     slug = fromDir(resolve4(slugOrDir));
   if (!slug && slugOrDir)
     slug = slugOrDir;
@@ -12716,8 +12802,8 @@ async function maybeRefreshShops(auth, brandDir, siteSlugOverride) {
   try {
     let slug = siteSlugOverride ?? null;
     if (!slug) {
-      const storeJson = join5(resolve4(brandDir), "store.json");
-      if (existsSync5(storeJson)) {
+      const storeJson = join6(resolve4(brandDir), "store.json");
+      if (existsSync6(storeJson)) {
         slug = JSON.parse(readFileSync5(storeJson, "utf8")).slug ?? null;
       }
     }
@@ -12772,7 +12858,7 @@ async function gql(auth, query, variables = {}) {
   return json.data;
 }
 function readJson(path9, label) {
-  if (!existsSync6(path9)) {
+  if (!existsSync7(path9)) {
     throw new Error(`No ${label} at ${path9}`);
   }
   return JSON.parse(readFileSync6(path9, "utf8"));
@@ -12802,7 +12888,7 @@ async function findProductId(auth, handle) {
 async function shopifyImport(storeDir, options = {}) {
   const auth = requireActive();
   const dir2 = resolve5(storeDir);
-  const catalog = readJson(join6(dir2, "catalog.json"), "catalog.json");
+  const catalog = readJson(join7(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"})`);
@@ -13011,13 +13097,13 @@ async function shopifyImport(storeDir, options = {}) {
 async function shopifyUploadImages(storeDir, options = {}) {
   const auth = requireActive();
   const dir2 = resolve5(storeDir);
-  const manifest = readJson(join6(dir2, "images", "manifest.json"), "images/manifest.json");
+  const manifest = readJson(join7(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) {
     if (entry.type === "banner" || !entry.handle)
       continue;
-    const filePath = join6(dir2, "images", entry.file);
-    if (!existsSync6(filePath)) {
+    const filePath = join7(dir2, "images", entry.file);
+    if (!existsSync7(filePath)) {
       console.log(`  - ${entry.handle}: ${entry.file} not generated yet, skipped`);
       continue;
     }
@@ -13092,7 +13178,7 @@ async function shopifyUploadImages(storeDir, options = {}) {
 // src/ads.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename4, join as join7, resolve as resolve6 } from "node:path";
+import { basename as basename4, join as join8, resolve as resolve6 } from "node:path";
 function apiError3(status, json) {
   if (json.code === "SLUG_TAKEN") {
     return new Error(`${json.error}
@@ -13144,8 +13230,8 @@ async function pollUntilReady2(auth, id) {
 function scaffoldStarter(dir2, slug, workspaceId) {
   const root = resolve6(dir2);
   const write = (rel, content) => {
-    const abs = join7(root, rel);
-    mkdirSync3(join7(abs, ".."), { recursive: true });
+    const abs = join8(root, rel);
+    mkdirSync3(join8(abs, ".."), { recursive: true });
     writeFileSync7(abs, content);
   };
   write("identity.yaml", `# Brand instance identity — which workspace and which platform accounts
@@ -13202,8 +13288,8 @@ async function adsCreate(dir2) {
   const view = await pollUntilReady2(auth, created.repoId);
   console.log(`  ✓ provisioned: ${view.githubRepo}`);
   scaffoldStarter(dir2, slug, auth.workspaceId);
-  mkdirSync3(join7(resolve6(dir2), ".zalify"), { recursive: true });
-  writeFileSync7(join7(resolve6(dir2), ".zalify", "brand-repo.json"), JSON.stringify({ id: created.repoId, slug: view.slug, repo: view.githubRepo }, null, 2) + `
+  mkdirSync3(join8(resolve6(dir2), ".zalify"), { recursive: true });
+  writeFileSync7(join8(resolve6(dir2), ".zalify", "brand-repo.json"), JSON.stringify({ id: created.repoId, slug: view.slug, repo: view.githubRepo }, null, 2) + `
 `);
   if (view.githubRepo) {
     const { token, repo } = await request2(auth, "POST", `/api/repos/${created.repoId}/push-token`, {});
@@ -13241,8 +13327,8 @@ async function adsList() {
 }
 
 // src/brand.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "node:fs";
-import { basename as basename5, join as join8, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "node:fs";
+import { basename as basename5, join as join9, resolve as resolve7 } from "node:path";
 var AUTHORING_MD = `# Brand authoring guide
 
 The rules for filling in this folder. An author — human or AI agent —
@@ -13545,17 +13631,17 @@ var MANIFEST_JSON = JSON.stringify({
 function brandInit(dir2 = ".", opts = {}) {
   const target = resolve7(dir2);
   const slug = basename5(target).toLowerCase().replaceAll(/[^a-z0-9-]+/g, "-").replaceAll(/^-+|-+$/g, "");
-  if (existsSync7(target) && readdirSync3(target).length > 0) {
+  if (existsSync8(target) && readdirSync3(target).length > 0) {
     throw new Error(`${dir2} already exists and is not empty`);
   }
   const name = opts.name ?? slug.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
   const currency = (opts.currency ?? "USD").toUpperCase();
-  mkdirSync4(join8(target, "images"), { recursive: true });
-  writeFileSync8(join8(target, "AUTHORING.md"), AUTHORING_MD);
-  writeFileSync8(join8(target, "brand.md"), BRAND_MD(name));
-  writeFileSync8(join8(target, "store.json"), STORE_JSON(name, slug, opts.vertical ?? "<vertical>", currency));
-  writeFileSync8(join8(target, "catalog.json"), CATALOG_JSON(name, currency));
-  writeFileSync8(join8(target, "images", "manifest.json"), MANIFEST_JSON);
+  mkdirSync4(join9(target, "images"), { recursive: true });
+  writeFileSync8(join9(target, "AUTHORING.md"), AUTHORING_MD);
+  writeFileSync8(join9(target, "brand.md"), BRAND_MD(name));
+  writeFileSync8(join9(target, "store.json"), STORE_JSON(name, slug, opts.vertical ?? "<vertical>", currency));
+  writeFileSync8(join9(target, "catalog.json"), CATALOG_JSON(name, currency));
+  writeFileSync8(join9(target, "images", "manifest.json"), MANIFEST_JSON);
   console.log(`Scaffolded brand data in ${dir2}:`);
   for (const f of ["AUTHORING.md", "brand.md", "store.json", "catalog.json", "images/manifest.json"]) {
     console.log(`  + ${f}`);
@@ -13570,8 +13656,8 @@ function brandValidate(dir2 = ".") {
   const problems = [];
   const warnings = [];
   const readJson2 = (rel) => {
-    const path9 = join8(target, rel);
-    if (!existsSync7(path9)) {
+    const path9 = join9(target, rel);
+    if (!existsSync8(path9)) {
       problems.push(`missing ${rel}`);
       return null;
     }
@@ -13582,7 +13668,7 @@ function brandValidate(dir2 = ".") {
       return null;
     }
   };
-  if (!existsSync7(join8(target, "brand.md")))
+  if (!existsSync8(join9(target, "brand.md")))
     problems.push("missing brand.md");
   const store = readJson2("store.json");
   if (store && (!store.name || !store.slug))
@@ -13758,7 +13844,7 @@ function brandValidate(dir2 = ".") {
 // src/cli.ts
 var __dirname4 = dirname2(fileURLToPath3(import.meta.url));
 var require2 = createRequire2(import.meta.url);
-var pkg = require2(join9(__dirname4, "..", "package.json"));
+var pkg = require2(join10(__dirname4, "..", "package.json"));
 try {
   updateNotifier({ pkg }).notify({
     isGlobal: true,
@@ -13847,7 +13933,9 @@ theme.command("status [dir]").description("Which theme files have you edited? (c
 theme.command("upgrade [dir]").description("Move to a newer theme version: untouched files overwritten, edited files 3-way-merged, theme/ + .env never touched").option("--to <version>", "target theme 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);
 });
-program2.command("self-update").description("Update the CLI to the latest version (auto-detects pnpm/bun/npm)").action(() => selfUpdate(pkg.version));
+program2.command("self-update").description("Update the CLI to the latest version (auto-detects pnpm/bun/npm)").action(async () => {
+  await selfUpdate(pkg.version);
+});
 program2.command("version").description("Print Zalify CLI version and check for updates").action(async () => {
   console.log(`Zalify CLI version: ${pkg.version}`);
   const isNewer = (a, b) => {

package/package.json

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