kasy-cli 1.16.0 → 1.18.0

package/lib/commands/configure.js

@@ -0,0 +1,548 @@
+/**
+ * `kasy configure` — interactive credential wizard, features-aware.
+ *
+ * Reads kit_setup.json + features.dart to know which features the project
+ * actually uses, then asks only for the credentials those features need.
+ * Idempotent: skips what's already filled, lets the user skip any field with
+ * Enter, and persists to the correct destination (.env, functions/.env, or
+ * Firebase Secret Manager).
+ *
+ * Out of scope (handled separately): Facebook (Info.plist + strings.xml),
+ * Apple Sign-In (Firebase Console only), APNs key (Apple Developer Portal).
+ */
+
+const path = require('node:path');
+const os = require('node:os');
+const { promisify } = require('node:util');
+const execAsync = promisify(require('node:child_process').exec);
+const fs = require('fs-extra');
+const kleur = require('kleur');
+const ui = require('../utils/ui');
+const { printCompactHeader } = require('../utils/brand');
+const { createTranslator, detectDefaultLanguage } = require('../utils/i18n');
+
+const PLACEHOLDER_REGEX = /^(YOUR_|TODO|CHANGE_ME|<.*>$)/i;
+
+// ── Field catalog ─────────────────────────────────────────────────────────
+// Grouped by feature so we only ask for credentials that the project actually
+// uses. Each field declares its `destination`:
+//   - 'env'           → project root .env (client-side)
+//   - 'functionsEnv'  → functions/.env (server-side non-secret)
+//   - 'firebaseSecret' → firebase functions:secrets:set (server-side secret)
+
+const FEATURE_BLOCKS = [
+  {
+    id: 'app_store',
+    titleKey: 'configure.section.appStore',
+    isActive: () => true,
+    fields: [
+      {
+        key: 'APP_STORE_ID',
+        destination: 'env',
+        label: 'App Store ID (numeric)',
+        hint: 'App Store Connect → App → General → Apple ID',
+        validate: (v) => (/^\d+$/.test(v) ? undefined : 'Numbers only'),
+      },
+    ],
+  },
+  {
+    id: 'sentry',
+    titleKey: 'configure.section.sentry',
+    isActive: (kit) => !!kit.useSentry,
+    fields: [
+      {
+        key: 'SENTRY_DSN',
+        destination: 'env',
+        label: 'Sentry DSN',
+        hint: 'Sentry → Project → Settings → Client Keys (DSN)',
+        validate: (v) => (/^https?:\/\/[^@\s]+@[^/\s]+\/\d+$/.test(v) ? undefined : 'Format: https://xxx@yyy/123'),
+      },
+    ],
+  },
+  {
+    id: 'analytics',
+    titleKey: 'configure.section.mixpanel',
+    isActive: (kit) => kit.analyticsProvider === 'mixpanel',
+    fields: [
+      {
+        key: 'MIXPANEL_TOKEN',
+        destination: 'env',
+        label: 'Mixpanel Project Token',
+        hint: 'Mixpanel → Project Settings → Project Token',
+        validate: () => undefined,
+      },
+    ],
+  },
+  {
+    id: 'revenuecat',
+    titleKey: 'configure.section.revenuecat',
+    isActive: (kit) => !!kit.subscriptionModule,
+    fields: [
+      {
+        key: 'RC_TEST_KEY',
+        destination: 'env',
+        label: 'RevenueCat — Test Key (test_…)',
+        hint: 'Used on simulator/emulator',
+        validate: (v) => (/^test_/.test(v) ? undefined : 'Must start with `test_`'),
+      },
+      {
+        key: 'RC_IOS_PROD_KEY',
+        destination: 'env',
+        label: 'RevenueCat — iOS prod (appl_…)',
+        hint: 'Used on physical iPhone',
+        validate: (v) => (/^appl_/.test(v) ? undefined : 'Must start with `appl_`'),
+      },
+      {
+        key: 'RC_ANDROID_PROD_KEY',
+        destination: 'env',
+        label: 'RevenueCat — Android prod (goog_…)',
+        hint: 'Used on physical Android',
+        validate: (v) => (/^goog_/.test(v) ? undefined : 'Must start with `goog_`'),
+      },
+      {
+        key: 'RC_WEB_API_KEY',
+        destination: 'env',
+        label: 'RevenueCat — Web Billing (rcb_…)',
+        hint: 'Only if app has Web/PWA',
+        onlyIf: (kit) => !!kit.revenuecatWeb,
+        validate: (v) => (/^rcb_/.test(v) ? undefined : 'Must start with `rcb_`'),
+      },
+      {
+        key: 'RC_WEBHOOK_KEY',
+        destination: 'firebaseSecret',
+        label: 'RevenueCat — Webhook Authorization header',
+        hint: 'Authorization header secret used by your RevenueCat webhook',
+        onlyIf: (kit) => kit.backendProvider === 'firebase',
+        validate: () => undefined,
+      },
+      {
+        key: 'META_ACCESS_TOKEN',
+        destination: 'firebaseSecret',
+        label: 'Meta Conversions API — Access Token',
+        hint: 'Meta Business → System User → Generate Token',
+        onlyIf: (kit) => kit.backendProvider === 'firebase',
+        validate: () => undefined,
+      },
+      {
+        key: 'META_DATASET_ID',
+        destination: 'firebaseSecret',
+        label: 'Meta — Dataset (Pixel) ID',
+        hint: 'Meta Events Manager → Data Source ID',
+        onlyIf: (kit) => kit.backendProvider === 'firebase',
+        validate: (v) => (/^\d+$/.test(v) ? undefined : 'Numbers only'),
+      },
+    ],
+  },
+  {
+    id: 'facebook',
+    titleKey: 'configure.section.facebook',
+    isActive: (kit) => !!kit.withFacebookPixel,
+    fields: [
+      {
+        key: 'FB_APP_ID',
+        destination: 'facebook',
+        label: 'Facebook App ID (numeric)',
+        hint: 'Meta for Developers → My Apps → Settings → Basic → App ID',
+        validate: (v) => (/^\d+$/.test(v) ? undefined : 'Numbers only'),
+      },
+      {
+        key: 'FB_CLIENT_TOKEN',
+        destination: 'facebook',
+        label: 'Facebook Client Token (32 hex)',
+        hint: 'Meta → Settings → Advanced → Security → Client Token',
+        validate: (v) => (/^[a-fA-F0-9]{32}$/.test(v) ? undefined : 'Should be 32 hex characters'),
+      },
+    ],
+  },
+  {
+    id: 'llm_chat',
+    titleKey: 'configure.section.llmChat',
+    isActive: (kit, ctx) => !!ctx.hasLlmChat,
+    fields: [
+      {
+        key: 'LLM_PROVIDER',
+        destination: 'functionsEnv',
+        label: 'LLM Provider (openai or gemini)',
+        validate: (v) => (/^(openai|gemini)$/.test(v) ? undefined : 'Use openai or gemini'),
+      },
+      {
+        key: 'LLM_SYSTEM_PROMPT',
+        destination: 'functionsEnv',
+        label: 'LLM system prompt (instructions)',
+        validate: () => undefined,
+      },
+      {
+        key: 'LLM_API_KEY',
+        destination: 'firebaseSecret',
+        label: 'LLM provider API key',
+        hint: 'OpenAI dashboard → API keys, or Google AI Studio',
+        onlyIf: (kit) => kit.backendProvider === 'firebase',
+        validate: () => undefined,
+      },
+    ],
+  },
+];
+
+// ── Helpers ───────────────────────────────────────────────────────────────
+
+function parseEnv(content) {
+  const map = new Map();
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq === -1) continue;
+    map.set(trimmed.slice(0, eq).trim(), trimmed.slice(eq + 1).trim());
+  }
+  return map;
+}
+
+function isFilled(value) {
+  if (!value) return false;
+  if (PLACEHOLDER_REGEX.test(value)) return false;
+  return true;
+}
+
+async function readEnvFile(envPath) {
+  if (!(await fs.pathExists(envPath))) return new Map();
+  return parseEnv(await fs.readFile(envPath, 'utf8'));
+}
+
+async function updateEnvFile(envPath, updates) {
+  let original = '';
+  if (await fs.pathExists(envPath)) original = await fs.readFile(envPath, 'utf8');
+  const lines = original.split('\n');
+  const handled = new Set();
+  const updated = lines.map((line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) return line;
+    const eq = trimmed.indexOf('=');
+    if (eq === -1) return line;
+    const key = trimmed.slice(0, eq).trim();
+    if (updates.has(key)) {
+      handled.add(key);
+      return `${key}=${updates.get(key)}`;
+    }
+    return line;
+  });
+  const appended = [];
+  for (const [key, value] of updates) if (!handled.has(key)) appended.push(`${key}=${value}`);
+  if (appended.length > 0) {
+    if (updated.length > 0 && updated[updated.length - 1].trim() !== '') updated.push('');
+    updated.push('# Added by `kasy configure`');
+    updated.push(...appended);
+  }
+  await fs.outputFile(envPath, updated.join('\n'), 'utf8');
+}
+
+// ── Facebook patches ──────────────────────────────────────────────────────
+// Facebook needs the same values in two build-time files: iOS Info.plist and
+// Android strings.xml. Both ship with placeholder zeros; we replace them in
+// place so the user only types each value once.
+
+function readFacebookCurrent(content, kind) {
+  if (kind === 'plist') {
+    const appId = content.match(/<key>FacebookAppID<\/key>\s*<string>([^<]*)<\/string>/);
+    const token = content.match(/<key>FacebookClientToken<\/key>\s*<string>([^<]*)<\/string>/);
+    return { appId: (appId?.[1] || '').trim(), token: (token?.[1] || '').trim() };
+  }
+  // strings.xml
+  const appId = content.match(/<string name="facebook_app_id"[^>]*>([^<]*)<\/string>/);
+  const token = content.match(/<string name="facebook_client_token"[^>]*>([^<]*)<\/string>/);
+  return { appId: (appId?.[1] || '').trim(), token: (token?.[1] || '').trim() };
+}
+
+function isFacebookPlaceholder(value) {
+  return !value || /^0+$/.test(value);
+}
+
+async function readFacebookState(projectDir) {
+  const plistPath = path.join(projectDir, 'ios', 'Runner', 'Info.plist');
+  const stringsPath = path.join(projectDir, 'android', 'app', 'src', 'main', 'res', 'values', 'strings.xml');
+  const state = { appId: '', token: '', plistExists: false, stringsExists: false };
+  if (await fs.pathExists(plistPath)) {
+    state.plistExists = true;
+    const plistRead = readFacebookCurrent(await fs.readFile(plistPath, 'utf8'), 'plist');
+    if (!isFacebookPlaceholder(plistRead.appId)) state.appId = plistRead.appId;
+    if (!isFacebookPlaceholder(plistRead.token)) state.token = plistRead.token;
+  }
+  if (await fs.pathExists(stringsPath)) {
+    state.stringsExists = true;
+    const stringsRead = readFacebookCurrent(await fs.readFile(stringsPath, 'utf8'), 'strings');
+    // Prefer plist value when both exist; only fall back if plist was placeholder.
+    if (!state.appId && !isFacebookPlaceholder(stringsRead.appId)) state.appId = stringsRead.appId;
+    if (!state.token && !isFacebookPlaceholder(stringsRead.token)) state.token = stringsRead.token;
+  }
+  return state;
+}
+
+async function writeFacebookCredentials(projectDir, appId, clientToken) {
+  const plistPath = path.join(projectDir, 'ios', 'Runner', 'Info.plist');
+  const stringsPath = path.join(projectDir, 'android', 'app', 'src', 'main', 'res', 'values', 'strings.xml');
+  const results = { plist: 'skipped', strings: 'skipped' };
+
+  if (appId && await fs.pathExists(plistPath)) {
+    let plist = await fs.readFile(plistPath, 'utf8');
+    plist = plist.replace(
+      /(<key>FacebookAppID<\/key>\s*<string>)[^<]*(<\/string>)/,
+      `$1${appId}$2`
+    );
+    if (clientToken) {
+      plist = plist.replace(
+        /(<key>FacebookClientToken<\/key>\s*<string>)[^<]*(<\/string>)/,
+        `$1${clientToken}$2`
+      );
+    }
+    // CFBundleURLSchemes — replace `fb<zeros>` with `fb<appId>` so deep links work.
+    plist = plist.replace(/<string>fb0+<\/string>/, `<string>fb${appId}</string>`);
+    await fs.outputFile(plistPath, plist, 'utf8');
+    results.plist = 'ok';
+  } else if (appId) {
+    results.plist = 'missing_file';
+  }
+
+  if (appId && await fs.pathExists(stringsPath)) {
+    let xml = await fs.readFile(stringsPath, 'utf8');
+    xml = xml.replace(
+      /(<string name="facebook_app_id"[^>]*>)[^<]*(<\/string>)/,
+      `$1${appId}$2`
+    );
+    if (clientToken) {
+      xml = xml.replace(
+        /(<string name="facebook_client_token"[^>]*>)[^<]*(<\/string>)/,
+        `$1${clientToken}$2`
+      );
+    }
+    // fb_login_protocol_scheme — set if present.
+    xml = xml.replace(
+      /(<string name="fb_login_protocol_scheme"[^>]*>)[^<]*(<\/string>)/,
+      `$1fb${appId}$2`
+    );
+    await fs.outputFile(stringsPath, xml, 'utf8');
+    results.strings = 'ok';
+  } else if (appId) {
+    results.strings = 'missing_file';
+  }
+
+  return results;
+}
+
+async function setFirebaseSecret(projectDir, key, value, t) {
+  // Use a tmp file to avoid newline injection / shell escaping issues.
+  const tmpFile = path.join(os.tmpdir(), `kasy_secret_${key}_${Date.now()}.tmp`);
+  await fs.outputFile(tmpFile, value, 'utf8');
+  try {
+    await execAsync(
+      `firebase functions:secrets:set ${key} --data-file="${tmpFile}"`,
+      { cwd: projectDir }
+    );
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.stderr || err.message };
+  } finally {
+    await fs.remove(tmpFile).catch(() => {});
+  }
+}
+
+async function detectFeatureContext(projectDir) {
+  const ctx = { hasLlmChat: false };
+  const featuresPath = path.join(projectDir, 'lib', 'core', 'config', 'features.dart');
+  if (await fs.pathExists(featuresPath)) {
+    const content = await fs.readFile(featuresPath, 'utf8');
+    if (/const bool withLlmChat\s*=\s*true/.test(content)) ctx.hasLlmChat = true;
+  }
+  return ctx;
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────
+
+async function runConfigure(options = {}) {
+  const language = options.language || detectDefaultLanguage();
+  const t = createTranslator(language);
+  const projectDir = path.resolve(options.directory || '.');
+
+  printCompactHeader(t);
+  ui.intro(kleur.bold(t('configure.title')));
+
+  const kitSetupPath = path.join(projectDir, 'kit_setup.json');
+  if (!(await fs.pathExists(kitSetupPath))) {
+    ui.log.error(t('configure.notKasyProject'));
+    ui.cancel(t('configure.notKasyProject'));
+    process.exit(1);
+  }
+  const kit = await fs.readJson(kitSetupPath);
+  const ctx = await detectFeatureContext(projectDir);
+
+  // Read current state of all sources
+  const envPath = path.join(projectDir, '.env');
+  const fnEnvPath = path.join(projectDir, 'functions', '.env');
+  const envState = await readEnvFile(envPath);
+  const fnEnvState = await readEnvFile(fnEnvPath);
+
+  // Firebase Secrets: we can't reliably introspect existing values without
+  // running `firebase functions:secrets:access` per key (slow + may prompt).
+  // Treat them as "always ask if not in this session". Status display will say
+  // "set on demand" so the user knows nothing is destructive.
+
+  const activeBlocks = FEATURE_BLOCKS.filter((b) => b.isActive(kit, ctx));
+  if (activeBlocks.length === 0) {
+    ui.log.success(t('configure.noOptionalFeatures'));
+    ui.outro(t('configure.outroNoChange'));
+    return;
+  }
+
+  // Facebook reads from both build files; cache once if the block is active.
+  const facebookState = activeBlocks.some((b) => b.id === 'facebook')
+    ? await readFacebookState(projectDir)
+    : null;
+
+  // Pre-scan: compute filled vs pending across all fields, grouped by block.
+  const plan = [];
+  for (const block of activeBlocks) {
+    const items = [];
+    for (const field of block.fields) {
+      if (field.onlyIf && !field.onlyIf(kit, ctx)) continue;
+      let currentValue;
+      if (field.destination === 'env') currentValue = envState.get(field.key);
+      else if (field.destination === 'functionsEnv') currentValue = fnEnvState.get(field.key);
+      else if (field.destination === 'firebaseSecret') currentValue = undefined;
+      else if (field.destination === 'facebook') {
+        currentValue = field.key === 'FB_APP_ID' ? facebookState?.appId : facebookState?.token;
+      }
+      items.push({ field, filled: isFilled(currentValue) });
+    }
+    if (items.length > 0) plan.push({ block, items });
+  }
+
+  // Status report
+  let totalFilled = 0;
+  let totalPending = 0;
+  for (const { items } of plan) {
+    for (const item of items) {
+      if (item.filled) totalFilled++;
+      else totalPending++;
+    }
+  }
+
+  ui.log.step(kleur.bold(t('configure.statusSummary', { filled: totalFilled, pending: totalPending })));
+  if (totalPending === 0) {
+    ui.log.success(t('configure.allDone'));
+    ui.outro(t('configure.allDone'));
+    return;
+  }
+  ui.log.message(kleur.dim(t('configure.skipHint')));
+
+  const envUpdates = new Map();
+  const fnEnvUpdates = new Map();
+  const secretUpdates = new Map();
+  const facebookUpdates = {};
+  let answeredCount = 0;
+  let skippedCount = 0;
+
+  for (const { block, items } of plan) {
+    const pending = items.filter((it) => !it.filled);
+    if (pending.length === 0) {
+      // All filled — show a compact success line per block.
+      ui.log.success(`${t(block.titleKey)} ${kleur.dim('— ' + t('configure.alreadyDone'))}`);
+      continue;
+    }
+
+    ui.log.step(kleur.bold(t(block.titleKey)));
+    for (const { field, filled } of items) {
+      if (filled) {
+        ui.log.message(kleur.dim(`  ✓ ${field.label} ${kleur.dim('— ' + t('configure.alreadyFilledShort'))}`));
+        continue;
+      }
+      const dst = field.destination === 'firebaseSecret' ? ' [Firebase Secret]'
+        : field.destination === 'functionsEnv' ? ' [functions/.env]'
+        : field.destination === 'facebook' ? ' [Info.plist + strings.xml]'
+        : '';
+      const value = await ui.text({
+        message: `${field.label}${kleur.dim(dst)}`,
+        placeholder: t('configure.skipPlaceholder'),
+        validate: (v) => {
+          const s = (v || '').trim();
+          if (!s) return undefined;
+          return field.validate(s);
+        },
+        onCancel: () => {
+          ui.cancel(t('configure.aborted'));
+          process.exit(0);
+        },
+      });
+      if (field.hint) ui.log.message(kleur.dim(`    ${field.hint}`));
+      const trimmed = (value || '').trim();
+      if (!trimmed) {
+        skippedCount++;
+        continue;
+      }
+      if (field.destination === 'env') envUpdates.set(field.key, trimmed);
+      else if (field.destination === 'functionsEnv') fnEnvUpdates.set(field.key, trimmed);
+      else if (field.destination === 'firebaseSecret') secretUpdates.set(field.key, trimmed);
+      else if (field.destination === 'facebook') {
+        if (field.key === 'FB_APP_ID') facebookUpdates.appId = trimmed;
+        else if (field.key === 'FB_CLIENT_TOKEN') facebookUpdates.token = trimmed;
+      }
+      answeredCount++;
+    }
+  }
+
+  // Persist
+  if (envUpdates.size > 0) {
+    await updateEnvFile(envPath, envUpdates);
+    ui.log.success(t('configure.savedEnv', { count: envUpdates.size }));
+  }
+  if (fnEnvUpdates.size > 0) {
+    await fs.ensureDir(path.dirname(fnEnvPath));
+    await updateEnvFile(fnEnvPath, fnEnvUpdates);
+    ui.log.success(t('configure.savedFnEnv', { count: fnEnvUpdates.size }));
+  }
+  if (facebookUpdates.appId || facebookUpdates.token) {
+    // If only one of the two was provided this run, fall back to the existing
+    // value (or leave the placeholder if there's none) for the other.
+    const appId = facebookUpdates.appId || facebookState?.appId || '';
+    const token = facebookUpdates.token || facebookState?.token || '';
+    if (appId) {
+      const fbResult = await writeFacebookCredentials(projectDir, appId, token);
+      const wroteSome = fbResult.plist === 'ok' || fbResult.strings === 'ok';
+      if (wroteSome) ui.log.success(t('configure.savedFacebook'));
+      if (fbResult.plist === 'missing_file') ui.log.warn(t('configure.facebookPlistMissing'));
+      if (fbResult.strings === 'missing_file') ui.log.warn(t('configure.facebookStringsMissing'));
+    } else {
+      ui.log.warn(t('configure.facebookNeedsAppId'));
+    }
+  }
+
+  if (secretUpdates.size > 0) {
+    const secretSpinner = ui.spinner();
+    secretSpinner.start(t('configure.settingSecrets', { count: secretUpdates.size }));
+    let okCount = 0;
+    const failures = [];
+    for (const [key, value] of secretUpdates) {
+      const result = await setFirebaseSecret(projectDir, key, value, t);
+      if (result.ok) okCount++;
+      else failures.push({ key, error: result.error });
+    }
+    secretSpinner.stop(t('configure.settingSecrets', { count: secretUpdates.size }));
+    if (okCount > 0) ui.log.success(t('configure.savedSecrets', { count: okCount }));
+    for (const f of failures) {
+      ui.log.warn(`${t('configure.secretFailed', { key: f.key })}\n${kleur.dim((f.error || '').slice(0, 200))}`);
+    }
+  }
+
+  const stillPending = totalPending - answeredCount;
+  if (stillPending > 0) {
+    ui.log.message(kleur.dim(`– ${t('configure.stillPending', { count: stillPending })}`));
+    ui.log.message(kleur.dim(`  ${t('configure.runAgainHint')}`));
+  } else if (answeredCount > 0) {
+    ui.log.success(t('configure.allDone'));
+  } else if (skippedCount > 0) {
+    ui.log.message(kleur.dim(`– ${t('configure.allSkipped')}`));
+  }
+
+  ui.outro(answeredCount > 0
+    ? t('configure.outroSaved', { count: answeredCount })
+    : t('configure.outroNoChange'));
+}
+
+module.exports = { runConfigure };

package/lib/commands/deploy.js

@@ -17,7 +17,7 @@ const path = require('node:path');
 const fs = require('fs-extra');
 const kleur = require('kleur');
 const ui = require('../utils/ui');
-const { printCompactHeader } = require('../utils/brand');
+const { printCompactHeader, paintLime } = require('../utils/brand');
 
 const { createTranslator } = require('../utils/i18n');
 const { getStoredLanguage } = require('../utils/license');
@@ -122,7 +122,7 @@ async function deployFirebase(projectDir, options, tr) {
     }
   }
 
-  const spinner = ui.timedSpinner();
+  const spinner = ui.timedSpinner({ color: paintLime });
   spinner.start(tr('deploy.firebase.spin'));
   let steps;
   try {
@@ -173,7 +173,7 @@ async function deploySupabase(projectDir, tr) {
     const firebaseProjectId = await readFirebaseProjectId(projectDir);
 
     if (firebaseProjectId) {
-      const fcmSpinner = ui.timedSpinner();
+      const fcmSpinner = ui.timedSpinner({ color: paintLime });
       fcmSpinner.start(tr('deploy.supabase.sakSpin'));
       const fcmResult = await createFcmServiceAccountKey(firebaseProjectId);
       fcmSpinner.stop(tr('deploy.supabase.sakSpinDone'));
@@ -194,7 +194,7 @@ async function deploySupabase(projectDir, tr) {
   }
 
   // ── 3. Deploy edge functions ────────────────────────────────────────────
-  const fnSpinner = ui.timedSpinner();
+  const fnSpinner = ui.timedSpinner({ color: paintLime });
   fnSpinner.start(tr('deploy.supabase.fnSpin'));
   const fnResult = await deployFunctions(projectDir);
   fnSpinner.stop(tr('deploy.supabase.fnSpinDone'));

package/lib/commands/doctor.js

@@ -18,6 +18,7 @@ const {
 } = require('../utils/apple-release');
 const { validateCodemagicSetup, codemagicReleaseDocPath } = require('../utils/codemagic-release');
 const { validateGoogleIosUrlScheme, validateAppleSignInEntitlement, validateFacebookInfoPlist, validateFacebookAndroidStrings, validateRevenueCat } = require('../scaffold/shared/post-build');
+const { listBillingAccounts, checkGcloudAuth } = require('../scaffold/backends/firebase/setup-from-scratch');
 const { printCompactHeader } = require('../utils/brand');
 
 function collectOptionalBackendChecks() {
@@ -175,14 +176,45 @@ async function runRevenueCatChecks(projectDir, t, config) {
   const rc = await validateRevenueCat(projectDir, config);
   if (rc.skipped) return;
 
-  if (!rc.iosEmpty && !rc.androidEmpty) {
-    ui.log.success(t('doctor.revenuecat.keysOk'));
+  if (rc.legacy) {
+    // Project predates the test/prod split — show the old summary.
+    if (!rc.iosEmpty && !rc.androidEmpty) {
+      ui.log.success(t('doctor.revenuecat.keysOk'));
+    } else {
+      ui.log.warn(t('doctor.revenuecat.keysEmpty'));
+    }
+    if (rc.bothTest) {
+      ui.log.warn(t('doctor.revenuecat.keysTest'));
+    }
   } else {
-    ui.log.warn(t('doctor.revenuecat.keysEmpty'));
-  }
+    // New 3-key scheme. One line per key with granular status.
+    if (rc.testOk) {
+      ui.log.success(t('doctor.revenuecat.testKeyOk'));
+    } else if (rc.testBadPrefix) {
+      ui.log.warn(t('doctor.revenuecat.prefixMismatch', { key: 'RC_TEST_KEY', expected: 'test_' }));
+    } else {
+      ui.log.warn(t('doctor.revenuecat.testKeyMissing'));
+    }
+
+    if (rc.iosProdOk) {
+      ui.log.success(t('doctor.revenuecat.iosProdOk'));
+    } else if (rc.iosProdBadPrefix) {
+      ui.log.warn(t('doctor.revenuecat.prefixMismatch', { key: 'RC_IOS_PROD_KEY', expected: 'appl_' }));
+    } else {
+      ui.log.message(kleur.dim(`– ${t('doctor.revenuecat.iosProdMissing')}`));
+    }
 
-  if (rc.bothTest) {
-    ui.log.warn(t('doctor.revenuecat.keysTest'));
+    if (rc.androidProdOk) {
+      ui.log.success(t('doctor.revenuecat.androidProdOk'));
+    } else if (rc.androidProdBadPrefix) {
+      ui.log.warn(t('doctor.revenuecat.prefixMismatch', { key: 'RC_ANDROID_PROD_KEY', expected: 'goog_' }));
+    } else {
+      ui.log.message(kleur.dim(`– ${t('doctor.revenuecat.androidProdMissing')}`));
+    }
+
+    if (rc.onlyTest) {
+      ui.log.warn(t('doctor.revenuecat.keysTest'));
+    }
   }
 
   if (rc.webhookUrl) {
@@ -217,6 +249,22 @@ async function runDoctor(options = {}) {
     });
   }
 
+  // ── Google Cloud billing account (Firebase Blaze) ─────────────────────
+  // Only meaningful when gcloud is authenticated; otherwise users already saw
+  // a gcloud check fail above and this would just repeat the noise.
+  const gcloudAuth = await checkGcloudAuth();
+  if (gcloudAuth.ok) {
+    ui.log.step(kleur.bold(t('doctor.gcpBilling.title')));
+    const billing = await listBillingAccounts();
+    if (billing.ok && billing.accounts?.length > 0) {
+      const sample = billing.accounts.slice(0, 3).map((a) => `${a.name || a.id} (${a.id})`).join(', ');
+      ui.log.success(`${t('doctor.gcpBilling.found', { count: billing.accounts.length })} ${kleur.dim(sample)}`);
+    } else {
+      ui.log.warn(t('doctor.gcpBilling.missing'));
+      ui.log.message(kleur.cyan('https://console.cloud.google.com/billing/create'));
+    }
+  }
+
   if (hasRequiredFailures(baseResults)) {
     throw new Error(t('doctor.requiredMissing'));
   }