kasy-cli 1.17.0 → 1.18.0

package/bin/kasy.js

@@ -8,6 +8,7 @@ const { runDoctor } = require('../lib/commands/doctor');
 const { runFeatures } = require('../lib/commands/features');
 const { runValidate } = require('../lib/commands/validate');
 const { runDeployCommand } = require('../lib/commands/deploy');
+const { runConfigure } = require('../lib/commands/configure');
 const { runCheck } = require('../lib/commands/check');
 const { runRun } = require('../lib/commands/run');
 const { runReset } = require('../lib/commands/reset');
@@ -137,7 +138,7 @@ function createLocalizedHelpConfig(t) {
           // Group root commands by intent for easier scanning by non-devs.
           const groups = [
             { id: 'start',       ids: ['new', 'doctor', 'features'] },
-            { id: 'work',        ids: ['add', 'remove', 'update', 'run', 'reset', 'splash', 'icon', 'favicon', 'notifications'] },
+            { id: 'work',        ids: ['add', 'configure', 'remove', 'update', 'run', 'reset', 'splash', 'icon', 'favicon', 'notifications'] },
             { id: 'publish',     ids: ['deploy', 'check', 'ios', 'codemagic'] },
             { id: 'maintenance', ids: ['upgrade', 'version', 'uninstall', 'docs'] },
             { id: 'advanced',    ids: ['setup', 'validate'] },
@@ -240,7 +241,7 @@ function buildProgram(language) {
       .argument('[directory]', 'Target folder (default: asks during setup)', '.')
       .option('-b, --backend <backend>', t('cli.command.setup.backendOption'))
       .option('--with <features>', t('cli.command.setup.featuresOption'))
-      .option('--yes', 'Skip interactive questions — Quick mode with Starter preset')
+      .option('--yes', 'Skip interactive questions (Quick mode, all features)')
       .option('-p, --project <id>', 'Firebase Project ID (used with --yes)')
       .description(t('cli.command.new.description'))
       .action(async (directory, options) => {
@@ -324,6 +325,17 @@ function buildProgram(language) {
     t
   );
 
+  applyLocalizedHelp(
+    program
+      .command('configure')
+      .argument('[directory]', 'Project folder (default: current directory)', '.')
+      .description(t('cli.command.configure.description'))
+      .action(async (directory) => {
+        await runConfigure({ directory, language });
+      }),
+    t
+  );
+
   applyLocalizedHelp(
     program
       .command('check')
@@ -347,6 +359,7 @@ function buildProgram(language) {
       .option('--prod', 'Use production dart-defines (from launch.json)')
       .option('--no-defines', 'Skip dart-defines from launch.json')
       .option('--rc <mode>', 'RevenueCat key mode: auto (default — picks by device), test, or prod')
+      .option('--raw', 'Disable spinner and pass Flutter output straight through (auto-on when stdout is not a TTY)')
       .description(t('cli.command.run.description'))
       .action(async (directory, options) => {
         await runRun(directory, { language, ...options });

package/lib/commands/add.js

@@ -6,7 +6,7 @@ const fs = require('fs-extra');
 const pkg = require('../../package.json');
 const kleur = require('kleur');
 const ui = require('../utils/ui');
-const { printCompactHeader } = require('../utils/brand');
+const { printCompactHeader, paintLime } = require('../utils/brand');
 const { createTranslator, detectDefaultLanguage } = require('../utils/i18n');
 const {
   AVAILABLE_FEATURES,
@@ -448,7 +448,7 @@ async function postAddLlmChat(projectDir, kitSetup, answers, t) {
   const refFlag = backend === 'supabase' && projectRef ? ` --project-ref ${projectRef}` : '';
 
   if (backend === 'firebase') {
-    const spinner = ui.spinner();
+    const spinner = ui.spinner({ color: paintLime });
     spinner.start(t('add.llm_chat.settingSecret'));
     try {
       // Write to temp file — avoids trailing newline (echo) and shell injection risks
@@ -463,7 +463,7 @@ async function postAddLlmChat(projectDir, kitSetup, answers, t) {
       ui.log.message(kleur.dim('Run manually: firebase functions:secrets:set LLM_API_KEY'));
     }
   } else if (backend === 'supabase') {
-    const spinner = ui.spinner();
+    const spinner = ui.spinner({ color: paintLime });
     spinner.start(t('add.llm_chat.settingSecret'));
     // Set LLM_API_KEY, LLM_PROVIDER and LLM_SYSTEM_PROMPT all as Supabase Secrets.
     // Deployed Edge Functions read from Deno.env.get() = Supabase Secrets, NOT from .env files.
@@ -493,7 +493,7 @@ async function postAddLlmChat(projectDir, kitSetup, answers, t) {
   // 3. Deploy the LLM function automatically
   if (backend === 'api') return { deployOk: false, deployAttempted: false };
 
-  const deploySpinner = ui.timedSpinner();
+  const deploySpinner = ui.timedSpinner({ color: paintLime });
   deploySpinner.start(t('add.llm_chat.deploying'));
   try {
     if (backend === 'firebase') {
@@ -721,7 +721,7 @@ async function runAdd(module, options = {}) {
   // 8. Apply patch if it exists under features/<module>/
   const patchDir = path.join(FEATURES_PATCH_DIR, normalized);
   if (await fs.pathExists(patchDir)) {
-    const spinner = ui.spinner();
+    const spinner = ui.spinner({ color: paintLime });
     spinner.start(t('add.applyingPatch'));
     try {
       const { tokens: patchTokens, pathReplacements: patchPathReplacements } = buildTokens({
@@ -781,7 +781,7 @@ async function runAdd(module, options = {}) {
 
   // 10. flutter pub get
   {
-    const spinner = ui.spinner();
+    const spinner = ui.spinner({ color: paintLime });
     spinner.start(t('add.pubGet'));
     try {
       await execAsync('flutter pub get', { cwd: projectDir, timeout: 300_000 });
@@ -794,7 +794,7 @@ async function runAdd(module, options = {}) {
   // 11. build_runner (only when needed: features with codegen)
   const needsBuildRunner = ['revenuecat', 'analytics', 'sentry', 'onboarding', 'llm_chat', 'feedback'].includes(normalized);
   if (needsBuildRunner) {
-    const spinner = ui.timedSpinner();
+    const spinner = ui.timedSpinner({ color: paintLime });
     spinner.start(t('add.buildRunner'));
     try {
       await execAsync('dart run build_runner build --delete-conflicting-outputs', { cwd: projectDir, timeout: 600_000 });

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 };