create-shopify-firebase-app 1.3.0 → 2.0.1

package/lib/index.js

@@ -1,12 +1,19 @@
 /**
- * create-shopify-firebase-app — CLI core
+ * create-shopify-firebase-app — CLI core (v2)
  *
- * Orchestrates the entire scaffolding flow:
- * 1. Collect project config (interactive prompts or CLI args)
- * 2. Scaffold files from templates
- * 3. Install dependencies
- * 4. Wire up Firebase + Shopify
- * 5. Initialize git
+ * Full-stack scaffolding for Shopify + Firebase apps.
+ *
+ * Flow:
+ * 1. App type selection (extension-only vs full-stack Firebase)
+ * 2. Language selection (TypeScript / JavaScript)
+ * 3. Project name + app name
+ * 4. Scaffold files (multi-page frontend + backend)
+ * 5. Firebase setup (login, create/select project, provision)
+ * 6. Shopify app creation (login, create/link app via CLI)
+ * 7. Configure URLs + credentials
+ * 8. Install dependencies + build
+ * 9. Git init
+ * 10. Ready to deploy!
  */
 
 import fs from "node:fs";
@@ -37,13 +44,20 @@ const c = {
 const ok = (msg) => console.log(`  ${c.green}✔${c.reset} ${msg}`);
 const warn = (msg) => console.log(`  ${c.yellow}⚠${c.reset} ${msg}`);
 const info = (msg) => console.log(`  ${c.cyan}ℹ${c.reset} ${msg}`);
+const fail = (msg) => console.log(`  ${c.red}✘${c.reset} ${msg}`);
 const section = (title) => {
   console.log();
   console.log(`  ${c.cyan}===${c.reset} ${c.bold}${title}${c.reset} ${c.cyan}===${c.reset}`);
   console.log();
 };
 
-// ─── Check if a CLI tool is available ────────────────────────────────────
+const onCancel = () => {
+  console.log("\n  Cancelled.\n");
+  process.exit(0);
+};
+
+// ─── Shell helpers ───────────────────────────────────────────────────────
+
 function hasCommand(cmd) {
   try {
     execSync(`${cmd} --version`, { stdio: "ignore" });
@@ -53,19 +67,12 @@ function hasCommand(cmd) {
   }
 }
 
-// ─── Run a command with live output ──────────────────────────────────────
 function exec(cmd, cwd) {
   return new Promise((resolve, reject) => {
-    const child = spawn(cmd, {
-      cwd,
-      shell: true,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
+    const child = spawn(cmd, { cwd, shell: true, stdio: ["ignore", "pipe", "pipe"] });
     let stderr = "";
-    child.stdout?.on("data", () => {}); // consume but don't print
+    child.stdout?.on("data", () => {});
     child.stderr?.on("data", (d) => (stderr += d.toString()));
-
     child.on("close", (code) => {
       if (code === 0) resolve();
       else reject(new Error(`Command failed: ${cmd}\n${stderr}`));
@@ -73,30 +80,16 @@ function exec(cmd, cwd) {
   });
 }
 
-// ─── Parse CLI arguments ─────────────────────────────────────────────────
-function parseArgs(argv) {
-  const args = {};
-  let projectName = null;
-
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg.startsWith("--")) {
-      const [key, val] = arg.slice(2).split("=");
-      args[key] = val ?? true;
-    } else if (arg.startsWith("-") && arg.length > 1) {
-      // Single-dash flags: -h, -v
-      for (const ch of arg.slice(1)) {
-        args[ch] = true;
-      }
-    } else if (!projectName) {
-      projectName = arg;
-    }
-  }
-
-  return { projectName, ...args };
+function execInteractive(cmd, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, { cwd, shell: true, stdio: "inherit" });
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Command exited with code ${code}`));
+    });
+  });
 }
 
-// ─── Open URL in browser (cross-platform) ───────────────────────────────
 function openBrowser(url) {
   const platform = process.platform;
   try {
@@ -108,7 +101,16 @@ function openBrowser(url) {
   }
 }
 
-// ─── List Firebase projects ──────────────────────────────────────────────
+function parseTomlField(tomlPath, field) {
+  try {
+    const content = fs.readFileSync(tomlPath, "utf8");
+    const match = content.match(new RegExp(`${field}\\s*=\\s*"([^"]+)"`));
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
 function listFirebaseProjects() {
   try {
     const output = execSync("firebase projects:list --json", {
@@ -128,88 +130,269 @@ function listFirebaseProjects() {
   return [];
 }
 
-// ─── Run an interactive command (user sees prompts) ─────────────────────
-function execInteractive(cmd, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(cmd, {
-      cwd,
-      shell: true,
-      stdio: "inherit",
-    });
-    child.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`Command exited with code ${code}`));
-    });
-  });
-}
-
-// ─── Check if logged into Shopify CLI ───────────────────────────────────
-function isShopifyLoggedIn() {
+async function createFirebaseProject(projectId, displayName) {
   try {
-    // `shopify app config link --help` doesn't need auth,
-    // but `shopify app info` does — use a quick check
-    const out = execSync("shopify auth login --help", {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    });
+    await exec(`firebase projects:create "${projectId}" --display-name "${displayName}"`);
     return true;
   } catch {
     return false;
   }
 }
 
-// ─── Parse TOML file for client_id ──────────────────────────────────────
-function parseTomlClientId(tomlPath) {
-  try {
-    const content = fs.readFileSync(tomlPath, "utf8");
-    const match = content.match(/client_id\s*=\s*"([^"]+)"/);
-    return match ? match[1] : null;
-  } catch {
-    return null;
+// ─── Parse CLI arguments ─────────────────────────────────────────────────
+function parseArgs(argv) {
+  const args = {};
+  let projectName = null;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const [key, val] = arg.slice(2).split("=");
+      args[key] = val ?? true;
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      for (const ch of arg.slice(1)) args[ch] = true;
+    } else if (!projectName) {
+      projectName = arg;
+    }
   }
+
+  return { projectName, ...args };
 }
 
-// ─── Create Firebase project ─────────────────────────────────────────────
-async function createFirebaseProject(projectId, displayName) {
-  try {
-    await exec(`firebase projects:create "${projectId}" --display-name "${displayName}"`);
-    return true;
-  } catch {
-    return false;
+// ─── File helpers ────────────────────────────────────────────────────────
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDirSync(srcPath, destPath);
+    else fs.copyFileSync(srcPath, destPath);
   }
 }
 
-// ─── Interactive prompts ─────────────────────────────────────────────────
-async function getConfig(args) {
-  // Check if running non-interactively
-  const isCI =
-    args["api-key"] && args["api-secret"] && args["project-id"];
+function countFiles(dir) {
+  let count = 0;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) count += countFiles(path.join(dir, entry.name));
+    else count++;
+  }
+  return count;
+}
 
-  if (isCI) {
-    return {
-      projectName: args.projectName || "my-shopify-app",
-      appName: args["app-name"] || args.projectName || "My Shopify App",
-      apiKey: args["api-key"],
-      apiSecret: args["api-secret"],
-      scopes: args.scopes || "read_products",
-      projectId: args["project-id"],
-      appUrl: `https://${args["project-id"]}.web.app`,
-    };
-  }
-
-  const onCancel = () => {
-    console.log("\n  Cancelled.\n");
-    process.exit(0);
+function substituteVars(filePath, vars) {
+  if (!fs.existsSync(filePath)) return;
+  let content = fs.readFileSync(filePath, "utf8");
+  for (const [key, val] of Object.entries(vars)) {
+    content = content.replaceAll(key, val);
+  }
+  fs.writeFileSync(filePath, content);
+}
+
+// ─── Scaffold ────────────────────────────────────────────────────────────
+function scaffold(outputDir, config) {
+  // 1. Copy shared files (firebase.json, firestore, gitignore, extensions)
+  copyDirSync(path.join(TEMPLATES_DIR, "shared"), outputDir);
+
+  // 2. Copy web frontend (multi-page with App Bridge + Polaris)
+  copyDirSync(path.join(TEMPLATES_DIR, "web"), path.join(outputDir, "web"));
+
+  // 3. Copy functions backend (TS or JS based on language choice)
+  const lang = config.language === "javascript" ? "js" : "ts";
+  copyDirSync(
+    path.join(TEMPLATES_DIR, lang, "functions"),
+    path.join(outputDir, "functions"),
+  );
+
+  // 4. Copy shopify.app.toml
+  fs.copyFileSync(
+    path.join(TEMPLATES_DIR, "shopify.app.toml"),
+    path.join(outputDir, "shopify.app.toml"),
+  );
+
+  // 5. Rename dotfiles (npm strips leading dots on publish)
+  const renames = [
+    ["gitignore", ".gitignore"],
+    ["env.example", ".env.example"],
+  ];
+  for (const [from, to] of renames) {
+    const src = path.join(outputDir, from);
+    const dest = path.join(outputDir, to);
+    if (fs.existsSync(src)) fs.renameSync(src, dest);
+  }
+
+  // 6. Variable substitution
+  const vars = {
+    "{{APP_NAME}}": config.appName,
+    "{{API_KEY}}": config.apiKey || "",
+    "{{API_SECRET}}": config.apiSecret || "",
+    "{{SCOPES}}": config.scopes,
+    "{{PROJECT_ID}}": config.projectId || "",
+    "{{APP_URL}}": config.appUrl || "",
+  };
+
+  const templateFiles = [
+    "shopify.app.toml",
+    "web/index.html",
+    "web/products.html",
+    "web/settings.html",
+    "web/polaris.html",
+  ];
+
+  for (const relPath of templateFiles) {
+    substituteVars(path.join(outputDir, relPath), vars);
+  }
+
+  // 7. Generate functions/.env
+  const envContent = [
+    `SHOPIFY_API_KEY=${config.apiKey || ""}`,
+    `SHOPIFY_API_SECRET=${config.apiSecret || ""}`,
+    `SCOPES=${config.scopes}`,
+    `APP_URL=${config.appUrl || ""}`,
+    "",
+  ].join("\n");
+  fs.writeFileSync(path.join(outputDir, "functions", ".env"), envContent);
+
+  // 8. Generate .firebaserc
+  if (config.projectId) {
+    const firebaserc = JSON.stringify(
+      { projects: { default: config.projectId } },
+      null,
+      2,
+    );
+    fs.writeFileSync(path.join(outputDir, ".firebaserc"), firebaserc + "\n");
+  }
+
+  // 9. Generate root package.json
+  const rootPkg = JSON.stringify(
+    { name: config.projectName, private: true },
+    null,
+    2,
+  );
+  fs.writeFileSync(path.join(outputDir, "package.json"), rootPkg + "\n");
+
+  return countFiles(outputDir);
+}
+
+// ─── Update credentials after Shopify app creation ───────────────────────
+function updateCredentials(outputDir, config) {
+  const vars = {
+    "{{API_KEY}}": config.apiKey || "",
+    "{{API_SECRET}}": config.apiSecret || "",
+    "{{APP_URL}}": config.appUrl || "",
   };
 
+  // Update shopify.app.toml
+  substituteVars(path.join(outputDir, "shopify.app.toml"), vars);
+
+  // Update functions/.env
+  const envContent = [
+    `SHOPIFY_API_KEY=${config.apiKey || ""}`,
+    `SHOPIFY_API_SECRET=${config.apiSecret || ""}`,
+    `SCOPES=${config.scopes}`,
+    `APP_URL=${config.appUrl || ""}`,
+    "",
+  ].join("\n");
+  fs.writeFileSync(path.join(outputDir, "functions", ".env"), envContent);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// ─── MAIN FLOW ───────────────────────────────────────────────────────────
+// ═══════════════════════════════════════════════════════════════════════════
+
+export async function run(argv) {
+  const args = parseArgs(argv);
+
+  // ── Handle flags ──────────────────────────────────────────────────
+  if (args.help || args.h) { printHelp(); return; }
+  if (args.version || args.v) {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+    console.log(pkg.version);
+    return;
+  }
+
+  // ── Handle --distribute ───────────────────────────────────────────
+  if (args.distribute) {
+    await distributeFlow();
+    return;
+  }
+
+  // ── CI / non-interactive mode ─────────────────────────────────────
+  const isCI = args["api-key"] && args["api-secret"] && args["project-id"];
+  if (isCI) {
+    await runCI(args);
+    return;
+  }
+
+  // ═══════════════════════════════════════════════════════════════════
+  // ── Interactive flow — guided project wizard ────
+  // ═══════════════════════════════════════════════════════════════════
+
   // ── Banner ────────────────────────────────────────────────────────
   console.log();
   console.log(`  ${c.green}${c.bold}🛍️  +  🔥${c.reset}  ${c.bold}create-shopify-firebase-app${c.reset}`);
-  console.log(`  ${c.dim}Serverless Shopify apps — free until you scale${c.reset}`);
+  console.log(`  ${c.dim}Build Shopify apps for free — serverless, zero-framework${c.reset}`);
+
+  // ═══════════════════════════════════════════════════════════════════
+  section("Choose Your Template");
+
+  const { appTemplate } = await prompts({
+    type: "select",
+    name: "appTemplate",
+    message: "What would you like to create?",
+    choices: [
+      {
+        title: `${c.bold}Shopify + Firebase app${c.reset} ${c.dim}(full-stack serverless)${c.reset}`,
+        description: "Dashboard, product search, settings, Polaris components — ready to deploy",
+        value: "firebase",
+      },
+      {
+        title: `Extension-only app ${c.dim}(Shopify CLI)${c.reset}`,
+        description: "Theme extensions, checkout extensions — no backend needed",
+        value: "extension",
+      },
+    ],
+  }, { onCancel });
+
+  // ── Extension-only: delegate to Shopify CLI ───────────────────────
+  if (appTemplate === "extension") {
+    console.log();
+    if (!hasCommand("shopify")) {
+      info("Installing Shopify CLI...");
+      try {
+        await exec("npm install -g @shopify/cli");
+        ok("Shopify CLI installed");
+      } catch {
+        fail("Could not install Shopify CLI");
+        info("Install manually: npm i -g @shopify/cli");
+        info("Then run: shopify app init");
+        return;
+      }
+    }
+    info("Launching Shopify CLI...");
+    console.log();
+    try {
+      await execInteractive("shopify app init");
+    } catch {
+      warn("Shopify CLI exited");
+    }
+    return;
+  }
 
   // ═══════════════════════════════════════════════════════════════════
-  section("App Configuration");
+  section("Project Setup");
 
+  // ── Language ──────────────────────────────────────────────────────
+  const { language } = await prompts({
+    type: "select",
+    name: "language",
+    message: "Language for Cloud Functions",
+    choices: [
+      { title: `TypeScript ${c.dim}(recommended)${c.reset}`, value: "typescript" },
+      { title: "JavaScript", value: "javascript" },
+    ],
+  }, { onCancel });
+
+  // ── Project name ──────────────────────────────────────────────────
   let projectName = args.projectName;
   if (!projectName) {
     const res = await prompts({
@@ -226,136 +409,15 @@ async function getConfig(args) {
     projectName = res.projectName;
   }
 
+  // ── App name ──────────────────────────────────────────────────────
   const { appName } = await prompts({
     type: "text",
     name: "appName",
     message: "App name (shown in Shopify admin)",
-    initial: projectName || "My Shopify App",
-  }, { onCancel });
-
-  const { appType } = await prompts({
-    type: "select",
-    name: "appType",
-    message: "What kind of app are you building?",
-    choices: [
-      { title: "Public app — list on the Shopify App Store", value: "public" },
-      { title: "Custom app — built for a single store", value: "custom" },
-    ],
-  }, { onCancel });
-
-  // ═══════════════════════════════════════════════════════════════════
-  section("Shopify Setup");
-
-  const hasShopifyCli = hasCommand("shopify");
-
-  // Build choices based on what's available
-  const shopifyChoices = [];
-  if (hasShopifyCli) {
-    shopifyChoices.push(
-      { title: "Create a new app via Shopify CLI", value: "cli-create" },
-      { title: "Link an existing app via Shopify CLI", value: "cli-link" },
-    );
-  }
-  shopifyChoices.push(
-    { title: `Enter credentials manually ${c.dim}(Client ID + Secret)${c.reset}`, value: "manual" },
-  );
-
-  const { shopifySetup } = await prompts({
-    type: "select",
-    name: "shopifySetup",
-    message: "How would you like to connect your Shopify app?",
-    choices: shopifyChoices,
+    initial: projectName.replace(/[-_.]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
   }, { onCancel });
 
-  let apiKey, apiSecret;
-
-  if (shopifySetup === "cli-create" || shopifySetup === "cli-link") {
-    // ── Use Shopify CLI to create/link the app ────────────────────
-    // We need a temp directory with a shopify.app.toml for the CLI to work
-    const tmpDir = path.resolve(process.cwd(), `__shopify_setup_${Date.now()}`);
-    fs.mkdirSync(tmpDir, { recursive: true });
-
-    try {
-      // Ensure logged in
-      console.log();
-      info("Logging into Shopify CLI...");
-      info("A browser window will open — sign in to your Partner account.");
-      console.log();
-      await execInteractive("shopify auth login", tmpDir);
-      ok("Logged into Shopify");
-
-      // Run config link — it handles both create and link interactively
-      console.log();
-      if (shopifySetup === "cli-create") {
-        info("Creating a new Shopify app...");
-        info(`Select ${c.bold}"Create a new app"${c.reset} when prompted.`);
-      } else {
-        info("Linking an existing Shopify app...");
-        info("Select your app from the list when prompted.");
-      }
-      console.log();
-      await execInteractive("shopify app config link", tmpDir);
-
-      // Parse the generated TOML to get client_id
-      const tomlFiles = fs.readdirSync(tmpDir).filter((f) => f.endsWith(".toml"));
-      let parsedKey = null;
-      for (const f of tomlFiles) {
-        parsedKey = parseTomlClientId(path.join(tmpDir, f));
-        if (parsedKey) break;
-      }
-
-      if (parsedKey) {
-        apiKey = parsedKey;
-        ok(`Client ID: ${c.cyan}${apiKey}${c.reset}`);
-      } else {
-        warn("Could not read Client ID from TOML");
-        const res = await prompts({
-          type: "text",
-          name: "apiKey",
-          message: "Paste your Client ID (API Key)",
-          validate: (v) => (v.trim() ? true : "Required"),
-        }, { onCancel });
-        apiKey = res.apiKey;
-      }
-
-      // API Secret is never in the TOML — always need to ask
-      console.log();
-      info("The API Secret is not stored in config files for security.");
-      info(`Find it at: ${c.cyan}https://partners.shopify.com${c.reset} → Apps → your app → Client credentials`);
-      console.log();
-      const { secret } = await prompts({
-        type: "password",
-        name: "secret",
-        message: "Paste your Client Secret (API Secret)",
-        validate: (v) => (v.trim() ? true : "Required — find it in Partner Dashboard → Apps → Client credentials"),
-      }, { onCancel });
-      apiSecret = secret;
-
-    } finally {
-      // Clean up temp directory
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  } else {
-    // ── Manual entry ──────────────────────────────────────────────
-    const creds = await prompts([
-      {
-        type: "text",
-        name: "apiKey",
-        message: `Shopify API Key ${c.dim}(Client ID)${c.reset}`,
-        validate: (v) => (v.trim() ? true : "Required"),
-      },
-      {
-        type: "password",
-        name: "apiSecret",
-        message: "Shopify API Secret",
-        validate: (v) => (v.trim() ? true : "Required"),
-      },
-    ], { onCancel });
-    apiKey = creds.apiKey;
-    apiSecret = creds.apiSecret;
-  }
-
-  // Scope presets (like Shopify CLI template selection)
+  // ── API scopes ────────────────────────────────────────────────────
   const { scopeChoice } = await prompts({
     type: "select",
     name: "scopeChoice",
@@ -382,34 +444,97 @@ async function getConfig(args) {
     scopes = scopeChoice;
   }
 
+  // ── Check for directory conflict ──────────────────────────────────
+  const outputDir = path.resolve(process.cwd(), projectName);
+  if (fs.existsSync(outputDir)) {
+    const { overwrite } = await prompts({
+      type: "confirm",
+      name: "overwrite",
+      message: `Directory "${projectName}" already exists. Overwrite?`,
+      initial: false,
+    }, { onCancel });
+    if (!overwrite) { console.log("\n  Cancelled.\n"); process.exit(0); }
+    fs.rmSync(outputDir, { recursive: true, force: true });
+  }
+
+  // ═══════════════════════════════════════════════════════════════════
+  section("Scaffolding");
+
+  // Build initial config (credentials filled in later after Shopify app creation)
+  const config = {
+    projectName,
+    appName,
+    language,
+    scopes,
+    apiKey: "",
+    apiSecret: "",
+    projectId: "",
+    appUrl: "",
+  };
+
+  info("Creating project files...");
+  const fileCount = scaffold(outputDir, config);
+  ok(`Created ${fileCount} files in ${c.cyan}${projectName}/${c.reset}`);
+
+  if (language === "typescript") {
+    info(`${c.dim}Backend: TypeScript (functions/src/*.ts)${c.reset}`);
+  } else {
+    info(`${c.dim}Backend: JavaScript (functions/src/*.js)${c.reset}`);
+  }
+  info(`${c.dim}Frontend: 4 pages — Dashboard, Products, Settings, Components${c.reset}`);
+
   // ═══════════════════════════════════════════════════════════════════
   section("Firebase Setup");
 
-  let projectId;
-  const hasFirebase = hasCommand("firebase");
+  // ── Ensure Firebase CLI ───────────────────────────────────────────
+  if (!hasCommand("firebase")) {
+    info("Firebase CLI not found — installing...");
+    try {
+      await exec("npm install -g firebase-tools");
+      ok("Firebase CLI installed");
+    } catch {
+      warn("Could not install Firebase CLI automatically");
+      info("Install manually: npm i -g firebase-tools");
+    }
+  }
 
-  if (hasFirebase) {
-    info("Fetching your Firebase projects...");
+  if (hasCommand("firebase")) {
+    // ── Firebase login ──────────────────────────────────────────────
+    info("Checking Firebase authentication...");
+    const projects = listFirebaseProjects();
+    if (projects.length > 0) {
+      ok("Firebase authenticated");
+    } else {
+      info("Opening browser for Firebase login...");
+      try {
+        await execInteractive("firebase login");
+        ok("Logged into Firebase");
+      } catch {
+        warn("Firebase login failed — run 'firebase login' manually later");
+      }
+    }
 
-    const choices = [
+    // ── Project selection ───────────────────────────────────────────
+    const freshProjects = listFirebaseProjects();
+    const fbChoices = [
       { title: `${c.cyan}[create a new project]${c.reset}`, value: "__create__" },
     ];
-    const projects = listFirebaseProjects();
-    if (projects.length > 0) {
-      for (const p of projects) {
-        choices.push({
+
+    if (freshProjects.length > 0) {
+      for (const p of freshProjects) {
+        fbChoices.push({
           title: `${p.displayName} ${c.dim}(${p.projectId})${c.reset}`,
           value: p.projectId,
         });
       }
     }
-    choices.push({ title: `${c.dim}[enter project ID manually]${c.reset}`, value: "__manual__" });
+    fbChoices.push({ title: `${c.dim}[enter project ID manually]${c.reset}`, value: "__manual__" });
 
     const { firebaseChoice } = await prompts({
       type: "select",
       name: "firebaseChoice",
       message: "Select a Firebase project",
-      choices,
+      choices: fbChoices,
     }, { onCancel });
 
     if (firebaseChoice === "__create__") {
@@ -417,7 +542,7 @@ async function getConfig(args) {
         type: "text",
         name: "newProjectId",
         message: "New project ID",
-        initial: projectName,
+        initial: projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-").slice(0, 30),
         validate: (v) => {
           if (!v.trim()) return "Required";
           if (!/^[a-z0-9][a-z0-9-]*$/.test(v)) return "Only lowercase letters, numbers, and hyphens";
@@ -430,17 +555,16 @@ async function getConfig(args) {
       const created = await createFirebaseProject(newProjectId, appName);
       if (created) {
         ok(`Project created: ${c.cyan}${newProjectId}${c.reset}`);
-        projectId = newProjectId;
+        config.projectId = newProjectId;
       } else {
         warn("Could not create project automatically");
-        info("Create one at https://console.firebase.google.com");
         const { manualId } = await prompts({
           type: "text",
           name: "manualId",
           message: "Firebase Project ID",
           validate: (v) => (v.trim() ? true : "Required"),
         }, { onCancel });
-        projectId = manualId;
+        config.projectId = manualId;
       }
     } else if (firebaseChoice === "__manual__") {
       const { manualId } = await prompts({
@@ -449,190 +573,265 @@ async function getConfig(args) {
         message: "Firebase Project ID",
         validate: (v) => (v.trim() ? true : "Required"),
       }, { onCancel });
-      projectId = manualId;
+      config.projectId = manualId;
     } else {
-      projectId = firebaseChoice;
-      ok(`Using project: ${c.cyan}${projectId}${c.reset}`);
+      config.projectId = firebaseChoice;
+      ok(`Using project: ${c.cyan}${config.projectId}${c.reset}`);
     }
-  } else {
-    // No Firebase CLI — manual setup
-    const { firebaseSetup } = await prompts({
-      type: "select",
-      name: "firebaseSetup",
-      message: "How would you like to set up Firebase?",
-      choices: [
-        { title: "Create a new project — opens Firebase Console", value: "create" },
-        { title: "Enter project ID manually", value: "manual" },
-      ],
-    }, { onCancel });
 
-    if (firebaseSetup === "create") {
-      console.log();
-      info("Opening Firebase Console...");
-      info("Create a new project and note the Project ID");
-      console.log();
-      openBrowser("https://console.firebase.google.com");
-    }
+    config.appUrl = `https://${config.projectId}.web.app`;
 
+    // ── Write .firebaserc now that we have projectId ────────────────
+    const firebaserc = JSON.stringify({ projects: { default: config.projectId } }, null, 2);
+    fs.writeFileSync(path.join(outputDir, ".firebaserc"), firebaserc + "\n");
+
+    // ── Provision Firebase services ─────────────────────────────────
+    await provisionFirebase(config, {
+      skipProvision: !!args["skip-provision"],
+      firestoreRegion: args["firestore-region"],
+      nonInteractive: false,
+      cwd: outputDir,
+    });
+  } else {
+    // No Firebase CLI available
     const { manualId } = await prompts({
       type: "text",
       name: "manualId",
-      message: "Firebase Project ID",
+      message: "Firebase Project ID (create at console.firebase.google.com)",
       validate: (v) => (v.trim() ? true : "Required"),
     }, { onCancel });
-    projectId = manualId;
-  }
+    config.projectId = manualId;
+    config.appUrl = `https://${config.projectId}.web.app`;
 
-  return {
-    projectName,
-    appName: appName || projectName,
-    appType,
-    apiKey,
-    apiSecret,
-    scopes: scopes || "read_products",
-    projectId,
-    appUrl: `https://${projectId}.web.app`,
-  };
-}
+    const firebaserc = JSON.stringify({ projects: { default: config.projectId } }, null, 2);
+    fs.writeFileSync(path.join(outputDir, ".firebaserc"), firebaserc + "\n");
+  }
 
-// ─── Scaffold files from templates ───────────────────────────────────────
-function scaffold(outputDir, config) {
-  // Recursively copy templates directory
-  copyDirSync(TEMPLATES_DIR, outputDir);
+  // ═══════════════════════════════════════════════════════════════════
+  section("Shopify App Setup");
 
-  // Rename dotfiles (npm strips leading dots on publish)
-  const renames = [
-    ["gitignore", ".gitignore"],
-    ["env.example", ".env.example"],
-  ];
-  for (const [from, to] of renames) {
-    const src = path.join(outputDir, from);
-    const dest = path.join(outputDir, to);
-    if (fs.existsSync(src)) {
-      fs.renameSync(src, dest);
+  // ── Ensure Shopify CLI ────────────────────────────────────────────
+  if (!hasCommand("shopify")) {
+    info("Shopify CLI not found — installing...");
+    try {
+      await exec("npm install -g @shopify/cli");
+      ok("Shopify CLI installed");
+    } catch {
+      warn("Could not install Shopify CLI");
     }
   }
 
-  // Variable substitution map
-  const vars = {
-    "{{APP_NAME}}": config.appName,
-    "{{API_KEY}}": config.apiKey,
-    "{{API_SECRET}}": config.apiSecret,
-    "{{SCOPES}}": config.scopes,
-    "{{PROJECT_ID}}": config.projectId,
-    "{{APP_URL}}": config.appUrl,
-  };
+  if (hasCommand("shopify")) {
+    const { shopifyAction } = await prompts({
+      type: "select",
+      name: "shopifyAction",
+      message: "Shopify app setup",
+      choices: [
+        { title: "Create a new app + link it (recommended)", value: "create" },
+        { title: "Link an existing app", value: "link" },
+        { title: "Skip — I'll configure manually later", value: "skip" },
+      ],
+    }, { onCancel });
 
-  // Files that need variable substitution
-  const templateFiles = [
-    "shopify.app.toml",
-    "web/index.html",
-  ];
+    if (shopifyAction !== "skip") {
+      // ── Login ──────────────────────────────────────────────────
+      console.log();
+      info("Logging into Shopify...");
+      info("A browser window will open — sign in to your Partner account.");
+      console.log();
+      try {
+        await execInteractive("shopify auth login");
+        ok("Logged into Shopify");
+      } catch {
+        warn("Shopify login failed — continuing with manual setup");
+      }
 
-  for (const relPath of templateFiles) {
-    const filePath = path.join(outputDir, relPath);
-    if (!fs.existsSync(filePath)) continue;
-    let content = fs.readFileSync(filePath, "utf8");
-    for (const [key, val] of Object.entries(vars)) {
-      content = content.replaceAll(key, val);
+      // ── Create / Link app via Shopify CLI ──────────────────────
+      // Must `cd` into project dir — Shopify CLI uses process.cwd(),
+      // not spawn's cwd option, for TOML generation.
+      console.log();
+      if (shopifyAction === "create") {
+        info(`Creating a new Shopify app: ${c.cyan}${appName}${c.reset}`);
+        info(`Select ${c.bold}"Create a new app"${c.reset} when prompted by the CLI.`);
+      } else {
+        info("Select your existing app from the list.");
+      }
+      console.log();
+
+      // Use `cd` to ensure Shopify CLI writes files in the project directory
+      const cdCmd = process.platform === "win32"
+        ? `cd /d "${outputDir}" && shopify app config link`
+        : `cd "${outputDir}" && shopify app config link`;
+
+      try {
+        await execInteractive(cdCmd);
+      } catch {
+        // Shopify CLI may exit non-zero even after creating/linking the app
+        // (e.g. "directory doesn't have a package.json" warning)
+        warn("Shopify CLI exited with a warning");
+      }
+
+      // ── Parse client_id from any TOML (runs regardless of exit code) ──
+      // Check project dir first, then parent dir (Shopify CLI fallback location)
+      const dirsToCheck = [outputDir, path.dirname(outputDir)];
+      for (const dir of dirsToCheck) {
+        if (config.apiKey) break;
+        try {
+          const tomlFiles = fs.readdirSync(dir).filter((f) => f.endsWith(".toml"));
+          for (const f of tomlFiles) {
+            const filePath = path.join(dir, f);
+            const clientId = parseTomlField(filePath, "client_id");
+            if (clientId && clientId !== "{{API_KEY}}" && clientId.length > 5) {
+              config.apiKey = clientId;
+              ok(`Client ID: ${c.cyan}${config.apiKey}${c.reset}`);
+
+              // If TOML was in parent dir (Shopify CLI bug), move it to project dir
+              if (dir !== outputDir) {
+                const destPath = path.join(outputDir, f);
+                try {
+                  // Don't overwrite our template — just read the client_id
+                  if (!fs.existsSync(destPath)) {
+                    fs.renameSync(filePath, destPath);
+                  } else {
+                    // Clean up the stray TOML from parent dir
+                    fs.unlinkSync(filePath);
+                  }
+                  info(`${c.dim}Picked up credentials from Shopify CLI${c.reset}`);
+                } catch {}
+              }
+              break;
+            }
+          }
+        } catch {}
+      }
+
+      if (!config.apiKey) {
+        console.log();
+        info("Could not read Client ID from Shopify CLI output.");
+        const res = await prompts({
+          type: "text",
+          name: "apiKey",
+          message: "Paste your Client ID (from Partner Dashboard → Apps)",
+          validate: (v) => (v.trim() ? true : "Required"),
+        }, { onCancel });
+        config.apiKey = res.apiKey;
+      }
     }
-    fs.writeFileSync(filePath, content);
-  }
 
-  // Generate functions/.env (secrets — not a template to avoid leaks)
-  const envContent = [
-    `SHOPIFY_API_KEY=${config.apiKey}`,
-    `SHOPIFY_API_SECRET=${config.apiSecret}`,
-    `SCOPES=${config.scopes}`,
-    `APP_URL=${config.appUrl}`,
-    "",
-  ].join("\n");
-  fs.writeFileSync(path.join(outputDir, "functions", ".env"), envContent);
+    // ── Get API Secret (never in TOML) ──────────────────────────────
+    if (!config.apiKey) {
+      console.log();
+      info(`Find credentials at: ${c.cyan}https://partners.shopify.com${c.reset} → Apps → Client credentials`);
+      const res = await prompts({
+        type: "text",
+        name: "apiKey",
+        message: `Client ID ${c.dim}(API Key)${c.reset}`,
+        validate: (v) => (v.trim() ? true : "Required"),
+      }, { onCancel });
+      config.apiKey = res.apiKey;
+    }
 
-  // Generate .firebaserc
-  const firebaserc = JSON.stringify(
-    { projects: { default: config.projectId } },
-    null,
-    2,
-  );
-  fs.writeFileSync(path.join(outputDir, ".firebaserc"), firebaserc + "\n");
+    console.log();
+    info("The API Secret is not stored in config files for security.");
+    info(`Find it at: ${c.cyan}https://partners.shopify.com${c.reset} → your app → Client credentials`);
+    console.log();
+    const { apiSecret } = await prompts({
+      type: "password",
+      name: "apiSecret",
+      message: "Client Secret (API Secret)",
+      validate: (v) => (v.trim() ? true : "Required"),
+    }, { onCancel });
+    config.apiSecret = apiSecret;
 
-  // Generate root package.json (required by Shopify CLI for `shopify app deploy`)
-  const rootPkg = JSON.stringify(
-    { name: config.name, private: true },
-    null,
-    2,
-  );
-  fs.writeFileSync(path.join(outputDir, "package.json"), rootPkg + "\n");
+  } else {
+    // No Shopify CLI — full manual entry
+    info(`Enter your Shopify app credentials (from ${c.cyan}partners.shopify.com${c.reset})`);
+    const creds = await prompts([
+      {
+        type: "text",
+        name: "apiKey",
+        message: `Client ID ${c.dim}(API Key)${c.reset}`,
+        validate: (v) => (v.trim() ? true : "Required"),
+      },
+      {
+        type: "password",
+        name: "apiSecret",
+        message: "Client Secret (API Secret)",
+        validate: (v) => (v.trim() ? true : "Required"),
+      },
+    ], { onCancel });
+    config.apiKey = creds.apiKey;
+    config.apiSecret = creds.apiSecret;
+  }
 
-  // Count files
-  let count = 0;
-  countFiles(outputDir, () => count++);
-  return count;
-}
+  // ── Write final credentials to files ──────────────────────────────
+  updateCredentials(outputDir, config);
 
-function copyDirSync(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      copyDirSync(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
+  // ═══════════════════════════════════════════════════════════════════
+  section("Installing & Building");
+
+  // ── npm install ───────────────────────────────────────────────────
+  info("Installing dependencies...");
+  const functionsDir = path.join(outputDir, "functions");
+  try {
+    await exec("npm install", functionsDir);
+    ok("Dependencies installed");
+  } catch {
+    warn(`npm install failed — run manually: cd ${projectName}/functions && npm install`);
   }
-}
 
-function countFiles(dir, cb) {
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    if (entry.isDirectory()) {
-      countFiles(path.join(dir, entry.name), cb);
-    } else {
-      cb();
+  // ── TypeScript build ──────────────────────────────────────────────
+  if (language === "typescript") {
+    info("Building TypeScript...");
+    try {
+      await exec("npm run build", functionsDir);
+      ok("TypeScript compiled successfully");
+    } catch {
+      warn("Build failed — run manually: cd functions && npm run build");
     }
   }
-}
 
-// ─── Main flow ───────────────────────────────────────────────────────────
-export async function run(argv) {
-  const args = parseArgs(argv);
+  // ═══════════════════════════════════════════════════════════════════
+  section("Finishing Up");
 
-  // Show help
-  if (args.help || args.h) {
-    printHelp();
-    return;
+  // ── Git init ──────────────────────────────────────────────────────
+  info("Initializing git...");
+  if (hasCommand("git")) {
+    try {
+      await exec("git init", outputDir);
+      await exec("git add -A", outputDir);
+      await exec('git commit -m "Initial scaffold from create-shopify-firebase-app"', outputDir);
+      ok("Git repository initialized");
+    } catch {
+      warn("Git init failed — initialize manually if needed");
+    }
+  } else {
+    warn("Git not found — skipping");
   }
 
-  // Show version
-  if (args.version || args.v) {
-    const pkg = JSON.parse(
-      fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"),
-    );
-    console.log(pkg.version);
-    return;
-  }
+  // ═══════════════════════════════════════════════════════════════════
+  printSuccess(config);
+}
+
+// ─── CI / non-interactive mode ──────────────────────────────────────────
+async function runCI(args) {
+  const config = {
+    projectName: args.projectName || "my-shopify-app",
+    appName: args["app-name"] || args.projectName || "My Shopify App",
+    language: args.language === "javascript" ? "javascript" : "typescript",
+    apiKey: args["api-key"],
+    apiSecret: args["api-secret"],
+    scopes: args.scopes || "read_products",
+    projectId: args["project-id"],
+    appUrl: `https://${args["project-id"]}.web.app`,
+  };
 
-  // Collect config
-  const config = await getConfig(args);
   const outputDir = path.resolve(process.cwd(), config.projectName);
 
-  // Check if directory exists
   if (fs.existsSync(outputDir)) {
-    const { overwrite } = await prompts({
-      type: "confirm",
-      name: "overwrite",
-      message: `Directory "${config.projectName}" already exists. Overwrite?`,
-      initial: false,
-    });
-    if (!overwrite) {
-      console.log("\n  Cancelled.\n");
-      process.exit(0);
-    }
     fs.rmSync(outputDir, { recursive: true, force: true });
   }
 
-  // ═══════════════════════════════════════════════════════════════════
   section("Setting Up");
 
   info("Scaffolding project...");
@@ -644,69 +843,111 @@ export async function run(argv) {
   try {
     await exec("npm install", functionsDir);
     ok("Dependencies installed");
-  } catch (e) {
-    warn(`npm install failed — run manually: cd ${config.projectName}/functions && npm install`);
-  }
-
-  info("Building TypeScript...");
-  try {
-    await exec("npm run build", functionsDir);
-    ok("TypeScript compiled successfully");
-  } catch (e) {
-    warn("Build failed — run manually: cd functions && npm run build");
+  } catch {
+    warn("npm install failed");
   }
 
-  info("Setting up Firebase...");
-  if (!hasCommand("firebase")) {
-    info("Firebase CLI not found — installing globally...");
+  if (config.language === "typescript") {
+    info("Building TypeScript...");
     try {
-      await exec("npm install -g firebase-tools");
-      ok("Firebase CLI installed");
-    } catch (e) {
-      warn("Could not install Firebase CLI automatically");
-      info("Install manually: npm i -g firebase-tools");
-      info(`Then run: cd ${config.projectName} && firebase use ${config.projectId}`);
+      await exec("npm run build", functionsDir);
+      ok("TypeScript compiled");
+    } catch {
+      warn("Build failed");
     }
   }
-  if (hasCommand("firebase")) {
-    const isCI = args["api-key"] && args["api-secret"] && args["project-id"];
+
+  if (hasCommand("firebase") && !args["skip-provision"]) {
+    info("Setting up Firebase...");
     await provisionFirebase(config, {
       skipProvision: !!args["skip-provision"],
       firestoreRegion: args["firestore-region"],
-      nonInteractive: isCI,
+      nonInteractive: true,
       cwd: outputDir,
     });
   }
 
-  info("Checking Shopify CLI...");
-  if (hasCommand("shopify")) {
-    ok("Shopify CLI detected");
-  } else {
-    info("Shopify CLI not found — installing globally...");
-    try {
-      await exec("npm install -g @shopify/cli");
-      ok("Shopify CLI installed");
-    } catch (e) {
-      warn("Could not install Shopify CLI automatically");
-      info("Install manually: npm i -g @shopify/cli");
-    }
-  }
-
-  info("Initializing git...");
   if (hasCommand("git")) {
+    info("Initializing git...");
     try {
       await exec("git init", outputDir);
       await exec("git add -A", outputDir);
       await exec('git commit -m "Initial scaffold from create-shopify-firebase-app"', outputDir);
-      ok("Git repository initialized with first commit");
-    } catch {
-      warn("Git init failed — initialize manually if needed");
+      ok("Git initialized");
+    } catch {}
+  }
+
+  printSuccess(config);
+}
+
+// ─── Distribution flow ──────────────────────────────────────────────────
+async function distributeFlow() {
+  console.log();
+  console.log(`  ${c.green}${c.bold}🛍️  +  🔥${c.reset}  ${c.bold}App Distribution${c.reset}`);
+
+  const tomlPath = path.resolve(process.cwd(), "shopify.app.toml");
+
+  if (!fs.existsSync(tomlPath)) {
+    // No app configured — offer to set one up
+    console.log();
+    fail("No shopify.app.toml found in the current directory.");
+    info("Run this command from your app's root directory.");
+    console.log();
+
+    if (hasCommand("shopify")) {
+      const { shouldLink } = await prompts({
+        type: "confirm",
+        name: "shouldLink",
+        message: "Would you like to link a Shopify app now?",
+        initial: true,
+      }, { onCancel });
+
+      if (shouldLink) {
+        try {
+          await execInteractive("shopify auth login");
+          await execInteractive("shopify app config link");
+          ok("App linked successfully");
+        } catch {
+          fail("Could not link app");
+          return;
+        }
+      } else {
+        return;
+      }
+    } else {
+      info("Install Shopify CLI: npm i -g @shopify/cli");
+      return;
     }
+  }
+
+  const clientId = parseTomlField(tomlPath, "client_id");
+  const appName = parseTomlField(tomlPath, "name");
+
+  section("Distribution Checklist");
+
+  console.log(`  ${c.bold}App: ${c.cyan}${appName || "Unknown"}${c.reset}`);
+  if (clientId) console.log(`  ${c.bold}Client ID: ${c.dim}${clientId}${c.reset}`);
+  console.log();
+
+  console.log(`  ${c.bold}Before submitting to the App Store:${c.reset}`);
+  console.log();
+  console.log(`    ${c.cyan}1.${c.reset} Deploy your app: ${c.cyan}firebase deploy${c.reset}`);
+  console.log(`    ${c.cyan}2.${c.reset} Test on a development store`);
+  console.log(`    ${c.cyan}3.${c.reset} Add your privacy policy URL`);
+  console.log(`    ${c.cyan}4.${c.reset} Add your app listing details (description, screenshots)`);
+  console.log(`    ${c.cyan}5.${c.reset} Submit for review`);
+  console.log();
+
+  if (clientId) {
+    info("Opening Partner Dashboard → Distribution...");
+    openBrowser(`https://partners.shopify.com/apps/${clientId}/distribution`);
   } else {
-    warn("Git not found — skipping");
+    info(`Open: ${c.cyan}https://partners.shopify.com${c.reset} → Apps → your app → Distribution`);
   }
 
-  printSuccess(config);
+  console.log();
+  console.log(`  ${c.dim}Docs: https://shopify.dev/docs/apps/launch${c.reset}`);
+  console.log();
 }
 
 // ─── Success output ──────────────────────────────────────────────────────
@@ -714,7 +955,15 @@ function printSuccess(config) {
   console.log();
   console.log(`  ${c.green}${c.bold}✔  All done!${c.reset} Your Shopify + Firebase app is ready.`);
   console.log();
-  console.log(`  ${c.bold}Next steps:${c.reset}`);
+  console.log(`  ${c.bold}Your app includes:${c.reset}`);
+  console.log(`    ${c.green}✔${c.reset} Dashboard — store info + quick stats`);
+  console.log(`    ${c.green}✔${c.reset} Products — search + detail view`);
+  console.log(`    ${c.green}✔${c.reset} Settings — form with Firestore persistence`);
+  console.log(`    ${c.green}✔${c.reset} Components — Polaris reference with copy-paste code`);
+  console.log(`    ${c.green}✔${c.reset} App Bridge — navigation, toasts, modals, resource picker`);
+  console.log(`    ${c.green}✔${c.reset} 4 Cloud Functions — auth, api, webhooks, proxy`);
+  console.log();
+  console.log(`  ${c.bold}Deploy:${c.reset}`);
   console.log();
   console.log(`    ${c.cyan}cd ${config.projectName}${c.reset}`);
   console.log(`    ${c.cyan}firebase deploy${c.reset}`);
@@ -723,11 +972,12 @@ function printSuccess(config) {
   console.log();
   console.log(`    ${c.cyan}${config.appUrl}/auth?shop=YOUR-STORE.myshopify.com${c.reset}`);
   console.log();
-  console.log(`  ${c.bold}Or develop locally:${c.reset}`);
+  console.log(`  ${c.bold}Go live:${c.reset}`);
   console.log();
-  console.log(`    ${c.cyan}shopify app dev${c.reset}`);
+  console.log(`    ${c.cyan}npx create-shopify-firebase-app --distribute${c.reset}`);
   console.log();
   console.log(`  ${c.dim}─────────────────────────────────────────${c.reset}`);
+  console.log(`  ${c.dim}Language:      ${config.language}${c.reset}`);
   console.log(`  ${c.dim}App URL:       ${config.appUrl}${c.reset}`);
   console.log(`  ${c.dim}Firebase:      ${config.projectId}${c.reset}`);
   console.log(`  ${c.dim}Scopes:        ${config.scopes}${c.reset}`);
@@ -739,8 +989,8 @@ function printHelp() {
   console.log(`
   ${c.bold}create-shopify-firebase-app${c.reset}
 
-  Create Shopify apps powered by Firebase.
-  Serverless, lightweight, zero-framework.
+  Build Shopify apps for free. Serverless, zero-framework.
+  The easiest way to build Shopify apps on Firebase.
 
   ${c.bold}Usage:${c.reset}
 
@@ -748,49 +998,47 @@ function printHelp() {
 
   ${c.bold}Options:${c.reset}
 
+    --help, -h               Show this help
+    --version, -v            Show version
+    --distribute             Open distribution dashboard for your app
+
+  ${c.bold}CI / non-interactive:${c.reset}
+
     --api-key=KEY            Shopify API Key (client_id)
     --api-secret=SECRET      Shopify API Secret
     --project-id=ID          Firebase Project ID
     --scopes=SCOPES          API scopes (default: read_products)
+    --language=LANG          typescript or javascript (default: typescript)
     --app-name=NAME          App name shown in Shopify admin
-    --help, -h               Show this help
-    --version, -v            Show version
-
-  ${c.bold}Firebase provisioning:${c.reset}
-
     --skip-provision         Skip Firebase service provisioning
-    --firestore-region=LOC   Firestore region (e.g. asia-south1, us-central1)
+    --firestore-region=LOC   Firestore region (e.g. us-central1)
 
   ${c.bold}Examples:${c.reset}
 
-    ${c.dim}# Interactive mode (prompts for config + provisions Firebase)${c.reset}
+    ${c.dim}# Interactive — guided wizard${c.reset}
     npx create-shopify-firebase-app
 
     ${c.dim}# With project name${c.reset}
     npx create-shopify-firebase-app my-app
 
-    ${c.dim}# Non-interactive (CI/CD)${c.reset}
+    ${c.dim}# CI / non-interactive${c.reset}
     npx create-shopify-firebase-app my-app \\
-      --api-key=abc123 \\
-      --api-secret=secret \\
+      --api-key=abc123 --api-secret=secret \\
       --project-id=my-firebase-project
 
-    ${c.dim}# With Firebase provisioning in CI${c.reset}
-    npx create-shopify-firebase-app my-app \\
-      --api-key=abc123 \\
-      --api-secret=secret \\
-      --project-id=my-firebase-project \\
-      --firestore-region=asia-south1
+    ${c.dim}# Go live — open distribution page${c.reset}
+    npx create-shopify-firebase-app --distribute
 
   ${c.bold}What you get:${c.reset}
 
-    ✔ Firebase v2 Cloud Functions (4 independent, auto-scaling functions)
-    ✔ Shopify API 2026-01 (latest) + OAuth, webhooks, GDPR
-    ✔ Firestore for sessions and app data
-    ✔ App Bridge embedded admin dashboard (vanilla HTML/JS)
-    ✔ Theme App Extension for storefront UI
-    ✔ Firebase Hosting ($0/month — free for up to 25K installed stores)
-    ✔ Auto-installs Firebase CLI + Shopify CLI if missing
-    ✔ Auto-provisioning: Firestore, Web App, Hosting (interactive)
+    ✔ 4 pages — Dashboard, Products, Settings, Polaris Components
+    ✔ App Bridge — embedded admin with navigation, toasts, modals
+    ✔ Firebase v2 Cloud Functions — 4 independent, auto-scaling
+    ✔ Shopify API 2026-01 — OAuth, webhooks, GDPR
+    ✔ Firestore — sessions, settings, app data
+    ✔ TypeScript or JavaScript — your choice
+    ✔ Firebase Hosting — $0/month for up to 25K installed stores
+    ✔ Auto-installs Firebase CLI + Shopify CLI
+    ✔ Distribution helper — go live in minutes
 `);
 }