@storifycli/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1737 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync } from "fs";
+import path12 from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/lib/constants.ts
+var MAX_MANIFEST_BYTES = 95 * 1024;
+var MAX_ZIP_BYTES = 50 * 1024 * 1024;
+var MAX_SINGLE_FILE_BYTES = 10 * 1024 * 1024;
+var DEFAULT_API_URL = "http://localhost:3001/api";
+var DEFAULT_STOREFRONT_URL = "http://localhost:3004";
+var DEFAULT_ADMIN_URL = "http://localhost:3003";
+var CONFIG_DIR_NAME = ".storify";
+var CONFIG_FILE_NAME = "config.json";
+
+// src/lib/config.ts
+import os from "os";
+import path from "path";
+import { promises as fs } from "fs";
+function getConfigPath() {
+  return path.join(os.homedir(), CONFIG_DIR_NAME, CONFIG_FILE_NAME);
+}
+async function readStoredConfig() {
+  const configPath = getConfigPath();
+  try {
+    const raw = await fs.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function writeStoredConfig(nextConfig) {
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+  await fs.mkdir(configDir, { recursive: true });
+  await fs.writeFile(configPath, `${JSON.stringify(nextConfig, null, 2)}
+`, { mode: 384 });
+}
+async function resolveAuthConfig(overrides = {}) {
+  const stored = await readStoredConfig();
+  const apiUrl = overrides.api || process.env.STORIFY_API_URL || stored.apiUrl || DEFAULT_API_URL;
+  const storefrontUrl = process.env.STORIFY_STOREFRONT_URL || stored.storefrontUrl || DEFAULT_STOREFRONT_URL;
+  const adminUrl = process.env.STORIFY_ADMIN_URL || stored.adminUrl || DEFAULT_ADMIN_URL;
+  const storeId = overrides.storeId || process.env.STORIFY_STORE_ID || stored.storeId;
+  const token = overrides.token || process.env.STORIFY_AUTH_TOKEN || stored.token;
+  if (!storeId || !storeId.trim()) {
+    throw new Error("Missing store id. Provide --store-id, STORIFY_STORE_ID, or run `storify login`.");
+  }
+  if (!token || !token.trim()) {
+    throw new Error("Missing auth token. Provide --token, STORIFY_AUTH_TOKEN, or run `storify login`.");
+  }
+  return {
+    apiUrl: apiUrl.replace(/\/+$/, ""),
+    storeId: storeId.trim(),
+    token: token.trim(),
+    storefrontUrl: storefrontUrl.replace(/\/+$/, ""),
+    adminUrl: adminUrl.replace(/\/+$/, "")
+  };
+}
+function getConfigFilePathForDisplay() {
+  return getConfigPath();
+}
+
+// src/lib/auth-api.ts
+function normalizeApiUrl(apiUrl) {
+  return apiUrl.replace(/\/+$/, "");
+}
+function extractErrorMessage(body, fallback) {
+  if (body && typeof body === "object" && "error" in body && typeof body.error === "string") {
+    return body.error;
+  }
+  return fallback;
+}
+async function loginWithPassword(apiUrl, email, password2) {
+  const base = normalizeApiUrl(apiUrl);
+  const response = await fetch(`${base}/auth/login`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email: email.trim(), password: password2 })
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(extractErrorMessage(body, `Login failed (${response.status})`));
+  }
+  const accessToken = typeof body.accessToken === "string" ? body.accessToken : "";
+  if (!accessToken) {
+    throw new Error("Login succeeded but no access token was returned. Set LEGACY_TOKEN_RESPONSE=true on the API.");
+  }
+  return {
+    accessToken,
+    refreshToken: typeof body.refreshToken === "string" ? body.refreshToken : void 0,
+    user: body.user
+  };
+}
+async function fetchUserStores(apiUrl, token) {
+  const base = normalizeApiUrl(apiUrl);
+  const response = await fetch(`${base}/auth/stores`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json"
+    }
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(body.error || `Failed to load stores (${response.status})`);
+  }
+  return Array.isArray(body.stores) ? body.stores : [];
+}
+async function verifyAuthToken(apiUrl, token) {
+  const base = normalizeApiUrl(apiUrl || DEFAULT_API_URL);
+  const response = await fetch(`${base}/auth/me`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json"
+    }
+  });
+  return response.ok;
+}
+
+// src/lib/login-prompts.ts
+import * as p from "@clack/prompts";
+
+// src/lib/local-dev.ts
+function isLocalHostUrl(value) {
+  if (!value) return false;
+  try {
+    const host = new URL(value).hostname.toLowerCase();
+    return host === "localhost" || host === "127.0.0.1" || host === "::1";
+  } catch {
+    return value.includes("localhost") || value.includes("127.0.0.1");
+  }
+}
+function shouldUseLocalDev(options) {
+  if (options.remote) return false;
+  if (options.local) return true;
+  return isLocalHostUrl(options.apiUrl) || isLocalHostUrl(options.storefrontUrl);
+}
+function localStorefrontBaseUrl(configured) {
+  const base = (configured || DEFAULT_STOREFRONT_URL).replace(/\/+$/, "");
+  if (isLocalHostUrl(base)) return base;
+  return DEFAULT_STOREFRONT_URL.replace(/\/+$/, "");
+}
+
+// src/lib/storefront-url.ts
+var PLATFORM_DOMAIN = "storify.it.com";
+function normalizeBaseUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+function resolveStorefrontBaseUrl(store, configuredBase, options = {}) {
+  const fallback = normalizeBaseUrl(configuredBase || DEFAULT_STOREFRONT_URL);
+  if (options.preferLocal || isLocalHostUrl(fallback)) {
+    return fallback;
+  }
+  if (!store) return fallback;
+  if (store.customDomain && store.domainVerified) {
+    return `https://${store.customDomain.replace(/^https?:\/\//, "").replace(/\/+$/, "")}`;
+  }
+  if (store.subdomain && store.subdomain.trim()) {
+    return `https://${store.subdomain.trim().toLowerCase()}.${PLATFORM_DOMAIN}`;
+  }
+  if (store.domain && store.domain.trim() && !store.domain.includes("localhost")) {
+    const domain = store.domain.trim();
+    if (domain.startsWith("http://") || domain.startsWith("https://")) {
+      return normalizeBaseUrl(domain);
+    }
+    return `https://${domain}`;
+  }
+  return fallback;
+}
+function buildStorefrontEntryUrl(storefrontBase, storeId, devSessionId) {
+  const base = normalizeBaseUrl(storefrontBase);
+  const isLocal = base.includes("localhost") || base.includes("127.0.0.1") || !base.includes("://");
+  let url;
+  if (isLocal) {
+    url = new URL(`${base}/${encodeURIComponent(storeId)}/`);
+  } else {
+    url = new URL(`${base}/`);
+    if (!url.hostname.startsWith(`${storeId}.`) && !url.pathname.includes(storeId)) {
+      url.pathname = `/${encodeURIComponent(storeId)}/`;
+    }
+  }
+  if (devSessionId) {
+    url.searchParams.set("devSession", devSessionId);
+  }
+  return url.toString();
+}
+
+// src/lib/login-prompts.ts
+async function promptEmail() {
+  const answer = await p.text({
+    message: "Email",
+    placeholder: "you@example.com",
+    validate: (value) => value?.trim() ? void 0 : "Email is required"
+  });
+  if (p.isCancel(answer)) {
+    p.cancel("Login cancelled.");
+    process.exit(0);
+  }
+  return String(answer).trim();
+}
+async function promptPassword() {
+  const answer = await p.password({
+    message: "Password",
+    validate: (value) => value ? void 0 : "Password is required"
+  });
+  if (p.isCancel(answer)) {
+    p.cancel("Login cancelled.");
+    process.exit(0);
+  }
+  return String(answer);
+}
+function storeOptionHint(store) {
+  const parts = [];
+  if (store.subdomain?.trim()) parts.push(store.subdomain.trim());
+  if (store.role?.trim()) parts.push(store.role.trim());
+  return parts.length > 0 ? parts.join(" \xB7 ") : void 0;
+}
+function displayStoreName(store) {
+  const name = store.name?.trim();
+  return name || store.subdomain?.trim() || store.id;
+}
+async function promptStoreSelection(stores, currentStoreId) {
+  if (stores.length === 0) {
+    throw new Error("No stores found for this account.");
+  }
+  if (stores.length === 1) {
+    const store2 = stores[0];
+    p.log.success(`Store: ${displayStoreName(store2)}`);
+    return store2;
+  }
+  const selected = await p.select({
+    message: "Choose your store",
+    initialValue: currentStoreId && stores.some((s) => s.id === currentStoreId) ? currentStoreId : stores[0].id,
+    options: stores.map((store2) => ({
+      value: store2.id,
+      label: displayStoreName(store2),
+      hint: storeOptionHint(store2)
+    }))
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Store selection cancelled.");
+    process.exit(0);
+  }
+  const store = stores.find((s) => s.id === selected);
+  if (!store) throw new Error("Invalid store selection.");
+  return store;
+}
+async function runInteractiveLoginFlow(options) {
+  const stored = await readStoredConfig();
+  const apiUrl = (options?.apiUrl || stored.apiUrl || process.env.STORIFY_API_URL || DEFAULT_API_URL).replace(
+    /\/+$/,
+    ""
+  );
+  p.intro("Storify login");
+  const email = await promptEmail();
+  const password2 = await promptPassword();
+  const loginSpinner = p.spinner();
+  loginSpinner.start("Signing in");
+  let loginResult;
+  try {
+    loginResult = await loginWithPassword(apiUrl, email, password2);
+    loginSpinner.stop("Signed in");
+  } catch (error) {
+    loginSpinner.stop("Sign in failed");
+    throw error;
+  }
+  const storesSpinner = p.spinner();
+  storesSpinner.start("Loading stores");
+  let stores = loginResult.user?.stores;
+  if (!stores || stores.length === 0) {
+    stores = await fetchUserStores(apiUrl, loginResult.accessToken);
+  }
+  storesSpinner.stop(
+    stores.length === 1 ? `1 store available` : `${stores.length} stores available`
+  );
+  const store = await promptStoreSelection(stores, options?.currentStoreId || stored.storeId);
+  const preferLocal = isLocalHostUrl(apiUrl);
+  const storefrontUrl = resolveStorefrontBaseUrl(store, stored.storefrontUrl || DEFAULT_STOREFRONT_URL, {
+    preferLocal
+  });
+  const adminUrl = (stored.adminUrl || DEFAULT_ADMIN_URL).replace(/\/+$/, "");
+  await writeStoredConfig({
+    apiUrl,
+    token: loginResult.accessToken,
+    storeId: store.id,
+    storefrontUrl,
+    adminUrl
+  });
+  p.outro(`Ready \xB7 ${displayStoreName(store)}`);
+  return {
+    apiUrl,
+    token: loginResult.accessToken,
+    store,
+    storefrontUrl,
+    adminUrl
+  };
+}
+
+// src/lib/ui.ts
+import pc from "picocolors";
+import ora from "ora";
+var brand = {
+  name: "Storify",
+  cli: "storify",
+  tagline: "Theme development toolkit"
+};
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
+}
+function supportsColor() {
+  return pc.isColorSupported;
+}
+function paint(text3, tone) {
+  if (!supportsColor()) return text3;
+  switch (tone) {
+    case "brand":
+      return pc.bold(pc.cyan(text3));
+    case "muted":
+      return pc.dim(text3);
+    case "success":
+      return pc.green(text3);
+    case "warn":
+      return pc.yellow(text3);
+    case "error":
+      return pc.red(text3);
+    case "info":
+      return pc.blue(text3);
+    case "accent":
+      return pc.magenta(text3);
+    default:
+      return text3;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+function printBanner(version2) {
+  const line = "\u2500".repeat(52);
+  console.log("");
+  console.log(paint(`  ${brand.name} CLI`, "brand") + paint(`  v${version2}`, "muted"));
+  console.log(paint(`  ${brand.tagline}`, "muted"));
+  console.log(paint(`  ${line}`, "muted"));
+  console.log("");
+}
+function printHeading(title, subtitle) {
+  console.log("");
+  console.log(paint(title, "brand"));
+  if (subtitle) console.log(paint(subtitle, "muted"));
+}
+function printDivider() {
+  console.log(paint("\u2500".repeat(52), "muted"));
+}
+function printStep(label, value, pad = 14) {
+  console.log(`  ${paint(label.padEnd(pad), "muted")}${value}`);
+}
+function printSuccess(message) {
+  console.log(`${paint("\u2714", "success")} ${message}`);
+}
+function printInfo(message) {
+  console.log(`${paint("\u2139", "info")} ${message}`);
+}
+function printWarn(message) {
+  console.log(`${paint("\u26A0", "warn")} ${message}`);
+}
+function printError(message) {
+  console.error(`${paint("\u2716", "error")} ${message}`);
+}
+function printHint(message) {
+  console.log(paint(`  Tip: ${message}`, "muted"));
+}
+function printCommandExample(label, command) {
+  console.log(`  ${paint(label.padEnd(16), "muted")}${paint(command, "accent")}`);
+}
+function printPreviewPanel(title, rows) {
+  console.log("");
+  console.log(paint(`  ${title}`, "brand"));
+  printDivider();
+  const labelWidth = Math.max(16, ...rows.map((row) => row.label.length + 2));
+  for (const row of rows) {
+    printStep(row.label, row.value, labelWidth);
+  }
+  console.log("");
+}
+function printQuickStart() {
+  printHeading("Quick start");
+  printCommandExample("Live storefront preview", "storify theme dev");
+  printCommandExample("Local Vite only", "storify theme dev --no-link-store");
+  printCommandExample("Validate", "storify theme validate");
+  printCommandExample("Build + pack", "storify theme pack");
+  printCommandExample("Sign in", "storify login");
+  printCommandExample("Check setup", "storify status");
+  console.log("");
+  printHint("Run `storify theme --help` for all theme commands.");
+  console.log("");
+}
+function createSpinner(text3) {
+  return ora({
+    text: text3,
+    color: "cyan",
+    spinner: "dots"
+  });
+}
+async function withSpinner(text3, task) {
+  const spinner2 = createSpinner(text3);
+  spinner2.start();
+  try {
+    const result = await task();
+    spinner2.stop();
+    return result;
+  } catch (error) {
+    spinner2.fail(text3);
+    throw error;
+  }
+}
+function maskSecret(value, visible = 4) {
+  if (!value) return paint("not set", "warn");
+  if (value.length <= visible) return "****";
+  return `${value.slice(0, visible)}${"*".repeat(Math.min(8, value.length - visible))}`;
+}
+function handleCliError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  printError(message);
+  console.log("");
+  printHint("Run `storify status` to verify login and paths.");
+  process.exit(1);
+}
+
+// src/commands/login.ts
+function normalizeUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+async function runLoginCommand(options) {
+  const stored = await readStoredConfig();
+  if (isInteractive() && !options.token && !options.storeId) {
+    await runInteractiveLoginFlow({
+      apiUrl: options.api,
+      currentStoreId: stored.storeId
+    });
+    return;
+  }
+  let apiUrl = options.api || stored.apiUrl || DEFAULT_API_URL;
+  let storeId = options.storeId || stored.storeId || "";
+  let token = options.token || stored.token || "";
+  let storefrontUrl = options.storefront || stored.storefrontUrl || DEFAULT_STOREFRONT_URL;
+  let adminUrl = options.admin || stored.adminUrl || DEFAULT_ADMIN_URL;
+  if ((!storeId || !token) && token) {
+    const stores = await fetchUserStores(normalizeUrl(apiUrl), token);
+    if (stores.length === 1) {
+      storeId = stores[0].id;
+      storefrontUrl = resolveStorefrontBaseUrl(stores[0], storefrontUrl);
+    }
+  }
+  if (!storeId || !token) {
+    if (isInteractive()) {
+      await runInteractiveLoginFlow({ apiUrl: options.api, currentStoreId: stored.storeId });
+      return;
+    }
+    throw new Error("Login required. Run `storify login` or set STORIFY_AUTH_TOKEN and STORIFY_STORE_ID.");
+  }
+  await writeStoredConfig({
+    apiUrl: normalizeUrl(apiUrl),
+    storeId: storeId.trim(),
+    token: token.trim(),
+    storefrontUrl: normalizeUrl(storefrontUrl),
+    adminUrl: normalizeUrl(adminUrl)
+  });
+  if (!isInteractive()) {
+    printHeading("Login saved");
+    printDivider();
+    printStep("Config file", getConfigFilePathForDisplay());
+    printStep("Store ID", storeId.trim());
+    printStep("Storefront", normalizeUrl(storefrontUrl));
+    printSuccess("Ready for `storify theme dev` and `storify theme upload`.");
+    console.log("");
+  }
+}
+
+// src/commands/status.ts
+import path3 from "path";
+import { promises as fs3 } from "fs";
+
+// src/lib/theme-root.ts
+import path2 from "path";
+import { promises as fs2 } from "fs";
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveThemeRoot(dirArg) {
+  let current = path2.resolve(dirArg || process.cwd());
+  while (true) {
+    const manifestPath = path2.join(current, "theme-manifest.json");
+    if (await fileExists(manifestPath)) {
+      return current;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      throw new Error("Could not find theme root. Run command inside theme directory (contains theme-manifest.json) or pass --dir.");
+    }
+    current = parent;
+  }
+}
+async function resolveRepoRoot(fromDir = process.cwd()) {
+  let current = path2.resolve(fromDir);
+  while (true) {
+    const gitPath = path2.join(current, ".git");
+    if (await fileExists(gitPath)) return current;
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      throw new Error("Could not find repository root (.git).");
+    }
+    current = parent;
+  }
+}
+
+// src/commands/status.ts
+async function fileExists2(filePath) {
+  try {
+    await fs3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runStatusCommand(options) {
+  printHeading("Environment status", "Current CLI configuration and theme context");
+  const configPath = getConfigFilePathForDisplay();
+  const stored = await readStoredConfig();
+  const hasConfig = Boolean(stored.storeId && stored.token);
+  printDivider();
+  printStep("Config file", configPath);
+  printStep("API URL", stored.apiUrl || "not set");
+  printStep("Store ID", stored.storeId || "not set");
+  printStep("Auth token", maskSecret(stored.token));
+  printStep("Storefront", stored.storefrontUrl || "not set");
+  printStep("Admin", stored.adminUrl || "not set");
+  console.log("");
+  if (hasConfig) {
+    printSuccess("Credentials found. Run `storify theme dev` for live storefront preview.");
+  } else {
+    printWarn("Credentials incomplete. Run `storify login` first.");
+  }
+  try {
+    const themeRoot = await resolveThemeRoot(options.dir);
+    const manifestPath = path3.join(themeRoot, "theme-manifest.json");
+    const manifestRaw = await fs3.readFile(manifestPath, "utf8");
+    const manifest = JSON.parse(manifestRaw);
+    const distExists = await fileExists2(path3.join(themeRoot, "dist", "theme-manifest.json"));
+    printDivider();
+    printStep("Theme root", themeRoot);
+    printStep("Theme name", manifest.name || "unknown");
+    printStep("Version", manifest.version || "unknown");
+    printStep("Build output", distExists ? "dist/ ready" : "not built yet");
+    console.log("");
+    printInfo(distExists ? "Run `storify theme pack` to create upload zip." : "Run `storify theme build` before packing.");
+  } catch {
+    console.log("");
+    printWarn("No theme found in current directory. cd into a theme folder or pass --dir.");
+  }
+  console.log("");
+}
+
+// src/commands/theme/build.ts
+import path5 from "path";
+import { promises as fs5 } from "fs";
+import { execa } from "execa";
+
+// src/lib/build-manifest.ts
+import path4 from "path";
+import { promises as fs4 } from "fs";
+function readJson(filePath) {
+  return fs4.readFile(filePath, "utf8").then((raw) => JSON.parse(raw));
+}
+function toCanonicalId(value) {
+  return String(value || "").trim().toLowerCase().replace(/-/g, "_");
+}
+function optionValue(option) {
+  if (option && typeof option === "object") {
+    return option.value;
+  }
+  return option;
+}
+function defaultForField(field) {
+  if (field.default !== void 0) return field.default;
+  switch (field.type) {
+    case "repeater":
+      return Array.isArray(field.default) ? field.default : [];
+    case "menu":
+      return "";
+    case "select": {
+      const options = Array.isArray(field.options) ? field.options : [];
+      return options[0] !== void 0 ? optionValue(options[0]) : "";
+    }
+    default:
+      return "";
+  }
+}
+function normalizeFieldValue(value, field = {}, fieldPath = "") {
+  const type = field.type;
+  if (type === "repeater") {
+    if (!Array.isArray(value)) return [];
+    const itemSchema = field.fields || {};
+    return value.map((item, index) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) {
+        throw new Error(`Invalid repeater item at "${fieldPath}[${index}]"`);
+      }
+      return normalizeContentBySchema(item, itemSchema, `${fieldPath}[${index}]`);
+    });
+  }
+  if (type === "menu") {
+    if (Array.isArray(value) || typeof value === "string") return value;
+    return "";
+  }
+  if (type === "select") {
+    const options = Array.isArray(field.options) ? field.options.map(optionValue) : [];
+    const selected = value ?? defaultForField(field);
+    const nextValue = String(selected ?? "");
+    if (options.length > 0 && !options.includes(nextValue)) {
+      throw new Error(`Invalid select value "${nextValue}" at "${fieldPath}"`);
+    }
+    return nextValue;
+  }
+  if (type === "color" || type === "text" || type === "textarea" || type === "image") {
+    const raw2 = value ?? defaultForField(field);
+    return raw2 === null || raw2 === void 0 ? "" : String(raw2);
+  }
+  if (type === "link") {
+    const raw2 = value ?? defaultForField(field);
+    if (raw2 === null || raw2 === void 0) return "";
+    if (typeof raw2 === "string" || typeof raw2 === "object") return raw2;
+    return String(raw2);
+  }
+  const raw = value ?? defaultForField(field);
+  return raw === void 0 ? "" : raw;
+}
+function normalizeContentBySchema(content = {}, schema = {}, pathPrefix = "", section = null) {
+  const output = {};
+  const contentObj = content && typeof content === "object" && !Array.isArray(content) ? content : {};
+  for (const key of Object.keys(contentObj)) {
+    if (key === "blocks" && section) continue;
+    if (!(key in schema)) {
+      throw new Error(`Unknown key "${key}" in content "${pathPrefix || "root"}"`);
+    }
+  }
+  for (const [key, field] of Object.entries(schema)) {
+    const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+    output[key] = normalizeFieldValue(contentObj[key], field, fieldPath);
+  }
+  if (section && Array.isArray(contentObj.blocks)) {
+    const blockDefinitions = Array.isArray(section.blocks) ? section.blocks : [];
+    output.blocks = contentObj.blocks.map((block, index) => {
+      if (!block || typeof block !== "object" || Array.isArray(block)) {
+        throw new Error(`Invalid block at "${pathPrefix}.blocks[${index}]"`);
+      }
+      const type = String(block.type || "");
+      const blockDef = blockDefinitions.find((candidate) => candidate.type === type);
+      if (!blockDef) {
+        throw new Error(`Unknown block type "${type}" at "${pathPrefix}.blocks[${index}]"`);
+      }
+      return {
+        type,
+        content: normalizeContentBySchema(
+          block.content || {},
+          blockDef.schema || {},
+          `${pathPrefix}.blocks[${index}]`
+        )
+      };
+    });
+  }
+  return output;
+}
+async function syncEntryFromDistIndex(themeRoot, manifest) {
+  const indexHtmlPath = path4.join(themeRoot, "dist", "index.html");
+  try {
+    const indexHtml = await fs4.readFile(indexHtmlPath, "utf8");
+    const scriptMatch = indexHtml.match(/<script[^>]*src="\.\/(assets\/[^"]+\.js)"/);
+    if (scriptMatch) {
+      manifest.entry = scriptMatch[1];
+    }
+  } catch {
+  }
+}
+async function buildThemeManifest(options) {
+  const { themeRoot, writeToDist, syncEntryFromDist } = options;
+  const manifestPath = path4.join(themeRoot, "theme-manifest.json");
+  const pagesDir = path4.join(themeRoot, "config", "pages");
+  const distDir = path4.join(themeRoot, "dist");
+  const outputPath = path4.join(distDir, "theme-manifest.json");
+  const manifest = await readJson(manifestPath);
+  if (!Array.isArray(manifest.sections) || !Array.isArray(manifest.pages)) {
+    throw new Error('Manifest must contain "sections" and "pages" arrays.');
+  }
+  const sectionById = /* @__PURE__ */ new Map();
+  manifest.sections = manifest.sections.map((section) => {
+    const sectionId = toCanonicalId(section.id);
+    if (!sectionId) throw new Error("Section id cannot be empty.");
+    if (sectionById.has(sectionId)) throw new Error(`Duplicate section id "${sectionId}".`);
+    const contentSchema = section.contentSchema || {};
+    const sectionDefaults = normalizeContentBySchema(
+      section.defaultContent || {},
+      contentSchema,
+      `section:${sectionId}`,
+      section
+    );
+    const normalizedSection = {
+      ...section,
+      id: sectionId,
+      contentSchema,
+      defaultContent: sectionDefaults,
+      settingsSchema: contentSchema,
+      fields: contentSchema
+    };
+    sectionById.set(sectionId, normalizedSection);
+    return normalizedSection;
+  });
+  manifest.pages = manifest.pages.map((page) => {
+    const pageId = toCanonicalId(page.id);
+    if (!pageId) throw new Error("Page id cannot be empty.");
+    if (!Array.isArray(page.layout)) throw new Error(`Page "${pageId}" layout must be an array.`);
+    const layout = page.layout.map((entry) => {
+      const sectionId = toCanonicalId(entry.sectionId);
+      if (!sectionById.has(sectionId)) {
+        throw new Error(`Page "${pageId}" references unknown sectionId "${entry.sectionId}".`);
+      }
+      if (!entry.handle || typeof entry.handle !== "string") {
+        throw new Error(`Page "${pageId}" has layout entry without a valid handle.`);
+      }
+      return { ...entry, sectionId };
+    });
+    return { ...page, id: pageId, layout };
+  });
+  if (manifest.themeSettingsSchema && !manifest.settingsSchema) {
+    manifest.settingsSchema = manifest.themeSettingsSchema;
+  }
+  try {
+    const pageFiles = (await fs4.readdir(pagesDir)).filter((fileName) => fileName.endsWith(".json")).sort();
+    for (const fileName of pageFiles) {
+      const pageId = toCanonicalId(path4.basename(fileName, ".json"));
+      const page = manifest.pages.find((item) => item.id === pageId);
+      if (!page) {
+        throw new Error(`Orphan page defaults file "${fileName}" has no matching manifest page id.`);
+      }
+      const rawPageDefaults = await readJson(path4.join(pagesDir, fileName));
+      const layoutByHandle = new Map(page.layout.map((item) => [item.handle, item]));
+      for (const handle of Object.keys(rawPageDefaults || {})) {
+        const layoutEntry = layoutByHandle.get(handle);
+        if (!layoutEntry) {
+          throw new Error(`Invalid handle "${handle}" in config/pages/${fileName}.`);
+        }
+        const section = sectionById.get(layoutEntry.sectionId);
+        normalizeContentBySchema(
+          rawPageDefaults[handle] || {},
+          section.contentSchema || {},
+          `${pageId}.${handle}`,
+          section
+        );
+      }
+    }
+  } catch (error) {
+    const code = error?.code;
+    if (code !== "ENOENT") throw error;
+  }
+  delete manifest.themeSettings;
+  delete manifest.settings;
+  if (syncEntryFromDist) {
+    await syncEntryFromDistIndex(themeRoot, manifest);
+  }
+  const serialized = JSON.stringify(manifest);
+  const sizeInBytes = Buffer.byteLength(serialized, "utf8");
+  if (sizeInBytes > MAX_MANIFEST_BYTES) {
+    throw new Error(`theme-manifest.json is too large (${sizeInBytes} bytes). Limit is ${MAX_MANIFEST_BYTES} bytes.`);
+  }
+  if (!writeToDist) {
+    return { sizeInBytes };
+  }
+  await fs4.mkdir(distDir, { recursive: true });
+  await fs4.writeFile(outputPath, serialized);
+  return { sizeInBytes, outputPath };
+}
+
+// src/commands/theme/build.ts
+async function copyConfigIfExists(themeRoot) {
+  const source = path5.join(themeRoot, "config");
+  const destination = path5.join(themeRoot, "dist", "config");
+  try {
+    await fs5.access(source);
+  } catch {
+    return;
+  }
+  await fs5.rm(destination, { recursive: true, force: true });
+  await fs5.cp(source, destination, { recursive: true });
+}
+async function runViteBuild(themeRoot, quiet) {
+  const viteBin = path5.join(themeRoot, "node_modules", "vite", "bin", "vite.js");
+  await execa("node", [viteBin, "build"], {
+    cwd: themeRoot,
+    stdio: quiet ? "pipe" : "inherit"
+  });
+}
+async function runBuildCommand(options) {
+  const themeRoot = await resolveThemeRoot(options.dir);
+  const quiet = Boolean(options.quiet);
+  if (!quiet) {
+    printHeading("Building theme", themeRoot);
+    printStep("Step 1/2", "Vite production build");
+  }
+  await runViteBuild(themeRoot, quiet);
+  const result = quiet ? await buildThemeManifest({
+    themeRoot,
+    writeToDist: true,
+    syncEntryFromDist: true,
+    quiet: true
+  }) : await withSpinner(
+    "Generating theme-manifest.json",
+    async () => buildThemeManifest({
+      themeRoot,
+      writeToDist: true,
+      syncEntryFromDist: true,
+      quiet: true
+    })
+  );
+  await copyConfigIfExists(themeRoot);
+  if (!quiet) {
+    printDivider();
+    printStep("Output", path5.join(themeRoot, "dist"));
+    printStep("Manifest", formatBytes(result.sizeInBytes));
+    printSuccess("Build completed.");
+    console.log("");
+  }
+}
+
+// src/commands/theme/dev.ts
+import path6 from "path";
+import { execa as execa3 } from "execa";
+
+// src/lib/dev-link.ts
+async function updateDevLink(auth, payload) {
+  const response = await fetch(`${auth.apiUrl}/theme/dev-link`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${auth.token}`,
+      "X-Store-Id": auth.storeId
+    },
+    body: JSON.stringify(payload)
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const message = (body && typeof body === "object" && "error" in body ? String(body.error) : "") || `Failed to update dev link (${response.status})`;
+    throw new Error(message);
+  }
+  return {
+    devThemeEnabled: body.devThemeEnabled === true,
+    devThemeBaseUrl: body.devThemeBaseUrl == null || body.devThemeBaseUrl === "" ? null : String(body.devThemeBaseUrl).trim(),
+    storefrontPreviewUrl: typeof body.storefrontPreviewUrl === "string" ? body.storefrontPreviewUrl : void 0,
+    devSessionId: typeof body.devSessionId === "string" ? body.devSessionId : void 0
+  };
+}
+
+// src/lib/port.ts
+import net from "net";
+function isPortFree(port, host) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, host);
+  });
+}
+async function findAvailablePort(preferred, host = "127.0.0.1") {
+  if (!Number.isInteger(preferred) || preferred <= 0) {
+    throw new Error("Invalid port.");
+  }
+  for (let port = preferred; port < preferred + 30; port++) {
+    if (await isPortFree(port, host)) return port;
+  }
+  throw new Error(`No free port found near ${preferred}. Close other dev servers or pass --port.`);
+}
+
+// src/lib/preview-urls.ts
+function buildPreviewUrls(auth, devBaseUrl, storefrontUrlOverride) {
+  const storefrontUrl = storefrontUrlOverride || `${auth.storefrontUrl.replace(/\/$/, "")}/${encodeURIComponent(auth.storeId)}/`;
+  return {
+    themeDirectUrl: `${devBaseUrl.replace(/\/$/, "")}/index.html?storeId=${encodeURIComponent(auth.storeId)}`,
+    storefrontUrl,
+    adminEditorUrl: `${auth.adminUrl.replace(/\/$/, "")}/${encodeURIComponent(auth.storeId)}/admin/theme/edit`
+  };
+}
+
+// src/lib/session.ts
+import * as p2 from "@clack/prompts";
+async function ensureAuthenticatedSession(options = {}) {
+  const stored = await readStoredConfig();
+  const hasCredentials = Boolean(stored.token?.trim() && stored.storeId?.trim());
+  const needsLogin = options.forceLogin || !hasCredentials;
+  if (needsLogin) {
+    if (!isInteractive()) {
+      throw new Error("Not logged in. Run `storify login` or set STORIFY_AUTH_TOKEN and STORIFY_STORE_ID.");
+    }
+    const session = await runInteractiveLoginFlow({
+      apiUrl: options.api,
+      currentStoreId: options.storeId || stored.storeId
+    });
+    return {
+      apiUrl: session.apiUrl,
+      token: session.token,
+      storeId: session.store.id,
+      storefrontUrl: session.storefrontUrl,
+      adminUrl: session.adminUrl,
+      store: session.store
+    };
+  }
+  const token = options.token || stored.token;
+  const apiUrl = (options.api || stored.apiUrl || DEFAULT_API_URL).replace(/\/+$/, "");
+  if (!options.token && !options.forceLogin) {
+    const valid = await verifyAuthToken(apiUrl, token);
+    if (!valid && isInteractive()) {
+      p2.log.warn("Session expired. Sign in again.");
+      const session = await runInteractiveLoginFlow({
+        apiUrl: options.api,
+        currentStoreId: options.storeId || stored.storeId
+      });
+      return {
+        apiUrl: session.apiUrl,
+        token: session.token,
+        storeId: session.store.id,
+        storefrontUrl: session.storefrontUrl,
+        adminUrl: session.adminUrl,
+        store: session.store
+      };
+    }
+    if (!valid) {
+      throw new Error("Saved auth token is invalid. Run `storify login` again.");
+    }
+  }
+  if (options.forceStorePick && isInteractive()) {
+    const stores = await fetchUserStores(apiUrl, token);
+    const store2 = await promptStoreSelection(stores, options.storeId || stored.storeId);
+    const storefrontUrl = resolveStorefrontBaseUrl(store2, stored.storefrontUrl);
+    await writeStoredConfig({
+      ...stored,
+      apiUrl,
+      token,
+      storeId: store2.id,
+      storefrontUrl
+    });
+    return {
+      ...await resolveAuthConfig({ ...options, api: apiUrl, storeId: store2.id, token }),
+      store: store2
+    };
+  }
+  const auth = await resolveAuthConfig(options);
+  let store;
+  try {
+    const stores = await fetchUserStores(auth.apiUrl, auth.token);
+    store = stores.find((s) => s.id === auth.storeId);
+  } catch {
+  }
+  return { ...auth, store };
+}
+function formatLivePreviewUrl(auth, devSessionId, store) {
+  const base = resolveStorefrontBaseUrl(store, auth.storefrontUrl, {
+    preferLocal: isLocalHostUrl(auth.apiUrl) || isLocalHostUrl(auth.storefrontUrl)
+  });
+  return buildStorefrontEntryUrl(base, auth.storeId, devSessionId);
+}
+
+// src/lib/tunnel.ts
+import { execa as execa2 } from "execa";
+
+// src/lib/wait-for-dev-server.ts
+async function waitForHttpReachable(baseUrl, timeoutMs = 45e3, acceptResponse) {
+  const url = baseUrl.replace(/\/+$/, "/");
+  const deadline = Date.now() + timeoutMs;
+  const isAccepted = acceptResponse ?? ((response) => response.ok);
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(url, { signal: AbortSignal.timeout(2e3) });
+      if (isAccepted(response)) return;
+    } catch {
+    }
+    await new Promise((resolve) => setTimeout(resolve, 300));
+  }
+  throw new Error(`Timed out waiting for HTTP endpoint at ${url}`);
+}
+async function waitForDevServer(baseUrl, timeoutMs = 45e3) {
+  return waitForHttpReachable(baseUrl, timeoutMs);
+}
+
+// src/lib/tunnel.ts
+async function startCloudflaredTunnel(localUrl) {
+  const child = execa2("cloudflared", ["tunnel", "--url", localUrl], {
+    all: true,
+    reject: false
+  });
+  const url = await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("Timed out while waiting for cloudflared public URL."));
+    }, 2e4);
+    const onData = (chunk) => {
+      const match = chunk.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/i);
+      if (match) {
+        clearTimeout(timeout);
+        resolve(match[0]);
+      }
+    };
+    child.all?.on("data", (buffer) => onData(String(buffer)));
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (code && code !== 0) {
+        clearTimeout(timeout);
+        reject(new Error(`cloudflared exited early with code ${code}`));
+      }
+    });
+  });
+  await waitForHttpReachable(
+    url,
+    3e4,
+    (response) => response.status >= 200 && response.status < 500
+  );
+  return { url, process: child };
+}
+
+// src/commands/theme/dev.ts
+function toPort(value) {
+  const parsed = Number(value || 3e3);
+  if (!Number.isInteger(parsed) || parsed <= 0) throw new Error("Invalid port.");
+  return parsed;
+}
+async function openInBrowser(url) {
+  const platform = process.platform;
+  if (platform === "linux") {
+    await execa3("xdg-open", [url], { detached: true, stdio: "ignore" });
+  } else if (platform === "darwin") {
+    await execa3("open", [url], { detached: true, stdio: "ignore" });
+  } else if (platform === "win32") {
+    await execa3("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" });
+  }
+}
+async function runDevCommand(options) {
+  const themeRoot = await resolveThemeRoot(options.dir);
+  const preferredPort = toPort(options.port);
+  const shouldLinkStore = options.linkStore !== false;
+  const shouldUnlinkOnExit = options.unlinkOnExit !== false;
+  printHeading("Theme preview", themeRoot);
+  const session = await ensureAuthenticatedSession({
+    api: options.api,
+    storeId: options.storeId,
+    token: options.token
+  });
+  const auth = { ...session };
+  const useLocalDev = shouldUseLocalDev({
+    local: options.local,
+    remote: options.remote,
+    apiUrl: auth.apiUrl,
+    storefrontUrl: auth.storefrontUrl
+  });
+  if (useLocalDev) {
+    auth.storefrontUrl = localStorefrontBaseUrl(auth.storefrontUrl);
+  }
+  const port = await findAvailablePort(preferredPort);
+  const localUrl = `http://localhost:${port}`;
+  const shouldUseTunnel = !useLocalDev && options.tunnel !== false;
+  if (port !== preferredPort) {
+    printWarn(`Port ${preferredPort} was busy. Using ${port} instead.`);
+  }
+  let tunnelProcess = null;
+  let linkedDevUrl = null;
+  let liveStorefrontUrl = null;
+  const viteBin = path6.join(themeRoot, "node_modules", "vite", "bin", "vite.js");
+  const viteArgs = [viteBin, "--host", "0.0.0.0", "--port", String(port), "--strictPort"];
+  const viteEnv = { ...process.env };
+  viteEnv.VITE_DEV_STORE_ID = auth.storeId;
+  let viteProcess = null;
+  const teardown = async () => {
+    if (tunnelProcess) {
+      tunnelProcess.kill("SIGTERM");
+    }
+    if (viteProcess) {
+      viteProcess.kill("SIGTERM");
+    }
+    if (shouldLinkStore && shouldUnlinkOnExit) {
+      try {
+        await updateDevLink(auth, { devThemeEnabled: false, devThemeBaseUrl: null });
+        printSuccess("Dev link disabled.");
+      } catch (error) {
+        printWarn(`Failed to disable dev link: ${error.message}`);
+      }
+    }
+  };
+  let tearingDown = false;
+  const handleExit = async () => {
+    if (tearingDown) return;
+    tearingDown = true;
+    await teardown();
+  };
+  process.on("SIGINT", async () => {
+    await handleExit();
+    process.exit(130);
+  });
+  process.on("SIGTERM", async () => {
+    await handleExit();
+    process.exit(143);
+  });
+  const viteSpinner = createSpinner(`Starting Vite on ${localUrl}`);
+  viteSpinner.start();
+  viteProcess = execa3("node", viteArgs, {
+    cwd: themeRoot,
+    env: viteEnv,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  viteProcess.stdout?.pipe(process.stdout);
+  viteProcess.stderr?.pipe(process.stderr);
+  try {
+    await waitForDevServer(localUrl);
+    viteSpinner.succeed(`Vite ready at ${localUrl}`);
+  } catch (error) {
+    viteSpinner.fail("Vite failed to start");
+    viteProcess.kill("SIGTERM");
+    throw error;
+  }
+  if (shouldLinkStore) {
+    if (useLocalDev) {
+      linkedDevUrl = localUrl;
+      printStep("Mode", "Localhost (storefront + theme on your machine)");
+    } else if (options.publicUrl) {
+      linkedDevUrl = options.publicUrl.replace(/\/+$/, "");
+    } else if (shouldUseTunnel) {
+      const tunnelSpinner = createSpinner("Creating public tunnel for theme assets");
+      tunnelSpinner.start();
+      try {
+        const tunnel = await startCloudflaredTunnel(localUrl);
+        linkedDevUrl = tunnel.url.replace(/\/+$/, "");
+        tunnelProcess = tunnel.process;
+        tunnelSpinner.succeed(`Public theme URL: ${linkedDevUrl}`);
+      } catch (error) {
+        tunnelSpinner.warn(`Tunnel unavailable (${error.message})`);
+        linkedDevUrl = localUrl;
+        printWarn("Storefront preview needs a public URL. Use --local or install cloudflared.");
+      }
+    } else {
+      linkedDevUrl = localUrl;
+    }
+    const devLinkResult = await withSpinner(
+      "Linking dev theme to your store on Storify",
+      async () => updateDevLink(auth, { devThemeEnabled: true, devThemeBaseUrl: linkedDevUrl })
+    );
+    liveStorefrontUrl = (useLocalDev ? formatLivePreviewUrl(auth, devLinkResult.devSessionId, session.store) : devLinkResult.storefrontPreviewUrl) || formatLivePreviewUrl(auth, devLinkResult.devSessionId, session.store);
+    const urls = buildPreviewUrls(auth, linkedDevUrl, liveStorefrontUrl);
+    printPreviewPanel("Live preview", [
+      { label: "Storefront", value: urls.storefrontUrl },
+      { label: "Theme (Vite)", value: linkedDevUrl },
+      { label: "Theme direct", value: urls.themeDirectUrl },
+      { label: "Admin editor", value: urls.adminEditorUrl }
+    ]);
+    if (useLocalDev) {
+      printHint(`Storefront must be running at ${DEFAULT_STOREFRONT_URL.replace(/\/+$/, "")}`);
+    } else {
+      printHint("Open the storefront link to see your theme with real store data.");
+    }
+    printHint("Press Ctrl+C to stop and disable dev link.");
+  } else {
+    printStep("Local URL", localUrl);
+    printStep("Store ID", auth.storeId);
+    printHint("Run without --no-link-store to preview on the storefront.");
+    console.log("");
+  }
+  const openTarget = options.openStorefront && liveStorefrontUrl ? liveStorefrontUrl : options.open ? localUrl : useLocalDev && shouldLinkStore && liveStorefrontUrl ? liveStorefrontUrl : null;
+  if (openTarget) {
+    await openInBrowser(openTarget);
+  }
+  printSuccess("Waiting for file changes...");
+  console.log("");
+  try {
+    await viteProcess;
+  } finally {
+    await handleExit();
+  }
+}
+
+// src/commands/theme/new.ts
+import path7 from "path";
+import { promises as fs6 } from "fs";
+import { execa as execa4 } from "execa";
+var EXCLUDED = /* @__PURE__ */ new Set(["node_modules", "dist", ".git"]);
+async function copyDirectory(source, destination) {
+  await fs6.mkdir(destination, { recursive: true });
+  const entries = await fs6.readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    if (EXCLUDED.has(entry.name) || entry.name.endsWith(".zip")) continue;
+    const sourcePath = path7.join(source, entry.name);
+    const destinationPath = path7.join(destination, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(sourcePath, destinationPath);
+    } else {
+      await fs6.copyFile(sourcePath, destinationPath);
+    }
+  }
+}
+function titleCase(value) {
+  return value.split(/[-_\s]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+async function runNewCommand(name, options) {
+  const cleanName = name.trim();
+  if (!cleanName) throw new Error("Theme name is required.");
+  const repoRoot = await resolveRepoRoot();
+  const source = path7.join(repoRoot, "themes", "storify-templatesrap");
+  const baseDir = options.dir ? path7.resolve(options.dir) : path7.join(repoRoot, "themes");
+  const destination = path7.join(baseDir, cleanName);
+  printHeading("Creating theme", cleanName);
+  try {
+    await fs6.access(destination);
+    throw new Error(`Target directory already exists: ${destination}`);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  await withSpinner("Copying starter template", async () => {
+    await copyDirectory(source, destination);
+  });
+  const manifestPath = path7.join(destination, "theme-manifest.json");
+  const packagePath = path7.join(destination, "package.json");
+  const manifest = JSON.parse(await fs6.readFile(manifestPath, "utf8"));
+  manifest.name = titleCase(cleanName);
+  manifest.version = "1.0.0";
+  await fs6.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+  const packageJson2 = JSON.parse(await fs6.readFile(packagePath, "utf8"));
+  packageJson2.name = `@storify/theme-${cleanName}`;
+  await fs6.writeFile(packagePath, `${JSON.stringify(packageJson2, null, 2)}
+`);
+  await withSpinner("Installing dependencies", async () => {
+    await execa4("npm", ["install"], { cwd: destination, stdio: "pipe" });
+  });
+  printDivider();
+  printStep("Theme path", destination);
+  printStep("Package", packageJson2.name);
+  printSuccess("Theme scaffold created.");
+  printCommandExample("Start dev", `cd ${destination} && storify theme dev`);
+  console.log("");
+}
+
+// src/commands/theme/pack.ts
+import path9 from "path";
+import { promises as fs8 } from "fs";
+
+// src/lib/zip-pack.ts
+import path8 from "path";
+import { promises as fs7 } from "fs";
+import archiver from "archiver";
+async function assertFileExists(filePath) {
+  try {
+    await fs7.access(filePath);
+  } catch {
+    throw new Error(`Missing required file: ${filePath}`);
+  }
+}
+async function collectFiles(root, current = root) {
+  const entries = await fs7.readdir(current, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const absPath = path8.join(current, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectFiles(root, absPath);
+      files.push(...nested);
+      continue;
+    }
+    files.push(path8.relative(root, absPath));
+  }
+  return files;
+}
+function sanitizeRelativeZipPath(relPath) {
+  return relPath.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+async function packDist(themeRoot, outputZipPath) {
+  const distPath = path8.join(themeRoot, "dist");
+  await assertFileExists(path8.join(distPath, "theme-manifest.json"));
+  await assertFileExists(path8.join(distPath, "index.html"));
+  const files = await collectFiles(distPath);
+  if (files.length === 0) {
+    throw new Error("dist/ is empty. Run `storify theme build` first.");
+  }
+  let hasManifestAtRoot = false;
+  for (const relPath of files) {
+    const safe = sanitizeRelativeZipPath(relPath);
+    if (safe.includes("..")) {
+      throw new Error(`Unsafe path inside dist: ${relPath}`);
+    }
+    if (safe === "theme-manifest.json") {
+      hasManifestAtRoot = true;
+    }
+    const abs = path8.join(distPath, relPath);
+    const stat2 = await fs7.stat(abs);
+    if (stat2.size > MAX_SINGLE_FILE_BYTES) {
+      throw new Error(`File ${safe} exceeds ${Math.floor(MAX_SINGLE_FILE_BYTES / (1024 * 1024))} MB.`);
+    }
+  }
+  if (!hasManifestAtRoot) {
+    throw new Error("dist must contain theme-manifest.json at root.");
+  }
+  await fs7.mkdir(path8.dirname(outputZipPath), { recursive: true });
+  await fs7.rm(outputZipPath, { force: true });
+  const outputHandle = await fs7.open(outputZipPath, "w");
+  const outputStream = outputHandle.createWriteStream();
+  const archive = archiver("zip", { zlib: { level: 9 } });
+  const donePromise = new Promise((resolve, reject) => {
+    outputStream.on("close", resolve);
+    outputStream.on("error", reject);
+    archive.on("error", reject);
+  });
+  archive.pipe(outputStream);
+  for (const relPath of files) {
+    if (relPath.endsWith(".DS_Store")) continue;
+    archive.file(path8.join(distPath, relPath), { name: sanitizeRelativeZipPath(relPath) });
+  }
+  await archive.finalize();
+  await donePromise;
+  await outputHandle.close();
+  const stat = await fs7.stat(outputZipPath);
+  if (stat.size > MAX_ZIP_BYTES) {
+    throw new Error(`Theme zip must be under ${Math.floor(MAX_ZIP_BYTES / (1024 * 1024))} MB.`);
+  }
+  return { zipPath: outputZipPath, zipSize: stat.size, fileCount: files.length };
+}
+
+// src/commands/theme/pack.ts
+async function exists(filePath) {
+  try {
+    await fs8.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function toSafeSlug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function runPackCommand(options) {
+  const themeRoot = await resolveThemeRoot(options.dir);
+  if (!options.quiet) {
+    printHeading("Packaging theme", themeRoot);
+  }
+  const distManifestPath = path9.join(themeRoot, "dist", "theme-manifest.json");
+  if (options.force || !await exists(distManifestPath)) {
+    await runBuildCommand({ dir: themeRoot, quiet: true });
+  }
+  const manifest = JSON.parse(await fs8.readFile(path9.join(themeRoot, "theme-manifest.json"), "utf8"));
+  const zipName = options.out || `${toSafeSlug(manifest.name || path9.basename(themeRoot) || "storify-theme")}-theme.zip`;
+  const zipPath = path9.isAbsolute(zipName) ? zipName : path9.join(themeRoot, zipName);
+  const packed = options.quiet ? await packDist(themeRoot, zipPath) : await withSpinner("Creating upload zip", async () => packDist(themeRoot, zipPath));
+  if (!options.quiet) {
+    printDivider();
+    printStep("Archive", packed.zipPath);
+    printStep("Size", formatBytes(packed.zipSize));
+    printStep("Files", String(packed.fileCount));
+    printSuccess("Theme package is ready.");
+    printHint("Upload with `storify theme upload` or from Admin panel.");
+    console.log("");
+  }
+  return packed.zipPath;
+}
+
+// src/lib/upload-api.ts
+import { promises as fs9 } from "fs";
+async function uploadThemeZip(auth, zipPath, updateThemeId) {
+  const payload = await fs9.readFile(zipPath);
+  const form = new FormData();
+  form.append("file", new Blob([payload], { type: "application/zip" }), "theme.zip");
+  const endpoint = updateThemeId ? `${auth.apiUrl}/uploaded-themes/${encodeURIComponent(updateThemeId)}/update-dist` : `${auth.apiUrl}/uploaded-themes/upload`;
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${auth.token}`,
+      "X-Store-Id": auth.storeId
+    },
+    body: form
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const message = (body && typeof body === "object" && "error" in body ? String(body.error) : "") || `Upload failed (${response.status})`;
+    throw new Error(message);
+  }
+  return body;
+}
+
+// src/commands/theme/upload.ts
+async function runUploadCommand(options) {
+  const themeRoot = await resolveThemeRoot(options.dir);
+  const auth = await resolveAuthConfig({
+    api: options.api,
+    storeId: options.storeId,
+    token: options.token
+  });
+  printHeading("Uploading theme", themeRoot);
+  const zipPath = options.zip || await withSpinner(
+    "Building upload package",
+    async () => runPackCommand({ dir: themeRoot, quiet: true })
+  );
+  const result = await withSpinner(
+    "Uploading zip to Storify API",
+    async () => uploadThemeZip(auth, zipPath, options.updateThemeId)
+  );
+  printDivider();
+  if (options.updateThemeId) {
+    printStep("Theme ID", options.updateThemeId);
+    printSuccess("Theme dist updated successfully.");
+  } else {
+    printStep("Theme ID", result?.id || "unknown");
+    printStep("Name", result?.name || "unknown");
+    if (result?.baseUrl) printStep("Base URL", result.baseUrl);
+    printSuccess("Theme uploaded successfully.");
+  }
+  printHint("Activate the theme from Admin panel if needed.");
+  console.log("");
+}
+
+// src/commands/theme/validate.ts
+import path11 from "path";
+import { promises as fs11 } from "fs";
+
+// src/lib/manifest-zod.ts
+import { z } from "zod";
+var MAX_SECTIONS = 100;
+var editorFieldSchema = z.object({
+  type: z.string().min(1),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  group: z.string().min(1).optional(),
+  required: z.boolean().optional(),
+  localizable: z.boolean().optional(),
+  default: z.unknown().optional()
+}).passthrough();
+var themePageLayoutItemSchema = z.object({
+  sectionId: z.string().min(1),
+  handle: z.string().min(1),
+  defaultEnabled: z.boolean().optional()
+});
+var themePageDefinitionSchema = z.object({
+  id: z.string().min(1),
+  type: z.string().min(1),
+  path: z.string().min(1),
+  layout: z.array(themePageLayoutItemSchema).min(0).max(50),
+  seoSchema: z.record(z.string(), editorFieldSchema).optional()
+});
+var themeManifestSectionSchema = z.object({
+  id: z.string().min(1),
+  name: z.string(),
+  component: z.string().min(1),
+  order: z.number().int().nonnegative().optional(),
+  group: z.enum(["header_group", "template_group", "overlay_group", "footer_group"]).optional(),
+  allowedPages: z.array(z.string().min(1)).optional(),
+  contentSchema: z.record(z.string(), editorFieldSchema).optional(),
+  defaultContent: z.record(z.string(), z.unknown()).optional()
+});
+var themeManifestDSLSchema = z.object({
+  name: z.string().min(1).transform((s) => s.trim()),
+  version: z.string().min(1).transform((s) => s.trim()),
+  entry: z.string().min(1).transform((s) => s.trim()),
+  sections: z.array(themeManifestSectionSchema).min(1).max(MAX_SECTIONS),
+  pages: z.array(themePageDefinitionSchema).optional(),
+  settingsSchema: z.record(z.string(), z.unknown()).optional(),
+  themeSettingsSchema: z.record(z.string(), editorFieldSchema).optional(),
+  themeSettingsGroups: z.array(z.object({ id: z.string().min(1), label: z.string().min(1), description: z.string().optional(), order: z.number().int().optional() })).optional(),
+  manifestVersion: z.number().int().nonnegative().optional(),
+  languages: z.array(z.string().min(1)).optional(),
+  assets: z.record(z.string(), z.string().min(1)).optional()
+});
+function validateThemeManifestDSL(obj) {
+  const result = themeManifestDSLSchema.safeParse(obj);
+  if (result.success) {
+    return { ok: true, manifest: result.data };
+  }
+  const first = result.error.issues[0];
+  const path13 = first?.path?.length ? first.path.join(".") : "manifest";
+  return { ok: false, error: `${path13}: ${first?.message ?? result.error.message}` };
+}
+function validateThemeManifestDSLReferences(manifest) {
+  const sectionIds = new Set(manifest.sections.map((s) => s.id));
+  if (!manifest.pages) return { ok: true };
+  for (const page of manifest.pages) {
+    for (const item of page.layout) {
+      if (!sectionIds.has(item.sectionId)) {
+        return { ok: false, error: `Page "${page.id}" layout references unknown section "${item.sectionId}"` };
+      }
+    }
+  }
+  return { ok: true };
+}
+
+// src/lib/section-map.ts
+import path10 from "path";
+import { promises as fs10 } from "fs";
+function parseSectionMapKeys(sectionRenderer) {
+  const start = sectionRenderer.indexOf("const SECTION_MAP");
+  if (start < 0) {
+    throw new Error("SECTION_MAP not found in src/SectionRenderer.tsx");
+  }
+  const eqBrace = sectionRenderer.indexOf("= {", start);
+  const open = eqBrace >= 0 ? eqBrace + 2 : sectionRenderer.indexOf("{", start);
+  let depth = 0;
+  let end = -1;
+  for (let i = open; i < sectionRenderer.length; i += 1) {
+    const ch = sectionRenderer[i];
+    if (ch === "{") depth += 1;
+    if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end < 0) {
+    throw new Error("Could not parse SECTION_MAP block");
+  }
+  const mapBody = sectionRenderer.slice(open + 1, end);
+  return new Set([...mapBody.matchAll(/^\s*([A-Z][A-Z0-9_]*)\s*:/gm)].map((m) => m[1]));
+}
+async function validateManifestSectionMap(themeRoot) {
+  const manifestPath = path10.join(themeRoot, "theme-manifest.json");
+  const sectionRendererPath = path10.join(themeRoot, "src", "SectionRenderer.tsx");
+  const [manifestRaw, sectionRenderer] = await Promise.all([
+    fs10.readFile(manifestPath, "utf8"),
+    fs10.readFile(sectionRendererPath, "utf8")
+  ]);
+  const manifest = JSON.parse(manifestRaw);
+  const mapKeys = parseSectionMapKeys(sectionRenderer);
+  const manifestComponents = (manifest.sections || []).map((s) => ({
+    id: String(s.id || ""),
+    component: String(s.component || "").trim().toUpperCase().replace(/-/g, "_")
+  })).filter((s) => Boolean(s.component));
+  const missing = manifestComponents.filter((s) => !mapKeys.has(s.component));
+  if (missing.length > 0) {
+    const message = missing.map((item) => `Manifest section "${item.id}" component "${item.component}" has no SECTION_MAP entry`).join("\n");
+    throw new Error(message);
+  }
+  return { sections: manifestComponents.length, mapKeys: mapKeys.size };
+}
+
+// src/commands/theme/validate.ts
+async function fileExists3(filePath) {
+  try {
+    await fs11.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runValidateCommand(options) {
+  const themeRoot = await resolveThemeRoot(options.dir);
+  printHeading("Validating theme", themeRoot);
+  const manifestPath = path11.join(themeRoot, "theme-manifest.json");
+  const manifestRaw = await fs11.readFile(manifestPath, "utf8");
+  const manifest = JSON.parse(manifestRaw);
+  let spinner2 = createSpinner("Checking manifest DSL");
+  spinner2.start();
+  const dslValidation = validateThemeManifestDSL(manifest);
+  if (!dslValidation.ok) {
+    spinner2.fail("Manifest DSL validation failed");
+    throw new Error(dslValidation.error);
+  }
+  spinner2.succeed("Manifest DSL is valid");
+  spinner2 = createSpinner("Checking page section references");
+  spinner2.start();
+  const refValidation = validateThemeManifestDSLReferences(dslValidation.manifest);
+  if (!refValidation.ok) {
+    spinner2.fail("Manifest references validation failed");
+    throw new Error(refValidation.error);
+  }
+  spinner2.succeed("Page layout references are valid");
+  const sectionRendererPath = path11.join(themeRoot, "src", "SectionRenderer.tsx");
+  if (await fileExists3(sectionRendererPath)) {
+    spinner2 = createSpinner("Matching SECTION_MAP components");
+    spinner2.start();
+    const sectionMapInfo = await validateManifestSectionMap(themeRoot);
+    spinner2.succeed(`SECTION_MAP matched (${sectionMapInfo.sections} sections, ${sectionMapInfo.mapKeys} keys)`);
+  } else {
+    printWarn("Skipped SECTION_MAP check (src/SectionRenderer.tsx not found).");
+  }
+  spinner2 = createSpinner("Validating config/pages defaults");
+  spinner2.start();
+  const dryRun = await buildThemeManifest({
+    themeRoot,
+    writeToDist: false,
+    syncEntryFromDist: false,
+    quiet: true
+  });
+  spinner2.succeed("Page defaults are consistent");
+  if (!dslValidation.manifest.entry || !dslValidation.manifest.entry.trim()) {
+    throw new Error("Manifest entry is required.");
+  }
+  const indexHtmlPath = path11.join(themeRoot, "index.html");
+  if (!await fileExists3(indexHtmlPath)) {
+    throw new Error("index.html is required at theme root.");
+  }
+  const uniqueSectionIds = new Set(dslValidation.manifest.sections.map((section) => section.id));
+  if (uniqueSectionIds.size !== dslValidation.manifest.sections.length) {
+    throw new Error("Duplicate section ids found in manifest.sections.");
+  }
+  printDivider();
+  printStep("Theme", dslValidation.manifest.name);
+  printStep("Version", dslValidation.manifest.version);
+  printStep("Sections", String(dslValidation.manifest.sections.length));
+  printStep("Manifest size", formatBytes(dryRun.sizeInBytes));
+  printSuccess("Theme is ready to build and pack.");
+  printInfo("Next: `storify theme pack`");
+  console.log("");
+}
+
+// src/lib/interactive.ts
+import * as p3 from "@clack/prompts";
+import pc2 from "picocolors";
+async function runInteractiveRoot(version2) {
+  if (!isInteractive()) {
+    printBanner(version2);
+    printQuickStart();
+    return;
+  }
+  p3.intro(`${brand.name} CLI ${pc2.dim(`v${version2}`)}`);
+  const action = await p3.select({
+    message: "What would you like to do?",
+    options: [
+      { value: "preview", label: "Start live theme preview", hint: "Login \u2192 pick store \u2192 storefront" },
+      { value: "validate", label: "Validate theme", hint: "Manifest + sections" },
+      { value: "build", label: "Build theme", hint: "dist/ output" },
+      { value: "pack", label: "Pack zip", hint: "Upload-ready archive" },
+      { value: "upload", label: "Upload theme", hint: "Send zip to Storify" },
+      { value: "new", label: "Create new theme", hint: "From starter template" },
+      { value: "login", label: "Sign in / switch store", hint: "Save credentials" },
+      { value: "status", label: "Check setup", hint: "Config + theme folder" },
+      { value: "help", label: "Show quick start", hint: "Common commands" }
+    ]
+  });
+  if (p3.isCancel(action)) {
+    p3.cancel("Cancelled.");
+    process.exit(0);
+  }
+  try {
+    switch (action) {
+      case "preview":
+        await runDevCommand({ linkStore: true, openStorefront: true, local: true });
+        break;
+      case "validate":
+        await runValidateCommand({});
+        break;
+      case "build":
+        await runBuildCommand({});
+        break;
+      case "pack":
+        await runPackCommand({});
+        break;
+      case "upload":
+        await runUploadCommand({});
+        break;
+      case "new": {
+        const name = await p3.text({
+          message: "Theme folder name",
+          placeholder: "my-theme",
+          validate: (value) => value?.trim() ? void 0 : "Name is required"
+        });
+        if (p3.isCancel(name)) {
+          p3.cancel("Cancelled.");
+          process.exit(0);
+        }
+        await runNewCommand(String(name).trim(), {});
+        break;
+      }
+      case "login":
+        await runLoginCommand({});
+        break;
+      case "status":
+        await runStatusCommand({});
+        break;
+      case "help":
+        printQuickStart();
+        p3.outro("Done.");
+        break;
+      default:
+        break;
+    }
+  } catch (error) {
+    p3.log.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+var __dirname = path12.dirname(fileURLToPath(import.meta.url));
+var packageJson = JSON.parse(readFileSync(path12.join(__dirname, "../package.json"), "utf8"));
+var version = packageJson.version || "0.0.0";
+var program = new Command();
+program.name("storify").description(`${brand.name} theme development CLI for storefront templates`).version(version, "-V, --version", "Show CLI version");
+program.command("login").description("Save API credentials to ~/.storify/config.json").option("--api <url>", "API base URL (e.g. http://localhost:3001/api)").option("--store-id <id>", "Store identifier").option("--token <token>", "Auth bearer token").option("--storefront <url>", "Storefront base URL").option("--admin <url>", "Admin base URL").action(async (options) => runLoginCommand(options));
+program.command("status").description("Show saved credentials and current theme context").option("--dir <path>", "Theme directory (default: current directory)").action(async (options) => runStatusCommand(options));
+var theme = program.command("theme").description("Develop, validate, build, pack, and upload Storify themes").addHelpText(
+  "after",
+  `
+Examples:
+  $ storify theme dev
+  $ storify theme dev --no-link-store
+  $ storify theme validate
+  $ storify theme pack
+  $ storify theme upload
+`
+);
+theme.command("dev").description("Run Vite dev server and preview theme on the live storefront").option("--dir <path>", "Theme directory (default: current directory)").option("--port <port>", "Dev server port", "3000").option("--store-id <id>", "Store ID for real data context").option("--api <url>", "API base URL").option("--token <token>", "Auth bearer token").option("--no-link-store", "Local Vite only (skip storefront preview)").option("--unlink-on-exit", "Disable dev link on process exit", true).option("--no-tunnel", "Do not try cloudflared tunnel").option("--local", "Use localhost storefront and theme (no tunnel)").option("--remote", "Use production storefront URL and cloudflared tunnel").option("--public-url <url>", "Public URL to use instead of opening a tunnel").option("--open", "Open local Vite URL in browser").option("--open-storefront", "Open live storefront preview in browser").action(async (options) => runDevCommand(options));
+theme.command("validate").alias("check").description("Validate theme manifest and section map").option("--dir <path>", "Theme directory (default: current directory)").action(async (options) => runValidateCommand(options));
+theme.command("build").description("Build theme dist and generated manifest").option("--dir <path>", "Theme directory (default: current directory)").action(async (options) => runBuildCommand(options));
+theme.command("pack").alias("zip").description("Create upload-ready zip from dist contents").option("--dir <path>", "Theme directory (default: current directory)").option("--out <zipPath>", "Output zip file path").option("--force", "Force rebuild before packaging").action(async (options) => {
+  await runPackCommand(options);
+});
+theme.command("new").description("Create a new theme from storify-templatesrap starter").argument("<name>", "Theme folder name").option("--dir <path>", "Base directory for new theme (default: repo themes/)").action(async (name, options) => runNewCommand(name, options));
+theme.command("upload").description("Upload a theme zip to /api/uploaded-themes").option("--dir <path>", "Theme directory (default: current directory)").option("--zip <path>", "Zip file path (if omitted, runs pack)").option("--api <url>", "API base URL override").option("--store-id <id>", "Store ID override").option("--token <token>", "Bearer token override").option("--update-theme-id <id>", "Use update-dist endpoint for an existing theme id").action(async (options) => runUploadCommand(options));
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    await runInteractiveRoot(version);
+    return;
+  }
+  await program.parseAsync(process.argv);
+}
+main().catch(handleCliError);