kasy-cli 1.2.1

package/lib/commands/new.js

@@ -0,0 +1,1870 @@
+/**
+ * `kasy new` — unified command to create a complete Flutter project.
+ *
+ * Flow:
+ *   1. Language — use stored preference or ask + save
+ *   2. Environment checks (non-blocking warnings)
+ *   3. Backend selection (Firebase / Supabase / API)
+ *   4. Backend tool checks (non-blocking warnings)
+ *   5. Collect answers (name, bundle ID, credentials, modules)
+ *   6. Run generator (copy → pub get → build_runner → flutterfire → deploy)
+ *   7. Show results + next steps
+ */
+
+const path = require('node:path');
+const crypto = require('node:crypto');
+const kleur = require('kleur');
+const gradient = require('gradient-string');
+const oraPackage = require('ora');
+const ora = oraPackage.default || oraPackage;
+
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+
+// Spinner manager for multi-step long-running operations.
+// Each call to .next(text) succeeds the previous step and starts a new one.
+// Call .succeed(text) or .fail(text) to close the last step.
+function makeProgressSpinner() {
+  let current = null;
+  return {
+    next(text) {
+      if (current) current.succeed();
+      current = ora(`  ${text}`).start();
+    },
+    succeed(text) {
+      if (current) { current.succeed(text ? `  ${text}` : undefined); current = null; }
+    },
+    fail(text) {
+      if (current) { current.fail(text ? `  ${text}` : undefined); current = null; }
+    },
+    warn(text) {
+      if (current) { current.warn(text ? `  ${text}` : undefined); current = null; }
+    },
+    stop() {
+      if (current) { current.stop(); current = null; }
+    },
+  };
+}
+
+function generateWebhookKey() {
+  return 'rc_wh_' + crypto.randomBytes(16).toString('hex');
+}
+
+
+
+async function waitWithCountdown(seconds, label) {
+  for (let i = seconds; i > 0; i--) {
+    process.stdout.write(`\r  ${label} ${i}s…   `);
+    await sleep(1000);
+  }
+  process.stdout.write(`\r  ${label} pronto!     \n`);
+}
+const prompts = require('prompts');
+const fs = require('fs-extra');
+const { createTranslator } = require('../utils/i18n');
+const { getStoredLanguage, setStoredLanguage } = require('../utils/license');
+const { promptLanguage } = require('../utils/prompts');
+const {
+  getBaseChecks,
+  getPlatformChecks,
+  getBackendChecks,
+  runChecks,
+  hasRequiredFailures,
+} = require('../utils/checks');
+const { normalizeBackend, getVisibleFeatures } = require('../scaffold/catalog');
+
+// Audience gate: set KASY_INTERNAL=1 to reveal beta/internal features.
+const KASY_AUDIENCE = process.env.KASY_INTERNAL === '1' ? 'internal' : 'public';
+const { generateFirebaseProject } = require('../scaffold/backends/firebase/generator');
+const { generateSupabaseProject } = require('../scaffold/backends/supabase/generator');
+const { generateApiProject } = require('../scaffold/backends/api/generator');
+const { createProjectAndGetKeys, setupLinkedProject, checkLoggedIn, getOrgsList, getProjectsByOrg, getProjectKeys } = require('../scaffold/backends/supabase/deploy');
+const { writeSupabaseGoogleAuthOptions, readSupabaseGoogleCredentials, getGoogleClientSecretViaGcloud } = require('../scaffold/shared/post-build');
+const { toPackageName } = require('../scaffold/backends/firebase/tokens');
+const { setupFromScratch, setupExistingProject, listBillingAccounts, listGcpOrganizations, checkGcloudAuth, getGcloudInstallInstructions, enableAuthProviders, registerDebugSha1 } = require('../scaffold/backends/firebase/setup-from-scratch');
+const { createFcmServiceAccountKey } = require('../scaffold/shared/fcm-service-account');
+
+// Região padrão para criação de projetos Supabase via API.
+// Supabase regions: https://supabase.com/docs/guides/platform/regions
+const DEFAULT_SUPABASE_REGION = 'sa-east-1'; // São Paulo
+
+const BILLING_OTHER = '__other__';
+
+/**
+ * Prompts user to select a billing account. Always shows when 1+ accounts exist.
+ * Includes "Other - enter ID manually" so user can use another account (e.g. when default has quota exceeded).
+ * @param {Function} tr - Translator
+ * @param {Function} onCancel - Cancel handler
+ * @returns {Promise<string|null>} Selected billing account ID, or null to use default (first)
+ */
+async function promptBillingAccountIfNeeded(tr, onCancel) {
+  const billingList = await listBillingAccounts();
+  if (!billingList.ok) return null;
+  if (!billingList.accounts?.length) {
+    console.log(kleur.yellow(`  ${tr('new.firebase.q.billingAccount.context')}`));
+    const { manualId } = await prompts(
+      {
+        type: 'text',
+        name: 'manualId',
+        message: tr('new.firebase.q.billingAccount.manualId'),
+        hint: tr('new.firebase.q.billingAccount.manualId.hint'),
+        validate: (v) => (v && v.trim() ? true : tr('new.firebase.q.billingAccount.manualId.required')),
+      },
+      { onCancel }
+    );
+    return manualId?.trim() || null;
+  }
+  const choices = [
+    ...billingList.accounts.map((a) => ({
+      title: `${a.name || a.id} (${a.id})`,
+      value: a.id,
+    })),
+    { title: tr('new.firebase.q.billingAccount.other'), value: BILLING_OTHER },
+  ];
+  console.log(kleur.yellow(`  ${tr('new.firebase.q.billingAccount.context')}`));
+  const { billingAccountId } = await prompts(
+    {
+      type: 'select',
+      name: 'billingAccountId',
+      message: tr('new.firebase.q.billingAccount'),
+      hint: tr('new.firebase.q.billingAccount.hint'),
+      choices,
+    },
+    { onCancel }
+  );
+  if (billingAccountId === BILLING_OTHER) {
+    const { manualId } = await prompts(
+      {
+        type: 'text',
+        name: 'manualId',
+        message: tr('new.firebase.q.billingAccount.manualId'),
+        hint: tr('new.firebase.q.billingAccount.manualId.hint'),
+        validate: (v) => (v && v.trim() ? true : tr('new.firebase.q.billingAccount.manualId.required')),
+      },
+      { onCancel }
+    );
+    return manualId?.trim() || null;
+  }
+  return billingAccountId;
+}
+
+/**
+ * Prompts user to select a GCP organization. Only shows when the account has ≥1 organization.
+ * Personal accounts (no orgs) silently skip this prompt.
+ * @param {Function} tr - Translator
+ * @param {Function} onCancel - Cancel handler
+ * @returns {Promise<string|null>} Selected organization ID, or null (no organization / personal account)
+ */
+async function promptOrganizationIfNeeded(tr, onCancel) {
+  const orgList = await listGcpOrganizations();
+  if (!orgList.ok || !orgList.organizations?.length) return null;
+  const choices = [
+    ...orgList.organizations.map((o) => ({
+      title: `${o.name} (${o.id})`,
+      value: o.id,
+    })),
+    { title: tr('new.firebase.q.organization.none'), value: null },
+  ];
+  const { organizationId } = await prompts(
+    {
+      type: 'select',
+      name: 'organizationId',
+      message: tr('new.firebase.q.organization'),
+      hint: tr('new.firebase.q.organization.hint'),
+      choices,
+    },
+    { onCancel }
+  );
+  return organizationId || null;
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function printBanner(tr) {
+  const bar = kleur.gray('─────────────────────────────────────────────────');
+  const logo = [
+    ' ██╗  ██╗ █████╗ ███████╗██╗   ██╗',
+    ' ██║ ██╔╝██╔══██╗██╔════╝╚██╗ ██╔╝',
+    ' █████╔╝ ███████║███████╗ ╚████╔╝ ',
+    ' ██╔═██╗ ██╔══██║╚════██║  ╚██╔╝  ',
+    ' ██║  ██╗██║  ██║███████║   ██║   ',
+    ' ╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝   ╚═╝   ',
+  ]
+    .map((line) => gradient(['#a78bfa', '#60a5fa'])(line))
+    .join('\n');
+  const title = kleur.bold().white(`  ${tr('new.banner')}`);
+  console.log(`\n${bar}`);
+  console.log(logo);
+  console.log('');
+  console.log(title);
+  console.log(kleur.dim(`  ${tr('new.subtitle2')}`));
+  console.log(`${bar}\n`);
+}
+
+function printPrerequisites(tr, backend, firebaseSetupMode = 'existing', checkResults = []) {
+  const gcloudOk = checkResults.every(
+    (r) => !r.name?.includes('gcloud') || r.ok
+  );
+  console.log(kleur.bold().yellow(`  ${tr('new.prereq.title')}`));
+  const firebaseCreate = firebaseSetupMode === 'create';
+  if (backend === 'firebase') {
+    if (firebaseCreate) {
+      if (!gcloudOk) {
+        console.log(kleur.gray(`  ${tr('new.firebase.prereq.create.1')}`));
+      }
+      console.log(kleur.gray(`  ${tr('new.firebase.prereq.create.2')}`));
+      console.log(kleur.gray(`  ${tr('new.firebase.prereq.create.projectQuota')}`));
+      console.log(kleur.cyan(`  ${tr('new.firebase.prereq.create.note')}`));
+    } else {
+      console.log(kleur.gray(`  ${tr('new.firebase.prereq.1')}`));
+      console.log(kleur.gray(`  ${tr('new.firebase.prereq.2')}`));
+      console.log(kleur.gray(`  ${tr('new.firebase.prereq.3')}`));
+      console.log(kleur.gray(`  ${tr('new.firebase.prereq.4')}`));
+      console.log(kleur.gray(`  ${tr('new.firebase.prereq.5')}`));
+      console.log(kleur.cyan(`  ${tr('new.firebase.prereq.doc')}`));
+    }
+  } else if (backend === 'supabase') {
+    if (firebaseCreate) {
+      if (!gcloudOk) {
+        console.log(kleur.gray(`  ${tr('new.firebase.prereq.create.1')}`));
+      }
+      console.log(kleur.gray(`  ${tr('new.firebase.prereq.create.2')}`));
+      console.log(kleur.gray(`  ${tr('new.firebase.prereq.create.projectQuota')}`));
+      console.log(kleur.cyan(`  ${tr('new.firebase.prereq.create.pushNote')}`));
+      console.log(kleur.gray(`  ${tr('new.supabase.prereq.1')}`));
+      console.log(kleur.gray(`  ${tr('new.supabase.prereq.2')}`));
+      console.log(kleur.cyan(`  ${tr('new.supabase.prereq.login')}`));
+    } else {
+      console.log(kleur.gray(`  ${tr('new.supabase.prereq.1')}`));
+      console.log(kleur.gray(`  ${tr('new.supabase.prereq.2')}`));
+      console.log(kleur.gray(`  ${tr('new.supabase.prereq.3')}`));
+      console.log(kleur.cyan(`  ${tr('new.supabase.prereq.login')}`));
+    }
+  } else if (backend === 'api') {
+    if (firebaseCreate) {
+      if (!gcloudOk) {
+        console.log(kleur.gray(`  ${tr('new.firebase.prereq.create.1')}`));
+      }
+      console.log(kleur.gray(`  ${tr('new.firebase.prereq.create.2')}`));
+      console.log(kleur.gray(`  ${tr('new.firebase.prereq.create.projectQuota')}`));
+      console.log(kleur.cyan(`  ${tr('new.firebase.prereq.create.pushNote')}`));
+      console.log(kleur.gray(`  ${tr('new.api.prereq.1')}`));
+      console.log(kleur.gray(`  ${tr('new.api.prereq.2')}`));
+    } else {
+      console.log(kleur.gray(`  ${tr('new.api.prereq.1')}`));
+      console.log(kleur.gray(`  ${tr('new.api.prereq.2')}`));
+      console.log(kleur.gray(`  ${tr('new.api.prereq.3')}`));
+    }
+  }
+  console.log('');
+}
+
+function printSummary(tr, answers) {
+  const modules = answers.modules.length > 0
+    ? answers.modules.join(', ')
+    : tr('new.firebase.confirm.none');
+
+  const backendLabel = { firebase: '🔥 Firebase', supabase: '🟢 Supabase', api: '🔗 API REST' }[answers.backend] || answers.backend;
+  const bar = kleur.gray('  ─────────────────────────────────────────────');
+
+  console.log(`\n${bar}`);
+  console.log(kleur.bold(`  📦 ${tr('new.firebase.confirm.title')}`));
+  console.log(bar);
+  console.log(`  ${kleur.dim(tr('new.firebase.confirm.app') + ':')}        ${kleur.white(answers.appName)}`);
+  console.log(`  ${kleur.dim('Bundle:')}        ${kleur.white(answers.bundleId)}`);
+  console.log(`  ${kleur.dim('Backend:')}       ${kleur.white(backendLabel)}`);
+  if (answers.firebaseProjectId) {
+    console.log(`  ${kleur.dim('Firebase:')}      ${kleur.white(answers.firebaseProjectId)}`);
+  }
+  if (answers.supabaseUrl) {
+    console.log(`  ${kleur.dim('Supabase URL:')}  ${kleur.white(answers.supabaseUrl)}`);
+  }
+  if (answers.apiBaseUrl) {
+    console.log(`  ${kleur.dim('API URL:')}       ${kleur.white(answers.apiBaseUrl)}`);
+  }
+  console.log(`  ${kleur.dim(tr('new.firebase.confirm.modules') + ':')}     ${kleur.white(modules)}`);
+  console.log(bar);
+}
+
+const STEP_LABELS = {
+  'project-setup':  { en: 'Project configured',                     pt: 'Projeto configurado',                   es: 'Proyecto configurado' },
+  'pub-get':        { en: 'Packages installed',                      pt: 'Pacotes instalados',                    es: 'Paquetes instalados' },
+  'slang':          { en: 'Translations generated',                  pt: 'Traducoes geradas',                     es: 'Traducciones generadas' },
+  'build-runner':   { en: 'Code generated (Riverpod / Freezed)',      pt: 'Codigo gerado (Riverpod / Freezed)',     es: 'Codigo generado (Riverpod / Freezed)' },
+  'flutterfire':    { en: 'Firebase configured (flutterfire)',        pt: 'Firebase configurado (flutterfire)',    es: 'Firebase configurado (flutterfire)' },
+  'Service Account key': { en: 'Service Account key',                pt: 'Chave de servico',                      es: 'Clave de servicio' },
+  'firebase_key.json': { en: 'Service account key copied', pt: 'Chave de conta de servico copiada', es: 'Clave de cuenta de servicio copiada' },
+  'npm install (functions)': { en: 'Functions dependencies installed', pt: 'Dependencias das Functions instaladas', es: 'Dependencias de Functions instaladas' },
+  'firebase deploy (Functions + Firestore rules + Storage)': {
+    en: 'Backend deployed (Functions + rules)',
+    pt: 'Backend publicado (Functions + regras)',
+    es: 'Backend desplegado (Functions + reglas)',
+  },
+  'firebase-messaging-sw': {
+    en: 'Web: firebase-messaging-sw.js configured',
+    pt: 'Web: firebase-messaging-sw.js configurado',
+    es: 'Web: firebase-messaging-sw.js configurado',
+  },
+  'supabase init':     { en: 'Supabase init',        pt: 'Supabase init',        es: 'Supabase init' },
+  'supabase link':     { en: 'Supabase linked',      pt: 'Supabase vinculado',   es: 'Supabase vinculado' },
+  'supabase db push':  { en: 'Database migrated',    pt: 'Banco migrado',        es: 'Base de datos migrada' },
+  'anonymous sign-in': { en: 'Anonymous sign-in enabled', pt: 'Login anonimo ativado', es: 'Inicio de sesion anonimo activado' },
+  'google sign-in': { en: 'Google Sign-In enabled', pt: 'Google Sign-In ativado', es: 'Google Sign-In activado' },
+  'google-auth-options': { en: 'Google client IDs written', pt: 'Client IDs do Google gravados', es: 'Client IDs de Google escritos' },
+  'ios-url-scheme': { en: 'iOS URL scheme registered', pt: 'URL scheme iOS registrado', es: 'URL scheme iOS registrado' },
+  'google-ios-url-scheme': { en: 'iOS Google URL scheme registered', pt: 'URL scheme Google iOS registrado', es: 'URL scheme Google iOS registrado' },
+  'deploy revenuecat-webhook': { en: 'RevenueCat webhook deployed', pt: 'Webhook RevenueCat publicado', es: 'Webhook RevenueCat desplegado' },
+  'secret REVENUECAT_WEBHOOK_KEY': { en: 'RevenueCat webhook secret', pt: 'Secret webhook RevenueCat', es: 'Secret webhook RevenueCat' },
+  'secret META_ACCESS_TOKEN': { en: 'Meta Access Token', pt: 'Meta Access Token', es: 'Meta Access Token' },
+  'secret META_DATASET_ID': { en: 'Meta Dataset ID', pt: 'Meta Dataset ID', es: 'Meta Dataset ID' },
+  'fcm-key': { en: 'FCM Service Account key generated', pt: 'Chave FCM gerada automaticamente', es: 'Clave FCM generada automáticamente' },
+  'fcm-key-saved': { en: 'FCM key saved to .kasy/', pt: 'Chave FCM salva em .kasy/', es: 'Clave FCM guardada en .kasy/' },
+  'secret FIREBASE_SERVICE_ACCOUNT_JSON': { en: 'FCM Service Account configured', pt: 'Service Account FCM configurado', es: 'Service Account FCM configurado' },
+  'gcp-project': { en: 'GCP project created', pt: 'Projeto GCP criado', es: 'Proyecto GCP creado' },
+  'billing': { en: 'Billing account linked (Blaze)', pt: 'Conta de faturamento vinculada (Blaze)', es: 'Cuenta de facturación vinculada (Blaze)' },
+  'add-firebase': { en: 'Firebase added to project', pt: 'Firebase adicionado ao projeto', es: 'Firebase añadido al proyecto' },
+  'enable-apis': { en: 'APIs enabled', pt: 'APIs ativadas', es: 'APIs habilitadas' },
+  'android-app': { en: 'Android app registered', pt: 'App Android registrado', es: 'App Android registrado' },
+  'ios-app': { en: 'iOS app registered', pt: 'App iOS registrado', es: 'App iOS registrado' },
+  'web-app': { en: 'Web app registered', pt: 'App Web registrado', es: 'App Web registrado' },
+  'sha1': { en: 'SHA-1 added for Google Sign-In', pt: 'SHA-1 adicionado para Google Sign-In', es: 'SHA-1 añadido para Google Sign-In' },
+  'service-account': { en: 'Service account key created', pt: 'Chave de conta de servico criada', es: 'Clave de cuenta de servicio creada' },
+  'firestore': { en: 'Firestore database created', pt: 'Banco Firestore criado', es: 'Base de datos Firestore creada' },
+  'storage': { en: 'Firebase Storage bucket created', pt: 'Bucket Firebase Storage criado', es: 'Bucket Firebase Storage creado' },
+};
+
+const STEP_PROGRESS = {
+  'project-setup': { en: 'Configuring your project…',               pt: 'Configurando seu projeto…',              es: 'Configurando tu proyecto…' },
+  'pub-get':       { en: 'Installing packages…',                    pt: 'Instalando pacotes…',                    es: 'Instalando paquetes…' },
+  'slang':         { en: 'Generating translations…',                pt: 'Gerando traducoes…',                     es: 'Generando traducciones…' },
+  'build-runner':  { en: 'Generating code (Riverpod / Freezed)…',   pt: 'Gerando codigo (pode demorar)…',         es: 'Generando codigo (puede tardar)…' },
+  'flutterfire':   { en: 'Connecting to Firebase…',                 pt: 'Conectando ao Firebase…',                es: 'Conectando a Firebase…' },
+  'deploy':        { en: 'Deploying backend to Firebase…',          pt: 'Publicando backend no Firebase…',        es: 'Desplegando backend en Firebase…' },
+  'gcp-project':   { en: 'Creating GCP project…',                   pt: 'Criando projeto GCP…',                    es: 'Creando proyecto GCP…' },
+  'billing':       { en: 'Linking billing account (Blaze)…',         pt: 'Vinculando conta de faturamento (Blaze)…', es: 'Vinculando cuenta de facturación (Blaze)…' },
+  'add-firebase':  { en: 'Adding Firebase…',                       pt: 'Adicionando Firebase…',                 es: 'Añadiendo Firebase…' },
+  'enable-apis':   { en: 'Enabling APIs…',                         pt: 'Ativando APIs…',                          es: 'Habilitando APIs…' },
+  'android-app':   { en: 'Registering Android app…',                pt: 'Registrando app Android…',               es: 'Registrando app Android…' },
+  'ios-app':       { en: 'Registering iOS app…',                     pt: 'Registrando app iOS…',                    es: 'Registrando app iOS…' },
+  'web-app':       { en: 'Registering Web app…',                     pt: 'Registrando app Web…',                    es: 'Registrando app Web…' },
+  'sha1':          { en: 'Adding SHA-1 for Google Sign-In…',        pt: 'Adicionando SHA-1 para Google Sign-In…', es: 'Añadiendo SHA-1 para Google Sign-In…' },
+  'service-account': { en: 'Creating service account key…',         pt: 'Criando chave de conta de servico…',      es: 'Creando clave de cuenta de servicio…' },
+  'firestore':     { en: 'Creating Firestore database…',            pt: 'Criando banco Firestore…',                es: 'Creando base de datos Firestore…' },
+  'storage':       { en: 'Creating Firebase Storage bucket…',       pt: 'Criando bucket Firebase Storage…',        es: 'Creando bucket Firebase Storage…' },
+  'deploy-retry-wait':   { en: 'Waiting 4 min for GCP permissions to propagate… (do not close terminal)', pt: 'Aguardando 4 min para permissões do GCP propagarem… (não feche o terminal)', es: 'Esperando 4 min para propagar permisos de GCP… (no cierres la terminal)' },
+  'deploy-retry-wait-2': { en: 'Retrying with updated permissions, 2 more min… (almost there!)', pt: 'Tentando novamente com permissões atualizadas, mais 2 min… (quase lá!)', es: 'Reintentando con permisos actualizados, 2 min más… (¡casi listo!)' },
+};
+
+function stepLabel(key, lang) {
+  const map = STEP_LABELS[key];
+  return map ? (map[lang] || map.en || key) : key;
+}
+
+function stepProgress(key, lang) {
+  const map = STEP_PROGRESS[key];
+  return map ? (map[lang] || map.en || key) : key;
+}
+
+/**
+ * Print the post-setup status block for a create-from-scratch result.
+ * Shows SHA-1, Firestore, Storage status with URLs for manual action when needed.
+ */
+function printCreateFromScratchStatus(result, tr) {
+  if (result.sha1Skipped) {
+    const err = (result.sha1Error || '').replace(/\s+/g, ' ').slice(0, 120);
+    if (result.sha1Skipped === 'api_failed') {
+      console.log(kleur.yellow(`  ⚠ SHA-1 não adicionado automaticamente. Motivo: ${err}`));
+    } else {
+      console.log(kleur.yellow(`  ⚠ SHA-1 não adicionado: ${result.sha1Skipped}`));
+    }
+    console.log(kleur.yellow(`     Adicione manualmente: Firebase Console → Configurações do projeto → Seus apps → Android → Adicionar impressão digital`));
+    if (result.sha1ManualUrl) console.log(kleur.cyan(`     ${result.sha1ManualUrl}`));
+  } else {
+    console.log(kleur.green(`  ✓ SHA-1 adicionado (Google Sign-In)`));
+  }
+
+  if (result.firestoreCreated) {
+    console.log(kleur.green(`  ✓ Firestore criado automaticamente`));
+  } else {
+    if (result.firestoreError) console.log(kleur.yellow(`  ⚠ Firestore não criado. Motivo: ${(result.firestoreError || '').slice(0, 100)}`));
+    else console.log(kleur.yellow(`  ⚠ Firestore não criado automaticamente`));
+    console.log(kleur.yellow(`     Ative manualmente no console:`));
+    console.log(kleur.cyan(`     ${result.firestoreUrl}`));
+  }
+
+  if (result.storageCreated) {
+    console.log(kleur.green(`  ✓ Firebase Storage criado automaticamente`));
+  } else {
+    if (result.storageError) console.log(kleur.yellow(`  ⚠ Storage não criado. Motivo: ${(result.storageError || '').slice(0, 100)}`));
+    else console.log(kleur.yellow(`  ⚠ Storage não criado automaticamente`));
+    console.log(kleur.yellow(`     Ative manualmente no console:`));
+    console.log(kleur.cyan(`     ${result.storageUrl}`));
+  }
+}
+
+function printSuccessCard(tr, answers, targetDir) {
+  const bar = kleur.gray('  ─────────────────────────────────────────────');
+  const folderName = path.basename(targetDir);
+  const consoleUrl = answers.backend === 'firebase' && answers.firebaseProjectId
+    ? `https://console.firebase.google.com/project/${answers.firebaseProjectId}`
+    : answers.backend === 'supabase'
+      ? 'https://supabase.com/dashboard'
+      : answers.apiBaseUrl || null;
+
+  console.log(`\n${bar}`);
+  console.log(kleur.bold(gradient(['#a78bfa', '#60a5fa'])(`  🎉 ${tr('new.success.title')}`)));
+  console.log(bar);
+  console.log('');
+  console.log(`  ${kleur.bold(tr('new.success.nextSteps'))}`);
+  console.log('');
+  console.log(`  ${kleur.dim('1.')} ${kleur.dim(tr('new.success.step.cd'))}`);
+  console.log(`     ${kleur.cyan(`cd ${folderName}`)}`);
+  console.log('');
+  console.log(`  ${kleur.dim('2.')} ${kleur.dim(tr('new.success.step.run'))}`);
+  console.log(`     ${kleur.cyan('kasy run')}`);
+  console.log(`     ${kleur.dim('(ou F5 no VS Code)')}`);
+  if (consoleUrl) {
+    console.log('');
+    console.log(`  ${kleur.dim('3.')} ${kleur.dim(tr('new.success.step.console'))}`);
+    console.log(`     ${kleur.cyan(consoleUrl)}`);
+  }
+  console.log('');
+  console.log(bar);
+  console.log('');
+}
+
+function printStepResult(step, lang = 'pt') {
+  if (step.skipped) {
+    const label = stepLabel(step.name, lang);
+    console.log(`  ${kleur.gray('⏭')}  ${kleur.gray(label)} ${kleur.gray('(skipped)')}`);
+    return;
+  }
+  const icon = step.ok ? kleur.green('✓') : kleur.red('✗');
+  const label = step.ok
+    ? kleur.white(stepLabel(step.name, lang))
+    : kleur.red(stepLabel(step.name, lang));
+  console.log(`  ${icon}  ${label}${step.detail ? kleur.gray(` — ${step.detail.split('\n')[0]}`) : ''}`);
+}
+
+function onCancel(tr) {
+  console.log(kleur.yellow(`\n  ${tr('new.firebase.error.aborted')}\n`));
+  process.exit(0);
+}
+
+async function promptSupabaseManual(tr, cancel) {
+  return prompts(
+    [
+      {
+        type: 'text',
+        name: 'supabaseUrl',
+        message: tr('prompt.supabase.url.enter'),
+        hint: 'https://xxxx.supabase.co',
+        validate: (v) => (v && v.trim() ? true : tr('prompt.supabase.url.required')),
+      },
+      {
+        type: 'text',
+        name: 'supabaseAnonKey',
+        message: tr('prompt.supabase.anonKey.enter'),
+        validate: (v) => (v && v.trim() ? true : tr('prompt.supabase.anonKey.required')),
+      },
+    ],
+    { onCancel: cancel }
+  );
+}
+
+// ── Module presets ────────────────────────────────────────────────────────────
+
+function buildPresets(audience) {
+  const catalog = getVisibleFeatures({ audience });
+  const named = ['starter', 'saas', 'content', 'full'];
+  const result = { none: [], custom: null };
+  for (const name of named) {
+    result[name] = catalog.filter((f) => f.defaultInPresets.includes(name)).map((f) => f.id);
+  }
+  return result;
+}
+
+const MODULE_PRESETS = buildPresets(KASY_AUDIENCE);
+
+// ── Main wizard ───────────────────────────────────────────────────────────────
+
+/**
+ * @param {string} directory - target directory (relative or absolute)
+ * @param {object} opts
+ * @param {string} [opts.language]     - language hint ('pt' | 'en' | 'es'). Uses stored preference if omitted.
+ * @param {string} [opts.backend]      - backend hint ('firebase' | 'supabase' | 'api'). Skips selection prompt if valid.
+ * @param {string} [opts.withModules]  - comma-separated modules to pre-select (e.g. 'revenuecat,sentry,ci').
+ */
+async function runNew(directory, { language: langHint = null, backend: backendHint = null, withModules = null, yes = false, project: projectHint = null } = {}) {
+  // ── 1. Language — use stored preference, or ask once and save ───────────
+  const storedLang = getStoredLanguage();
+  let language = storedLang;
+  if (!language) {
+    language = await promptLanguage(langHint);
+    setStoredLanguage(language);
+  }
+
+  const tr = createTranslator(language);
+  const cancel = () => onCancel(tr);
+
+  // ── 2. Environment checks (non-blocking — only warnings) ────────────────
+  const envChecks = [...getBaseChecks(), ...getPlatformChecks()];
+  await runChecks(envChecks, tr('new.checks.environment'), {
+    t: tr,
+    compact: true,
+    spinnerLabel: tr('new.checks.environment.checking'),
+    doneLabel: tr('new.checks.environment.done'),
+  });
+
+  printBanner(tr);
+
+  // Whether an explicit target directory was provided by the user
+  const hasExplicitDir = directory && directory !== '.';
+
+  // If no directory was given, we'll determine targetDir AFTER asking the app name
+  let targetDir = hasExplicitDir
+    ? path.resolve(process.cwd(), directory)
+    : null;
+
+  // Guard for explicit dir: must be empty or not exist
+  if (targetDir && await fs.pathExists(targetDir)) {
+    const contents = await fs.readdir(targetDir);
+    if (contents.length > 0) {
+      throw new Error(tr('new.firebase.error.dirNotEmpty', { path: targetDir }));
+    }
+  }
+
+  // ── 3. Backend selection (support pre-selection via --backend flag) ─────
+  let backend = normalizeBackend(backendHint);
+  if (!backend) {
+    const { backend: selectedBackend } = await prompts(
+      {
+        type: 'select',
+        name: 'backend',
+        message: tr('new.q.backend'),
+        choices: [
+          { title: '🔥 Firebase', description: tr('new.q.backend.firebase.desc'), value: 'firebase' },
+          { title: '🟢 Supabase', description: tr('new.q.backend.supabase.desc'), value: 'supabase' },
+          { title: '🔗 API REST', description: tr('new.q.backend.api.desc'),      value: 'api' },
+        ],
+        initial: 0,
+      },
+      { onCancel: cancel }
+    );
+    backend = selectedBackend;
+  } else {
+    const backendLabel = { firebase: '🔥 Firebase', supabase: '🟢 Supabase', api: '🔗 API REST' }[backend] || backend;
+    console.log(kleur.gray(`  Backend: ${kleur.white(backendLabel)}`));
+  }
+
+  // ── 3b. Backend tool checks (required — blocks if missing) ───────────────
+  const backendCheckKey = backend === 'api' ? 'restApi' : backend;
+  const backendChecks = getBackendChecks(backendCheckKey);
+  let backendCheckResults = [];
+  if (backendChecks.length > 0) {
+    if (backend === 'supabase' || backend === 'api') {
+      console.log(kleur.dim(`\n  ℹ ${tr('new.checks.firebaseForPush')}`));
+    }
+    const backendLabel = tr('setup.checks.backend', { backend }) || `  Checking ${backend} tools…`;
+    backendCheckResults = await runChecks(backendChecks, backendLabel, {
+      t: tr,
+      compact: true,
+      spinnerLabel: tr('setup.checks.backend.checking', { backend }) || `Checking ${backend} tools`,
+      doneLabel: tr('setup.checks.backend.done', { backend }) || `${backend} tools ready`,
+    });
+    if (hasRequiredFailures(backendCheckResults)) {
+      console.log(kleur.red(`\n  ✖ ${tr('new.checks.requiredBlock')}`));
+      console.log(kleur.dim(`\n  ${tr('new.checks.installFirebase')}`));
+      if (backend === 'supabase') {
+        const platform = process.platform === 'darwin' ? 'darwin' : process.platform === 'win32' ? 'win32' : 'linux';
+        const supabaseKey = `new.checks.installSupabase.${platform}`;
+        console.log(kleur.dim(`  ${tr(supabaseKey) || tr('new.checks.installSupabase')}`));
+      }
+      console.log('');
+      process.exit(1);
+    }
+  }
+
+  // ── 3c. Wizard mode — Quick (few questions) or Full (all options) ──────────
+  let isQuick = yes; // --yes implies Quick mode
+  if (!yes) {
+    const { wizardMode } = await prompts(
+      {
+        type: 'select',
+        name: 'wizardMode',
+        message: tr('new.q.mode'),
+        choices: [
+          { title: tr('new.q.mode.quick'),    value: 'quick' },
+          { title: tr('new.q.mode.advanced'), value: 'advanced' },
+        ],
+        initial: 0,
+      },
+      { onCancel: cancel }
+    );
+    isQuick = wizardMode === 'quick';
+  }
+
+  // ── 4b. Firebase setup mode (create vs existing) — ask first so prereqs are correct ─
+  // Firebase backend: full setup. Supabase/API: Firebase only for push notifications (FCM).
+  let firebaseSetupMode = 'existing';
+  if (!yes) {
+    if (backend === 'firebase') {
+      const { setupMode } = await prompts(
+        {
+          type: 'select',
+          name: 'setupMode',
+          message: tr('new.firebase.q.setupMode'),
+          choices: [
+            { title: tr('new.firebase.q.setupMode.create'), value: 'create' },
+            { title: tr('new.firebase.q.setupMode.existing'), value: 'existing' },
+          ],
+          initial: 0,
+        },
+        { onCancel: cancel }
+      );
+      firebaseSetupMode = setupMode;
+    } else if (backend === 'supabase' || backend === 'api') {
+      const { setupMode } = await prompts(
+        {
+          type: 'select',
+          name: 'setupMode',
+          message: tr('new.firebase.q.setupMode.push'),
+          choices: [
+            { title: tr('new.firebase.q.setupMode.create'), value: 'create' },
+            { title: tr('new.firebase.q.setupMode.existing'), value: 'existing' },
+          ],
+          initial: 0,
+        },
+        { onCancel: cancel }
+      );
+      firebaseSetupMode = setupMode;
+    }
+  }
+
+  // ── 4c. Backend-specific prerequisites (dynamic: only show what's not yet verified) ─
+  printPrerequisites(tr, backend, firebaseSetupMode, backendCheckResults);
+
+  // ── Firebase region — Quick mode uses default (us-central1) ──────────
+  let firebaseRegion = 'us-central1';
+  if (backend === 'firebase' && !isQuick) {
+    const { region } = await prompts(
+      {
+        type: 'select',
+        name: 'region',
+        message: tr('new.firebase.q.region'),
+        choices: [
+          { title: tr('new.firebase.q.region.us'),      value: 'us-central1' },
+          { title: tr('new.firebase.q.region.europe'),  value: 'europe-west1' },
+          { title: tr('new.firebase.q.region.brazil'),  value: 'southamerica-east1' },
+        ],
+        initial: 0,
+      },
+      { onCancel: cancel }
+    );
+    firebaseRegion = region || 'us-central1';
+  }
+
+  // ── Core questions (appName, bundleId) ────────────────────────────────────
+  const coreQuestions = [
+    {
+      type: 'text',
+      name: 'appName',
+      message: tr('new.firebase.q.appName'),
+      hint: tr('new.firebase.q.appName.hint'),
+      initial: hasExplicitDir ? path.basename(targetDir) : '',
+      validate: (v) => (v && v.trim() ? true : tr('new.firebase.q.appName.required')),
+    },
+    {
+      type: 'text',
+      name: 'bundleId',
+      message: tr('new.firebase.q.bundleId'),
+      hint: tr('new.firebase.q.bundleId.hint'),
+      initial: (prev, values) => {
+        const name = (values?.appName || prev || '').trim();
+        if (!name) return 'com.example.app';
+        const slug = name
+          .normalize('NFD')
+          .replace(/[\u0300-\u036f]/g, '')
+          .toLowerCase()
+          .replace(/[^a-z0-9]/g, '');
+        if (!slug || /^\d/.test(slug)) return 'com.example.app';
+        return `com.${slug}.app`;
+      },
+      validate: (v) => {
+        if (!v || !v.trim()) return tr('new.firebase.q.bundleId.required');
+        return /^[a-zA-Z][\w]*(\.[a-zA-Z][\w]*)+$/.test(v.trim())
+          ? true
+          : tr('new.firebase.q.bundleId.invalid');
+      },
+    },
+  ];
+  const needFirebaseProjectIdNow =
+    (backend === 'firebase' && firebaseSetupMode === 'existing') ||
+    ((backend === 'supabase' || backend === 'api') && firebaseSetupMode === 'existing');
+  if (needFirebaseProjectIdNow) {
+    coreQuestions.push({
+      type: 'text',
+      name: 'firebaseProjectId',
+      message: tr('new.firebase.q.projectId'),
+      hint: tr('new.firebase.q.projectId.hint') + (backend !== 'firebase' ? ' (FCM + Remote Config)' : ''),
+      validate: (v) => {
+        if (!v || !v.trim()) return tr('new.firebase.q.projectId.required');
+        const id = v.trim();
+        if (id.length < 6 || id.length > 30) return 'ID deve ter entre 6 e 30 caracteres (ex: meu-app-123)';
+        if (!/^[a-z][a-z0-9-]*[a-z0-9]$/.test(id)) return 'ID inválido: use letras minúsculas, números e hífens, começando com letra (ex: meu-app-123)';
+        return true;
+      },
+    });
+  }
+  let core;
+  if (yes) {
+    if (!hasExplicitDir) {
+      console.error(kleur.red(`\n  ✗ --yes requires an app name: kasy new MyApp --yes\n`));
+      process.exit(1);
+    }
+    const appName = path.basename(targetDir);
+    const slug = appName
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]/g, '');
+    const bundleId = (slug && !/^\d/.test(slug)) ? `com.${slug}.app` : 'com.example.app';
+    let firebaseProjectId = projectHint?.trim() || '';
+    if (!firebaseProjectId && backend === 'firebase') {
+      const { pid } = await prompts(
+        {
+          type: 'text',
+          name: 'pid',
+          message: tr('new.firebase.q.projectId'),
+          hint: tr('new.firebase.q.projectId.hint'),
+          validate: (v) => (v && v.trim() ? true : tr('new.firebase.q.projectId.required')),
+        },
+        { onCancel: cancel }
+      );
+      firebaseProjectId = pid?.trim() || '';
+    }
+    core = { appName, bundleId, firebaseProjectId };
+    console.log(kleur.gray(`  App:      ${kleur.white(appName)}`));
+    console.log(kleur.gray(`  Bundle:   ${kleur.white(bundleId)}`));
+    if (firebaseProjectId) console.log(kleur.gray(`  Project:  ${kleur.white(firebaseProjectId)}`));
+  } else {
+    core = await prompts(coreQuestions, { onCancel: cancel });
+  }
+
+  // ── Firebase: create from scratch (when selected) ─────────────────────────
+  let firebaseIncludeWeb = true;
+  if (backend === 'firebase' && firebaseSetupMode === 'create') {
+    const { includeWeb } = await prompts(
+      {
+        type: 'confirm',
+        name: 'includeWeb',
+        message: tr('new.firebase.create.includeWeb'),
+        initial: true,
+      },
+      { onCancel: cancel }
+    );
+    firebaseIncludeWeb = includeWeb !== false;
+    const gcloudCheck = await checkGcloudAuth();
+    if (!gcloudCheck.ok) {
+      console.log(kleur.red(`  ${tr('new.firebase.create.gcloudRequired')}`));
+      if (gcloudCheck.missing === 'gcloud') {
+        const instructions = getGcloudInstallInstructions();
+        console.log(kleur.cyan(`\n  ${tr('new.firebase.create.installTitle')}`));
+        if (instructions.install) {
+          console.log(kleur.white(`  ${tr('new.firebase.create.installCommand')}:`));
+          console.log(kleur.cyan(`    ${instructions.install}`));
+        }
+        if (instructions.hint) {
+          console.log(kleur.gray(`  ${instructions.hint}`));
+        }
+        console.log(kleur.white(`  ${tr('new.firebase.create.installAfter')}:`));
+        console.log(kleur.cyan(`    ${instructions.after}`));
+        console.log(kleur.gray(`  ${tr('new.firebase.create.installUrl')}: ${instructions.url}`));
+        console.log('');
+      } else {
+        console.log(kleur.cyan(`  ${tr('new.firebase.create.authCommand')}`));
+        console.log('');
+      }
+      console.log(kleur.yellow(`  ${tr('new.firebase.create.fallbackHint')}`));
+      const fallback = await prompts(
+        {
+          type: 'text',
+          name: 'firebaseProjectId',
+          message: tr('new.firebase.q.projectId'),
+          hint: tr('new.firebase.q.projectId.hint'),
+          validate: (v) => (v && v.trim() ? true : tr('new.firebase.q.projectId.required')),
+        },
+        { onCancel: cancel }
+      );
+      core.firebaseProjectId = fallback.firebaseProjectId;
+    } else {
+      const selectedOrgId = await promptOrganizationIfNeeded(tr, cancel);
+      let selectedBillingId = await promptBillingAccountIfNeeded(tr, cancel);
+      console.log(kleur.dim(`\n  ⏱  ${tr('new.firebase.create.estimatedTime')}`));
+      console.log(kleur.dim(`  ${tr('new.internet.warning')}\n`));
+      const ps1 = makeProgressSpinner();
+      ps1.next(tr('new.firebase.create.creating'));
+      const setupResult = await setupFromScratch(core.appName.trim(), core.bundleId.trim(), {
+        includeWeb: firebaseIncludeWeb,
+        region: firebaseRegion,
+        tr,
+        billingAccountId: selectedBillingId || undefined,
+        organizationId: selectedOrgId || undefined,
+        onProgress: (key, data) => {
+          if (key === 'wait-propagate') {
+            ps1.next(tr('new.firebase.create.waitPropagate'));
+          } else if (key === 'firestore') {
+            ps1.next(stepProgress('firestore', language));
+          } else if (key === 'storage') {
+            ps1.next(stepProgress('storage', language));
+          } else if (key === 'auth-providers-warn') {
+            ps1.stop();
+            console.log(kleur.yellow(`  ⚠ ${tr('new.firebase.interactive.authWarn')}`));
+            console.log(kleur.cyan(`     ${data?.url || ''}`));
+          }
+        },
+      });
+      if (setupResult.ok) {
+        ps1.succeed(tr('new.firebase.create.success'));
+        core.firebaseProjectId = setupResult.projectId;
+        console.log(kleur.dim(`  Project ID: ${core.firebaseProjectId}`));
+        printCreateFromScratchStatus(setupResult, tr);
+        const authUrl = `https://console.firebase.google.com/project/${core.firebaseProjectId}/authentication/providers`;
+        if (setupResult.authEnabled && !setupResult.googleSignInSkipped) {
+          // Email/Password, Anonymous AND Google Sign-In were all enabled automatically — skip prompt.
+        } else {
+          // At least one provider needs manual activation.
+          const step1Key = setupResult.googleSignInSkipped
+            ? 'new.firebase.create.beforeContinue.step1'
+            : 'new.firebase.create.beforeContinue.step1.noAuth';
+          const readyKey = setupResult.googleSignInSkipped
+            ? 'new.firebase.create.beforeContinue.ready'
+            : 'new.firebase.create.beforeContinue.ready.noAuth';
+          console.log(kleur.bold().yellow(`\n  ${tr('new.firebase.create.beforeContinue.title')}`));
+          console.log(kleur.gray(`  ${tr(step1Key)}`));
+          console.log(kleur.cyan(`     ${authUrl}`));
+          const { ready } = await prompts(
+            {
+              type: 'confirm',
+              name: 'ready',
+              message: tr(readyKey),
+              initial: true,
+            },
+            { onCancel: cancel }
+          );
+          if (!ready) {
+            console.log(kleur.gray(`  ${tr('prompt.cancelled')}`));
+            process.exit(0);
+          }
+        }
+
+      } else {
+        ps1.fail(tr('new.firebase.create.failed'));
+        let lastResult = setupResult;
+        while (lastResult.billingFailed && lastResult.projectId) {
+          console.log(kleur.red(`  ${tr('new.firebase.create.failed')}: ${lastResult.error}`));
+          console.log(kleur.yellow(`\n  ${tr('new.firebase.create.billingRetry.title')}`));
+          console.log(kleur.cyan(`     ${lastResult.billingManualLink}`));
+          console.log(kleur.gray(`  ${tr('new.firebase.create.billingRetry.hint')}`));
+          const { retry } = await prompts(
+            {
+              type: 'confirm',
+              name: 'retry',
+              message: tr('new.firebase.create.billingRetry.ready'),
+              initial: true,
+            },
+            { onCancel: cancel }
+          );
+          if (!retry) {
+            console.log(kleur.gray(`  ${tr('new.firebase.create.billingRetry.exit')}`));
+            console.log(kleur.cyan(`  ${tr('new.firebase.create.useExistingHint', { id: lastResult.projectId })}`));
+            process.exit(0);
+          }
+          console.log(kleur.gray(`  ${tr('new.firebase.create.billingRetry.retrying')}`));
+          selectedBillingId = await promptBillingAccountIfNeeded(tr, cancel);
+          const ps2 = makeProgressSpinner();
+          ps2.next(tr('new.firebase.create.creating'));
+          lastResult = await setupFromScratch(core.appName.trim(), core.bundleId.trim(), {
+                includeWeb: firebaseIncludeWeb,
+            region: firebaseRegion,
+            tr,
+            resumeFromBilling: { projectId: lastResult.projectId },
+            billingAccountId: selectedBillingId || undefined,
+            organizationId: selectedOrgId || undefined,
+            onProgress: (key) => {
+              if (key === 'wait-propagate') {
+                ps2.next(tr('new.firebase.create.waitPropagate'));
+              } else if (key === 'firestore') {
+                ps2.next(stepProgress('firestore', language));
+              } else if (key === 'storage') {
+                ps2.next(stepProgress('storage', language));
+              }
+            },
+          });
+          if (lastResult.ok) {
+            ps2.succeed(tr('new.firebase.create.success'));
+            core.firebaseProjectId = lastResult.projectId;
+            console.log(kleur.dim(`  Project ID: ${core.firebaseProjectId}`));
+            printCreateFromScratchStatus(lastResult, tr);
+            const authUrl = `https://console.firebase.google.com/project/${core.firebaseProjectId}/authentication/providers`;
+            if (lastResult.authEnabled && !lastResult.googleSignInSkipped) {
+              // All three providers enabled automatically — skip prompt.
+            } else {
+              const step1Key = lastResult.googleSignInSkipped
+                ? 'new.firebase.create.beforeContinue.step1'
+                : 'new.firebase.create.beforeContinue.step1.noAuth';
+              const lastReadyKey = lastResult.googleSignInSkipped
+                ? 'new.firebase.create.beforeContinue.ready'
+                : 'new.firebase.create.beforeContinue.ready.noAuth';
+              console.log(kleur.bold().yellow(`\n  ${tr('new.firebase.create.beforeContinue.title')}`));
+              console.log(kleur.gray(`  ${tr(step1Key)}`));
+              console.log(kleur.cyan(`     ${authUrl}`));
+              const { ready } = await prompts(
+                {
+                  type: 'confirm',
+                  name: 'ready',
+                  message: tr(lastReadyKey),
+                  initial: true,
+                },
+                { onCancel: cancel }
+              );
+              if (!ready) {
+                console.log(kleur.gray(`  ${tr('prompt.cancelled')}`));
+                process.exit(0);
+              }
+            }
+
+            break;
+          }
+        }
+        if (!lastResult.ok && !lastResult.billingFailed) {
+          const isProjectQuota = /exceeded your allotted project quota|project quota/i.test(String(lastResult.error || ''));
+          const msg = isProjectQuota ? tr('new.firebase.create.projectQuotaExceeded') : `${tr('new.firebase.create.failed')}: ${lastResult.error}`;
+          console.log(kleur.red(`  ${msg}`));
+          if (lastResult.projectId) {
+            core.firebaseProjectId = lastResult.projectId;
+            console.log(kleur.gray(`  ${tr('new.firebase.create.usingProjectId', { id: lastResult.projectId })}`));
+          } else {
+            const fallback = await prompts(
+              {
+                type: 'text',
+                name: 'firebaseProjectId',
+                message: tr('new.firebase.q.projectId'),
+                hint: tr('new.firebase.q.projectId.hint'),
+                validate: (v) => (v && v.trim() ? true : tr('new.firebase.q.projectId.required')),
+              },
+              { onCancel: cancel }
+            );
+            core.firebaseProjectId = fallback.firebaseProjectId;
+          }
+        }
+      }
+    }
+  }
+
+  // ── Firebase: create from scratch for Supabase/API (push notifications only) ─
+  if ((backend === 'supabase' || backend === 'api') && firebaseSetupMode === 'create') {
+    const gcloudCheck = await checkGcloudAuth();
+    if (!gcloudCheck.ok) {
+      console.log(kleur.red(`  ${tr('new.firebase.create.gcloudRequired')}`));
+      if (gcloudCheck.missing === 'gcloud') {
+        const instructions = getGcloudInstallInstructions();
+        console.log(kleur.cyan(`\n  ${tr('new.firebase.create.installTitle')}`));
+        if (instructions.install) {
+          console.log(kleur.white(`  ${tr('new.firebase.create.installCommand')}:`));
+          console.log(kleur.cyan(`    ${instructions.install}`));
+        }
+        if (instructions.hint) {
+          console.log(kleur.gray(`  ${instructions.hint}`));
+        }
+        console.log(kleur.white(`  ${tr('new.firebase.create.installAfter')}:`));
+        console.log(kleur.cyan(`    ${instructions.after}`));
+        console.log(kleur.gray(`  ${tr('new.firebase.create.installUrl')}: ${instructions.url}`));
+        console.log('');
+      } else {
+        console.log(kleur.cyan(`  ${tr('new.firebase.create.authCommand')}`));
+        console.log('');
+      }
+      console.log(kleur.yellow(`  ${tr('new.firebase.create.fallbackHint')}`));
+      const fallback = await prompts(
+        {
+          type: 'text',
+          name: 'firebaseProjectId',
+          message: tr('new.firebase.q.projectId'),
+          hint: tr('new.firebase.q.projectId.hint') + ' (FCM + Remote Config)',
+          validate: (v) => (v && v.trim() ? true : tr('new.firebase.q.projectId.required')),
+        },
+        { onCancel: cancel }
+      );
+      core.firebaseProjectId = fallback.firebaseProjectId;
+    } else {
+      const selectedOrgId = await promptOrganizationIfNeeded(tr, cancel);
+      const selectedBillingId = await promptBillingAccountIfNeeded(tr, cancel);
+      console.log(kleur.dim(`\n  ${tr('new.internet.warning')}\n`));
+      const ps3 = makeProgressSpinner();
+      ps3.next(tr('new.firebase.create.creatingPush'));
+      const setupResult = await setupFromScratch(core.appName.trim(), core.bundleId.trim(), {
+        includeWeb: true,
+        region: firebaseRegion,
+        tr,
+        billingAccountId: selectedBillingId || undefined,
+        organizationId: selectedOrgId || undefined,
+        onProgress: (key) => {
+          if (key === 'wait-propagate') {
+            ps3.next(tr('new.firebase.create.waitPropagate'));
+          } else if (key === 'firestore') {
+            ps3.next(stepProgress('firestore', language));
+          } else if (key === 'storage') {
+            ps3.next(stepProgress('storage', language));
+          }
+        },
+      });
+      if (setupResult.ok) {
+        ps3.succeed(tr('new.firebase.create.successPush'));
+        core.firebaseProjectId = setupResult.projectId;
+        console.log(kleur.dim(`  Project ID: ${core.firebaseProjectId}`));
+        printCreateFromScratchStatus(setupResult, tr);
+      } else {
+        ps3.fail(tr('new.firebase.create.failed'));
+        console.log(kleur.red(`  ${tr('new.firebase.create.failed')}: ${setupResult.error}`));
+        if (setupResult.projectId) {
+          core.firebaseProjectId = setupResult.projectId;
+          console.log(kleur.gray(`  ${tr('new.firebase.create.usingProjectId', { id: setupResult.projectId })}`));
+        } else {
+          const fallback = await prompts(
+            {
+              type: 'text',
+              name: 'firebaseProjectId',
+              message: tr('new.firebase.q.projectId'),
+              hint: tr('new.firebase.q.projectId.hint') + ' (FCM + Remote Config)',
+              validate: (v) => (v && v.trim() ? true : tr('new.firebase.q.projectId.required')),
+            },
+            { onCancel: cancel }
+          );
+          core.firebaseProjectId = fallback.firebaseProjectId;
+        }
+      }
+    }
+  }
+
+  // ── Backend-specific questions ───────────────────────────────────────────
+  let supabaseCreate = false;
+  let supabaseDbPassword = null;
+  let supabaseCreateResult = null;
+  /** When using existing project: { projectRef, supabaseUrl, supabaseAnonKey, dbPassword } */
+  let supabaseExistingResult = null;
+
+  if (backend === 'supabase') {
+    const { createSupabase } = await prompts(
+      {
+        type: 'select',
+        name: 'createSupabase',
+        message: tr('new.supabase.q.create'),
+        choices: [
+          { title: tr('new.supabase.q.create.create'), value: true },
+          { title: tr('new.supabase.q.create.existing'), value: false },
+        ],
+        initial: 0,
+      },
+      { onCancel: cancel }
+    );
+    supabaseCreate = createSupabase;
+
+    if (supabaseCreate) {
+      const loginCheck = await checkLoggedIn();
+      if (!loginCheck.ok) {
+        console.log(kleur.yellow(`  ${tr('new.supabase.loginRequired')}`));
+        console.log(kleur.cyan(`  ${tr('new.supabase.loginCommand')}`));
+        console.log('');
+      }
+      const orgsResult = await getOrgsList();
+      if (!orgsResult.ok || !orgsResult.orgs?.length) {
+        console.log(kleur.red(`  ${tr('new.supabase.orgsRequired')}`));
+        supabaseCreateResult = { ok: false, error: tr('new.supabase.orgsRequired') };
+      } else {
+        let orgId = orgsResult.orgs[0].id;
+        if (orgsResult.orgs.length > 1) {
+          const { selectedOrgId } = await prompts(
+            {
+              type: 'select',
+              name: 'selectedOrgId',
+              message: tr('new.supabase.q.orgSelect'),
+              choices: orgsResult.orgs.map((o) => ({ title: o.name, value: o.id })),
+            },
+            { onCancel: cancel }
+          );
+          orgId = selectedOrgId;
+        }
+        let supabaseRegion = DEFAULT_SUPABASE_REGION;
+        if (!isQuick) {
+          const { region } = await prompts(
+            {
+              type: 'select',
+              name: 'region',
+              message: tr('new.supabase.q.region'),
+              choices: [
+                { title: tr('new.supabase.q.region.brazil'), value: 'sa-east-1' },
+                { title: tr('new.supabase.q.region.us'),     value: 'us-east-1' },
+                { title: tr('new.supabase.q.region.europe'), value: 'eu-west-1' },
+                { title: tr('new.supabase.q.region.global'), value: 'us-east-1' },
+              ],
+              initial: 0,
+            },
+            { onCancel: cancel }
+          );
+          supabaseRegion = region || DEFAULT_SUPABASE_REGION;
+        }
+        const { dbPassword } = await prompts(
+          {
+            type: 'password',
+            name: 'dbPassword',
+            message: tr('new.supabase.q.dbPassword'),
+            validate: (v) => (v && v.length >= 6 ? true : tr('new.supabase.q.dbPassword.required')),
+          },
+          { onCancel: cancel }
+        );
+        supabaseDbPassword = dbPassword;
+        console.log(kleur.dim(`  ${tr('new.internet.warning')}`));
+        console.log(kleur.gray(`  ${tr('new.supabase.creating')}`));
+        supabaseCreateResult = await createProjectAndGetKeys(
+          core.appName.trim().replace(/\s+/g, '-').toLowerCase(),
+          supabaseDbPassword,
+          supabaseRegion,
+          orgId
+        );
+      }
+      if (supabaseCreateResult.ok) {
+        core.supabaseUrl = supabaseCreateResult.supabaseUrl;
+        core.supabaseAnonKey = supabaseCreateResult.supabaseAnonKey;
+        console.log(kleur.green(`  ✓ ${tr('new.supabase.created')}`));
+      } else {
+        console.log(kleur.red(`  ${tr('new.supabase.createFailed')}: ${supabaseCreateResult.error}`));
+        console.log(kleur.gray(`  ${tr('new.supabase.loginHint')}`));
+        Object.assign(core, await promptSupabaseManual(tr, cancel));
+        supabaseCreate = false;
+      }
+    } else {
+      // Usar projeto Supabase existente: org → projeto → keys → senha (mesmo fluxo de setup, sem criar)
+      const loginCheck = await checkLoggedIn();
+      if (!loginCheck.ok) {
+        console.log(kleur.yellow(`  ${tr('new.supabase.loginRequired')}`));
+        console.log(kleur.cyan(`  ${tr('new.supabase.loginCommand')}`));
+        console.log('');
+        Object.assign(core, await promptSupabaseManual(tr, cancel));
+      } else {
+        const orgsResult = await getOrgsList();
+        if (!orgsResult.ok || !orgsResult.orgs?.length) {
+          console.log(kleur.red(`  ${tr('new.supabase.orgsRequired')}`));
+          Object.assign(core, await promptSupabaseManual(tr, cancel));
+        } else {
+          let orgId = orgsResult.orgs[0].id;
+          if (orgsResult.orgs.length > 1) {
+            const { selectedOrgId } = await prompts(
+              { type: 'select', name: 'selectedOrgId', message: tr('new.supabase.q.useExisting.orgSelect'), choices: orgsResult.orgs.map((o) => ({ title: o.name, value: o.id })) },
+              { onCancel: cancel }
+            );
+            orgId = selectedOrgId;
+          }
+          const projectsResult = await getProjectsByOrg(orgId);
+          if (!projectsResult.ok || !projectsResult.projects?.length) {
+            console.log(kleur.yellow(`  ${tr('new.supabase.projectsRequired')}`));
+            Object.assign(core, await promptSupabaseManual(tr, cancel));
+          } else {
+            const { selectedProjectRef } = await prompts(
+              {
+                type: 'select',
+                name: 'selectedProjectRef',
+                message: tr('new.supabase.q.useExisting.projectSelect'),
+                choices: projectsResult.projects.map((p) => ({ title: `${p.name} (${p.id})`, value: p.id })),
+              },
+              { onCancel: cancel }
+            );
+            const keysResult = await getProjectKeys(selectedProjectRef);
+            if (!keysResult.ok) {
+              console.log(kleur.red(`  ${keysResult.error}`));
+              Object.assign(core, await promptSupabaseManual(tr, cancel));
+            } else {
+              core.supabaseUrl = keysResult.supabaseUrl;
+              core.supabaseAnonKey = keysResult.supabaseAnonKey;
+              const { dbPassword } = await prompts(
+                {
+                  type: 'password',
+                  name: 'dbPassword',
+                  message: tr('new.supabase.q.dbPassword.existing'),
+                  validate: (v) => (v && v.length >= 6 ? true : tr('new.supabase.q.dbPassword.required')),
+                },
+                { onCancel: cancel }
+              );
+              supabaseExistingResult = {
+                ok: true,
+                projectRef: selectedProjectRef,
+                supabaseUrl: keysResult.supabaseUrl,
+                supabaseAnonKey: keysResult.supabaseAnonKey,
+                dbPassword,
+              };
+              console.log(kleur.green(`  ✓ ${tr('new.supabase.existingLinked')}`));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // ── Supabase: Google Sign-In credentials resolved automatically after build ─
+  // (No prompts — web/iOS client IDs come from google-services.json /
+  //  GoogleService-Info.plist; secret fetched from Identity Toolkit API)
+  let googleWebClientId = '';
+  let googleClientSecret = '';
+  let googleIosClientId = '';
+
+  if (backend === 'api') {
+    const api = await prompts(
+      {
+        type: 'text',
+        name: 'apiBaseUrl',
+        message: tr('new.api.q.baseUrl'),
+        hint: tr('new.api.q.baseUrl.hint'),
+        initial: 'https://api.example.com',
+      },
+      { onCancel: cancel }
+    );
+    Object.assign(core, api);
+  }
+
+  // Resolve targetDir now that we have the app name
+  if (!targetDir) {
+    const folderName = toPackageName(core.appName.trim());
+    targetDir = path.resolve(process.cwd(), folderName);
+    // Guard: derived dir must not already exist
+    if (await fs.pathExists(targetDir)) {
+      const contents = await fs.readdir(targetDir);
+      if (contents.length > 0) {
+        throw new Error(tr('new.firebase.error.dirNotEmpty', { path: targetDir }));
+      }
+    }
+  }
+
+  // ── Firebase existing project: enable APIs + create Firestore/Storage ───
+  if (backend === 'firebase' && firebaseSetupMode === 'existing' && core.firebaseProjectId) {
+    const ps4 = makeProgressSpinner();
+    ps4.next(stepProgress('enable-apis', language));
+    const existingSetup = await setupExistingProject(core.firebaseProjectId, {
+      onProgress: (key, data) => {
+        if (key === 'enable-apis') {
+          ps4.next(stepProgress('enable-apis', language));
+        } else if (key === 'enable-apis-warn') {
+          ps4.warn(`${tr('new.firebase.create.failed')}: APIs`);
+          console.log(kleur.yellow(`  ⚠ Não foi possível ativar APIs: ${(data?.error || '').slice(0, 80)}`));
+        } else if (key === 'firestore') {
+          ps4.next(stepProgress('firestore', language));
+        } else if (key === 'storage') {
+          ps4.next(stepProgress('storage', language));
+        } else if (key === 'auth-providers-warn') {
+          ps4.stop();
+          console.log(kleur.yellow(`  ⚠ ${tr('new.firebase.interactive.authWarn')}`));
+          console.log(kleur.cyan(`     ${data?.url || ''}`));
+        } else if (key === 'auth-google-warn') {
+          ps4.stop();
+          console.log(kleur.yellow(`  ⚠ Google Sign-In: ative manualmente em Authentication → Sign-in method → Google`));
+          console.log(kleur.cyan(`     ${data?.url || ''}`));
+        }
+      },
+    });
+    if (existingSetup.firestoreCreated) {
+      ps4.succeed(stepLabel('firestore', language));
+    } else if (existingSetup.firestoreError && !existingSetup.firestoreError.includes('ALREADY_EXISTS')) {
+      ps4.fail(`Firestore: ${(existingSetup.firestoreError || '').slice(0, 80)}`);
+      console.log(kleur.cyan(`     ${existingSetup.firestoreUrl}`));
+    } else {
+      ps4.stop();
+    }
+    if (existingSetup.storageCreated) {
+      console.log(kleur.green(`  ✔ ${stepLabel('storage', language)}`));
+    } else if (existingSetup.storageError && !existingSetup.storageError.includes('ALREADY_EXISTS')) {
+      console.log(kleur.yellow(`  ⚠ Storage: ${(existingSetup.storageError || '').slice(0, 80)}`));
+      console.log(kleur.cyan(`     ${existingSetup.storageUrl}`));
+    }
+    console.log('');
+  }
+
+  // ── Optional modules ────────────────────────────────────────────────────
+  // --with flag pre-selects modules and bypasses preset selection entirely.
+  const preselectedModules = withModules
+    ? String(withModules).split(',').map((m) => m.trim().toLowerCase()).filter(Boolean)
+    : [];
+
+  let modules = [];
+
+  if (preselectedModules.length > 0) {
+    // --with flag was passed: use those modules directly, skip preset prompt.
+    modules = preselectedModules;
+  } else if (isQuick) {
+    // Quick mode: show preset picker (no multiselect).
+    const { preset } = await prompts(
+      {
+        type: 'select',
+        name: 'preset',
+        message: tr('new.q.preset'),
+        choices: [
+          { title: tr('new.q.preset.starter'), value: 'starter' },
+          { title: tr('new.q.preset.saas'),    value: 'saas' },
+          { title: tr('new.q.preset.content'), value: 'content' },
+          { title: tr('new.q.preset.full'),    value: 'full' },
+          { title: tr('new.q.preset.none'),    value: 'none' },
+        ],
+        initial: 0,
+      },
+      { onCancel: cancel }
+    );
+    modules = MODULE_PRESETS[preset] || [];
+  } else {
+    // Advanced mode: full multiselect — built from catalog, filtered by audience + backend.
+    const visibleFeatures = getVisibleFeatures({ audience: KASY_AUDIENCE, backend });
+
+    // web has an extra runtime constraint: firebase create-mode only
+    const isWebExcluded = backend === 'firebase' && firebaseSetupMode === 'create';
+
+    // Visual groups in display order (header key → feature ids in this group)
+    const groups = [
+      { header: null,                              ids: ['sentry', 'analytics', 'facebook'] },
+      { header: 'new.modules.header.monetization', ids: ['revenuecat'] },
+      { header: 'new.modules.header.features',     ids: ['onboarding', 'web', 'widget', 'llm_chat', 'local_notifications'] },
+      { header: 'new.modules.header.feedback',     ids: ['feedback'] },
+      { header: 'new.modules.header.ci',           ids: ['ci'] },
+    ];
+
+    const moduleChoices = [];
+    for (const group of groups) {
+      const inGroup = visibleFeatures.filter((f) => {
+        if (!group.ids.includes(f.id)) return false;
+        if (f.id === 'web' && isWebExcluded) return false;
+        return true;
+      });
+      if (inGroup.length === 0) continue;
+      if (group.header) {
+        moduleChoices.push({ title: tr(group.header), value: `__header_${group.header}__`, disabled: true });
+      }
+      for (const f of inGroup) {
+        const label = tr(`new.firebase.module.${f.id}`) + (f.status === 'internal' ? ' [beta]' : '');
+        moduleChoices.push({ title: label, value: f.id, selected: false });
+      }
+    }
+
+    const { modules: rawModules } = await prompts(
+      {
+        type: 'multiselect',
+        name: 'modules',
+        message: tr('new.firebase.q.modules'),
+        hint: tr('new.firebase.q.modules.hint'),
+        instructions: tr('prompt.multiselect.instructions'),
+        choices: moduleChoices,
+        min: 0,
+        warn: tr('prompt.multiselect.warnDisabled'),
+      },
+      { onCancel: cancel }
+    );
+    modules = (rawModules || []).filter((m) => !String(m).startsWith('__header_'));
+  }
+
+  if (backend === 'firebase' && firebaseSetupMode === 'create' && firebaseIncludeWeb) {
+    modules = [...new Set([...modules, 'web'])];
+  }
+
+  // ── Module-specific questions ───────────────────────────────────────────
+  const moduleAnswers = {};
+
+  if (modules.includes('revenuecat')) {
+    const rc = await prompts(
+      [
+        {
+          type: 'text',
+          name: 'rcAndroidKey',
+          message: tr('new.firebase.q.revenuecat.android'),
+          validate: (v) => (v && v.trim() ? true : tr('new.firebase.q.revenuecat.android.required')),
+        },
+        {
+          type: 'text',
+          name: 'rcIosKey',
+          message: tr('new.firebase.q.revenuecat.ios'),
+          validate: (v) => (v && v.trim() ? true : tr('new.firebase.q.revenuecat.ios.required')),
+        },
+        {
+          type: 'select',
+          name: 'defaultPaywall',
+          message: tr('new.firebase.q.paywall'),
+          hint: tr('new.firebase.q.paywall.hint'),
+          choices: [
+            { title: 'Basic (list of plans)', value: 'basic' },
+            { title: 'With trial switch', value: 'withSwitch' },
+            { title: 'Row + comparison table', value: 'basicRow' },
+            { title: 'Minimal (benefits + CTA)', value: 'minimal' },
+          ],
+          initial: 0,
+        },
+      ],
+      { onCancel: cancel }
+    );
+    Object.assign(moduleAnswers, rc);
+  }
+
+  // RC web key — only in advanced mode (optional credential, can configure later).
+  if (!isQuick && modules.includes('revenuecat') && modules.includes('web')) {
+    const rcWebKey = await prompts(
+      {
+        type: 'text',
+        name: 'rcWebKey',
+        message: tr('new.firebase.q.revenuecat.webKey'),
+        validate: (v) => {
+          if (!v || !v.trim()) return true; // optional — blank is fine
+          return /^rcb_/.test(v.trim()) ? true : tr('new.firebase.q.revenuecat.webKey.invalid');
+        },
+      },
+      { onCancel: cancel }
+    );
+    Object.assign(moduleAnswers, {
+      revenuecatWeb: true,
+      rcWebKey: (rcWebKey.rcWebKey || '').trim(),
+    });
+  } else if (modules.includes('revenuecat') && modules.includes('web')) {
+    // Quick mode: mark web billing as included but key will be configured later.
+    moduleAnswers.revenuecatWeb = true;
+    moduleAnswers.rcWebKey = '';
+  }
+
+  // Sentry DSN — already optional (blank = configure later). Skip in quick mode.
+  if (!isQuick && modules.includes('sentry')) {
+    const s = await prompts(
+      {
+        type: 'text',
+        name: 'sentryDsn',
+        message: tr('new.firebase.q.sentry.dsn'),
+        validate: (v) => {
+          if (!v || !v.trim()) return true; // optional — blank is fine
+          return /^https?:\/\/[^@\s]+@[^/\s]+\/\d+$/.test(v.trim())
+            ? true
+            : tr('new.firebase.q.sentry.dsn.invalid');
+        },
+      },
+      { onCancel: cancel }
+    );
+    Object.assign(moduleAnswers, s);
+  }
+
+  // Mixpanel token — already optional. Skip in quick mode.
+  if (!isQuick && modules.includes('analytics')) {
+    const mx = await prompts(
+      {
+        type: 'text',
+        name: 'mixpanelToken',
+        message: tr('new.firebase.q.mixpanel.token'),
+      },
+      { onCancel: cancel }
+    );
+    Object.assign(moduleAnswers, mx);
+  }
+
+  // LLM Chat credentials — skip in quick mode, all fields optional.
+  if (!isQuick && modules.includes('llm_chat')) {
+    const { configureLlmNow } = await prompts(
+      {
+        type: 'confirm',
+        name: 'configureLlmNow',
+        message: tr('new.q.llm_chat.configureNow'),
+        hint: tr('new.q.llm_chat.configureNow.hint'),
+        initial: true,
+      },
+      { onCancel: cancel }
+    );
+
+    if (configureLlmNow) {
+      const llm = await prompts(
+        [
+          {
+            type: 'select',
+            name: 'llmProvider',
+            message: tr('add.prompt.llmProvider'),
+            choices: [
+              { title: 'OpenAI (gpt-4o-mini)', value: 'openai' },
+              { title: 'Google Gemini (gemini-1.5-flash)', value: 'gemini' },
+            ],
+            initial: 0,
+          },
+          {
+            type: 'text',
+            name: 'llmSystemPrompt',
+            message: tr('add.prompt.llmSystemPrompt'),
+          },
+          {
+            type: 'text',
+            name: 'llmApiKey',
+            message: tr('add.prompt.llmApiKey'),
+          },
+        ],
+        { onCancel: cancel }
+      );
+      Object.assign(moduleAnswers, llm);
+    } else {
+      moduleAnswers.llmConfigureLater = true;
+    }
+  } else if (isQuick && modules.includes('llm_chat')) {
+    moduleAnswers.llmConfigureLater = true;
+  }
+
+  // Facebook — required credentials, always ask.
+  if (modules.includes('facebook')) {
+    const fb = await prompts(
+      [
+        {
+          type: 'text',
+          name: 'fbAppId',
+          message: tr('new.firebase.q.facebook.appId'),
+          validate: (v) => {
+            if (!v || !v.trim()) return tr('new.firebase.q.facebook.appId.required');
+            return /^\d+$/.test(v.trim()) ? true : tr('new.firebase.q.facebook.appId.invalid');
+          },
+        },
+        {
+          type: 'text',
+          name: 'fbToken',
+          message: tr('new.firebase.q.facebook.token'),
+          validate: (v) => (v && v.trim() ? true : tr('new.firebase.q.facebook.token.required')),
+        },
+      ],
+      { onCancel: cancel }
+    );
+    Object.assign(moduleAnswers, fb);
+  }
+
+  // Server secrets (webhook, Meta Ads) — skip in quick mode, configure later via `kasy deploy`.
+  if (!isQuick && modules.includes('revenuecat') && (backend === 'supabase' || backend === 'firebase')) {
+    const { configureSecretsNow } = await prompts(
+      {
+        type: 'confirm',
+        name: 'configureSecretsNow',
+        message: tr('new.firebase.q.secrets.configureNow'),
+        hint: tr('new.firebase.q.secrets.configureNow.hint'),
+        initial: true,
+      },
+      { onCancel: cancel }
+    );
+
+    if (configureSecretsNow) {
+      const rcSecrets = await prompts(
+        [
+          {
+            type: 'text',
+            name: 'rcWebhookKey',
+            message: tr('new.firebase.q.revenuecat.webhookKey'),
+            initial: generateWebhookKey(),
+            hint: tr('new.firebase.q.revenuecat.webhookKey.hint'),
+          },
+          {
+            type: 'text',
+            name: 'metaAccessToken',
+            message: tr('new.firebase.q.revenuecat.metaToken'),
+          },
+          {
+            type: 'text',
+            name: 'metaDatasetId',
+            message: tr('new.firebase.q.revenuecat.metaDataset'),
+            validate: (v) => {
+              if (!v || !v.trim()) return true; // optional — blank is fine
+              return /^\d+$/.test(v.trim()) ? true : tr('new.firebase.q.revenuecat.metaDataset.invalid');
+            },
+          },
+        ],
+        { onCancel: cancel }
+      );
+      Object.assign(moduleAnswers, rcSecrets);
+    } else {
+      moduleAnswers.secretsConfigureLater = true;
+    }
+  } else if (isQuick && modules.includes('revenuecat')) {
+    // Quick mode: always defer secrets to `kasy deploy`.
+    moduleAnswers.secretsConfigureLater = true;
+  }
+
+  // ── Deploy is now a separate command (`kasy deploy`) ─────────────
+  // Deploy is never run during `new` — the project is generated and ready,
+  // and the user deploys when they choose with `kasy deploy`.
+  const deploy = false;
+
+  // ── Summary ─────────────────────────────────────────────────────────────
+  const answers = {
+    appName: core.appName.trim(),
+    bundleId: core.bundleId.trim(),
+    firebaseProjectId: core.firebaseProjectId.trim(),
+    modules: modules || [],
+    backend,
+    includeWeb: backend === 'firebase' ? firebaseIncludeWeb : true,
+    supabaseUrl: core.supabaseUrl?.trim(),
+    supabaseAnonKey: core.supabaseAnonKey?.trim(),
+    apiBaseUrl: core.apiBaseUrl?.trim(),
+  };
+
+  printSummary(tr, answers);
+
+  if (!yes) {
+    const { proceed } = await prompts(
+      {
+        type: 'confirm',
+        name: 'proceed',
+        message: tr('new.firebase.confirm.proceed'),
+        initial: true,
+      },
+      { onCancel: cancel }
+    );
+    if (!proceed) {
+      console.log(kleur.gray(`\n  ${tr('prompt.cancelled')}\n`));
+      process.exit(0);
+    }
+  }
+
+  // ── Generate ────────────────────────────────────────────────────────────
+  console.log('');
+  const spinner = ora(stepProgress('project-setup', language)).start();
+
+  let result;
+  try {
+    if (backend === 'supabase') {
+      result = await generateSupabaseProject(targetDir, {
+        appName: answers.appName,
+        bundleId: answers.bundleId,
+        firebaseProjectId: answers.firebaseProjectId,
+        supabaseUrl: answers.supabaseUrl,
+        supabaseAnonKey: answers.supabaseAnonKey,
+        modules: answers.modules,
+        moduleAnswers,
+        language,
+        onProgress: (key) => {
+          spinner.text = kleur.cyan(stepProgress(key, language));
+        },
+      });
+    } else if (backend === 'api') {
+      result = await generateApiProject(targetDir, {
+        appName: answers.appName,
+        bundleId: answers.bundleId,
+        firebaseProjectId: answers.firebaseProjectId,
+        apiBaseUrl: answers.apiBaseUrl,
+        modules: answers.modules,
+        moduleAnswers,
+        language,
+        onProgress: (key) => {
+          spinner.text = kleur.cyan(stepProgress(key, language));
+        },
+      });
+    } else {
+      result = await generateFirebaseProject(targetDir, {
+        appName: answers.appName,
+        bundleId: answers.bundleId,
+        firebaseProjectId: answers.firebaseProjectId,
+        deploy,
+        modules: answers.modules,
+        moduleAnswers,
+        includeWeb: answers.includeWeb !== false,
+        functionsRegion: firebaseRegion,
+        language,
+        onProgress: (key) => {
+          spinner.text = kleur.cyan(stepProgress(key, language));
+        },
+      });
+    }
+    spinner.stop();
+  } catch (err) {
+    spinner.fail(kleur.red(err.message));
+    throw err;
+  }
+
+  // Save deploy metadata for `kasy deploy` auto-detect
+  if (backend === 'firebase') {
+    try {
+      const kasyDir = path.join(targetDir, '.kasy');
+      await fs.ensureDir(kasyDir);
+      await fs.writeJson(path.join(kasyDir, 'config.json'), { functionsRegion: firebaseRegion }, { spaces: 2 });
+    } catch (_) {}
+
+    // Write functions/.env with LLM non-secret vars (provider + system prompt)
+    if (modules.includes('llm_chat') && !moduleAnswers.llmConfigureLater) {
+      try {
+        const envLines = [];
+        if (moduleAnswers.llmProvider) envLines.push(`LLM_PROVIDER=${moduleAnswers.llmProvider}`);
+        if (moduleAnswers.llmSystemPrompt?.trim()) envLines.push(`LLM_SYSTEM_PROMPT=${moduleAnswers.llmSystemPrompt.trim()}`);
+        if (envLines.length > 0) {
+          await fs.ensureDir(path.join(targetDir, 'functions'));
+          await fs.appendFile(path.join(targetDir, 'functions', '.env'), envLines.join('\n') + '\n', 'utf8');
+        }
+      } catch (_) {}
+    }
+  }
+
+  // ── Results ─────────────────────────────────────────────────────────────
+  console.log('');
+  result.steps.forEach((s) => printStepResult(s, language));
+
+  // ── Supabase: link + db push + functions deploy (when project was created or existing selected) ─
+  const supabaseSetupPayload = (supabaseCreate && supabaseCreateResult?.ok)
+    ? { projectRef: supabaseCreateResult.projectRef, dbPassword: supabaseDbPassword }
+    : (supabaseExistingResult?.ok ? { projectRef: supabaseExistingResult.projectRef, dbPassword: supabaseExistingResult.dbPassword } : null);
+
+  if (backend === 'supabase') {
+    // ── Auto-resolve Google credentials from flutterfire output files ────────
+    const flutterfireOk = result.steps.find((s) => s.name === 'flutterfire')?.ok;
+    if (flutterfireOk) {
+      const fileCreds = await readSupabaseGoogleCredentials(targetDir);
+      googleWebClientId = fileCreds.webClientId;
+      googleIosClientId = fileCreds.iosClientId;
+
+      // Enable Google Sign-In in Firebase Auth so Identity Toolkit stores the client secret.
+      // This is the same step that setupFromScratch runs for Firebase backend.
+      // For Supabase, Firebase Auth is not used for auth, but enabling Google here is the
+      // only way to make the client secret available via the Identity Toolkit API.
+      // Non-fatal: silently ignored if it fails (e.g. API not yet propagated).
+      if (answers.firebaseProjectId) {
+        await enableAuthProviders(answers.firebaseProjectId);
+      }
+
+      // Try to get the Client Secret from Identity Toolkit API (requires gcloud auth)
+      if (answers.firebaseProjectId && googleWebClientId) {
+        googleClientSecret = await getGoogleClientSecretViaGcloud(answers.firebaseProjectId);
+      }
+
+      // Always write google_auth_options.dart with whatever credentials we have
+      if (googleWebClientId) {
+        const gaResult = await writeSupabaseGoogleAuthOptions(targetDir, googleWebClientId, googleIosClientId);
+        printStepResult({ name: 'google-auth-options', ok: gaResult.ok, detail: gaResult.error }, language);
+      }
+    }
+
+    if (supabaseSetupPayload) {
+      // ── FCM Service Account key (best effort via gcloud — Firebase uses ADC, Supabase needs JSON) ──
+      let fcmServiceAccountJson = null;
+      if (answers.firebaseProjectId) {
+        const fcmSpinner = ora(kleur.cyan('Gerando chave FCM (Service Account)…')).start();
+        const fcmResult = await createFcmServiceAccountKey(answers.firebaseProjectId);
+        if (fcmResult.ok) {
+          fcmServiceAccountJson = fcmResult.json;
+          fcmSpinner.stop();
+          printStepResult({ name: 'fcm-key', ok: true }, language);
+        } else {
+          fcmSpinner.stop();
+          printStepResult({ name: 'fcm-key', ok: false, detail: 'configure FIREBASE_SERVICE_ACCOUNT_JSON manualmente' }, language);
+        }
+      }
+
+      const setupSpinner = ora(kleur.cyan(tr('new.supabase.setup'))).start();
+      try {
+        const secrets = {
+          firebaseProjectId: answers.firebaseProjectId,
+          ...(fcmServiceAccountJson ? { firebaseServiceAccountJson: fcmServiceAccountJson } : {}),
+          ...(answers.modules?.includes('revenuecat') ? {
+            rcWebhookKey: moduleAnswers.rcWebhookKey,
+            metaAccessToken: moduleAnswers.metaAccessToken,
+            metaDatasetId: moduleAnswers.metaDatasetId,
+          } : {}),
+          ...(answers.modules?.includes('llm_chat') && !moduleAnswers.llmConfigureLater ? {
+            llmApiKey: moduleAnswers.llmApiKey,
+            llmProvider: moduleAnswers.llmProvider,
+            llmSystemPrompt: moduleAnswers.llmSystemPrompt,
+          } : {}),
+        };
+        const google = googleWebClientId && googleClientSecret
+          ? { webClientId: googleWebClientId, clientSecret: googleClientSecret }
+          : {};
+        const setupSteps = await setupLinkedProject(
+          targetDir,
+          supabaseSetupPayload.projectRef,
+          supabaseSetupPayload.dbPassword,
+          secrets,
+          google
+        );
+        setupSpinner.stop();
+        setupSteps.forEach((s) => printStepResult(s, language));
+      } catch (err) {
+        setupSpinner.fail(kleur.red(err.message));
+        console.log(kleur.yellow(`  ${tr('new.supabase.setupManual')}`));
+      }
+    }
+  }
+
+  // ── API: FCM Service Account key — save to .kasy/ for server configuration ──
+  if (backend === 'api' && answers.firebaseProjectId) {
+    const fcmSpinner = ora(kleur.cyan('Gerando chave FCM (Service Account)…')).start();
+    const fcmResult = await createFcmServiceAccountKey(answers.firebaseProjectId);
+    if (fcmResult.ok) {
+      fcmSpinner.stop();
+      try {
+        const kasyDir = path.join(targetDir, '.kasy');
+        await fs.ensureDir(kasyDir);
+        await fs.writeFile(path.join(kasyDir, 'fcm-service-account.json'), fcmResult.json, 'utf8');
+        // Ensure this credential file is not committed to git
+        const gitignorePath = path.join(targetDir, '.gitignore');
+        const gitignoreEntry = '.kasy/fcm-service-account.json';
+        if (await fs.pathExists(gitignorePath)) {
+          const existing = await fs.readFile(gitignorePath, 'utf8');
+          if (!existing.includes(gitignoreEntry)) {
+            await fs.appendFile(gitignorePath, `\n# FCM service account key (credentials — do not commit)\n${gitignoreEntry}\n`, 'utf8');
+          }
+        }
+        printStepResult({ name: 'fcm-key-saved', ok: true }, language);
+        console.log(kleur.gray(`     Configure no servidor: FIREBASE_SERVICE_ACCOUNT_JSON="$(cat .kasy/fcm-service-account.json)"`));
+      } catch (_) {
+        printStepResult({ name: 'fcm-key-saved', ok: false, detail: 'salvar arquivo de chave falhou' }, language);
+      }
+    } else {
+      fcmSpinner.stop();
+      printStepResult({ name: 'fcm-key', ok: false, detail: 'configure FIREBASE_SERVICE_ACCOUNT_JSON manualmente' }, language);
+    }
+  }
+
+  // ── SHA-1: register debug keystore for existing Firebase projects (all backends) ──
+  // setupFromScratch already handles SHA-1 for new-project flow.
+  // For existing projects, flutterfire configure registers the Android app but does NOT add SHA-1.
+  // Without SHA-1, google_sign_in v7+ Credential Manager fails on Android with:
+  // "CredManProvService: GetCredentialResponse error returned from framework"
+  if (answers.firebaseProjectId && firebaseSetupMode === 'existing') {
+    const flutterfireOkForSha1 = result.steps.find((s) => s.name === 'flutterfire')?.ok;
+    if (flutterfireOkForSha1) {
+      const sha1Spinner = ora(kleur.cyan('Registrando SHA-1 (Google Sign-In Android)…')).start();
+      const sha1Result = await registerDebugSha1(answers.firebaseProjectId, answers.bundleId);
+      sha1Spinner.stop();
+      if (sha1Result.ok) {
+        if (!sha1Result.existed) {
+          printStepResult({ name: 'sha1', ok: true }, language);
+        }
+        // existed === true → already registered, silent success
+      } else {
+        console.log(kleur.yellow(`  ⚠ SHA-1 não adicionado automaticamente: ${(sha1Result.sha1Error || '').slice(0, 120)}`));
+        console.log(kleur.yellow(`     Adicione manualmente para o Google Sign-In funcionar no Android:`));
+        console.log(kleur.cyan(`     https://console.firebase.google.com/project/${answers.firebaseProjectId}/settings/general/android:${answers.bundleId}`));
+      }
+    }
+  }
+
+  const flutterfireStep = result.steps.find((s) => s.name === 'flutterfire');
+  if (flutterfireStep && !flutterfireStep.ok) {
+    const platforms = answers.includeWeb !== false ? 'android,ios,web' : 'android,ios';
+    console.log(kleur.yellow(`\n  ${tr('new.firebase.warn.flutterfire')}`));
+    console.log(kleur.yellow(`  ${tr('new.firebase.warn.flutterfire.manual')}`));
+    console.log(
+      kleur.cyan(
+        `  dart pub global run flutterfire_cli:flutterfire configure` +
+        ` --project=${answers.firebaseProjectId}` +
+        ` --out lib/firebase_options_dev.dart --platforms=${platforms} --yes`
+      )
+    );
+  }
+
+  // ── APNs reminder (all backends — required for iOS push notifications) ───────
+  // Cannot be automated: the .p8 key only exists in Apple Developer Portal.
+  if (answers.firebaseProjectId) {
+    console.log('');
+    console.log(kleur.bold().yellow(`  ⚠  Push iOS: configure a APNs Key no Firebase Console`));
+    console.log(kleur.gray(`     1. Apple Developer Portal → Keys → criar APNs Key (.p8)`));
+    console.log(kleur.gray(`     2. Firebase Console → Cloud Messaging → app iOS → fazer upload da APNs Key`));
+    console.log(kleur.cyan(`     https://console.firebase.google.com/project/${answers.firebaseProjectId}/settings/cloudmessaging`));
+  }
+
+  printSuccessCard(tr, answers, targetDir);
+
+}
+
+module.exports = { runNew };