kasy-cli 1.12.1 → 1.14.0

package/lib/commands/new.js

@@ -15,22 +15,10 @@ const path = require('node:path');
 const crypto = require('node:crypto');
 const kleur = require('kleur');
 
-function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
-
 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`);
-}
-
 function openUrl(url) {
   try {
     const { exec } = require('node:child_process');
@@ -716,7 +704,7 @@ async function runNew(directory, { language: langHint = null, backend: backendHi
       const selectedOrgId = await promptOrganizationIfNeeded(tr, cancel);
       let selectedBillingId = await promptBillingAccountIfNeeded(tr, cancel);
       ui.log.info(`${tr('new.firebase.create.estimatedTime')}\n${tr('new.internet.warning')}`);
-      const ps1 = ui.makeStepper();
+      const ps1 = ui.makeTimedStepper();
       ps1.next(tr('new.firebase.create.creating'));
       const setupResult = await setupFromScratch(core.appName.trim(), core.bundleId.trim(), {
         includeWeb: firebaseIncludeWeb,
@@ -796,7 +784,7 @@ async function runNew(directory, { language: langHint = null, backend: backendHi
           }
           ui.log.message(tr('new.firebase.create.billingRetry.retrying'));
           selectedBillingId = await promptBillingAccountIfNeeded(tr, cancel);
-          const ps2 = ui.makeStepper();
+          const ps2 = ui.makeTimedStepper();
           ps2.next(tr('new.firebase.create.creating'));
           lastResult = await setupFromScratch(core.appName.trim(), core.bundleId.trim(), {
                 includeWeb: firebaseIncludeWeb,
@@ -889,7 +877,7 @@ async function runNew(directory, { language: langHint = null, backend: backendHi
       const selectedOrgId = await promptOrganizationIfNeeded(tr, cancel);
       const selectedBillingId = await promptBillingAccountIfNeeded(tr, cancel);
       ui.log.info(tr('new.internet.warning'));
-      const ps3 = ui.makeStepper();
+      const ps3 = ui.makeTimedStepper();
       ps3.next(tr('new.firebase.create.creatingPush'));
       const setupResult = await setupFromScratch(core.appName.trim(), core.bundleId.trim(), {
         includeWeb: true,
@@ -990,7 +978,7 @@ async function runNew(directory, { language: langHint = null, backend: backendHi
         });
         supabaseDbPassword = dbPassword;
         ui.log.info(tr('new.internet.warning'));
-        const createSpinner = ui.spinner();
+        const createSpinner = ui.timedSpinner();
         createSpinner.start(tr('new.supabase.creating'));
         supabaseCreateResult = await createProjectAndGetKeys(
           core.appName.trim().replace(/\s+/g, '-').toLowerCase(),
@@ -1087,7 +1075,7 @@ async function runNew(directory, { language: langHint = null, backend: backendHi
 
   // ── Firebase existing project: enable APIs + create Firestore/Storage ───
   if (backend === 'firebase' && firebaseSetupMode === 'existing' && core.firebaseProjectId) {
-    const ps4 = ui.makeStepper();
+    const ps4 = ui.makeTimedStepper();
     ps4.next(stepProgress('enable-apis', language));
     const existingSetup = await setupExistingProject(core.firebaseProjectId, {
       onProgress: (key, data) => {
@@ -1388,7 +1376,7 @@ async function runNew(directory, { language: langHint = null, backend: backendHi
   // Stepper shows each step closing as ✦ and the next starting as ⠙ — so the
   // user gets explicit "X done → Y starting" feedback instead of a single
   // spinner with a mutating message.
-  const stepper = ui.makeStepper();
+  const stepper = ui.makeTimedStepper();
   // First step started here so even silent prep work shows progress.
   stepper.next(stepProgress('project-setup', language));
 
@@ -1512,7 +1500,7 @@ async function runNew(directory, { language: langHint = null, backend: backendHi
       // ── FCM Service Account key (best effort via gcloud — Firebase uses ADC, Supabase needs JSON) ──
       let fcmServiceAccountJson = null;
       if (answers.firebaseProjectId) {
-        const fcmSpinner = ui.spinner();
+        const fcmSpinner = ui.timedSpinner();
         fcmSpinner.start(tr('new.fcm.generating'));
         const fcmResult = await createFcmServiceAccountKey(answers.firebaseProjectId);
         fcmSpinner.stop(tr('new.fcm.generating'));
@@ -1562,7 +1550,7 @@ async function runNew(directory, { language: langHint = null, backend: backendHi
 
   // ── API: FCM Service Account key — save to .kasy/ for server configuration ──
   if (backend === 'api' && answers.firebaseProjectId) {
-    const fcmSpinner = ui.spinner();
+    const fcmSpinner = ui.timedSpinner();
     fcmSpinner.start(tr('new.fcm.generating'));
     const fcmResult = await createFcmServiceAccountKey(answers.firebaseProjectId);
     fcmSpinner.stop(tr('new.fcm.generating'));

package/lib/commands/remove.js

@@ -444,7 +444,7 @@ async function runRemove(module, options = {}) {
     'revenuecat', 'analytics', 'sentry', 'onboarding', 'llm_chat', 'feedback',
   ].includes(normalized);
   if (needsBuildRunner) {
-    const spinner = ui.spinner();
+    const spinner = ui.timedSpinner();
     spinner.start(t('remove.buildRunner'));
     try {
       await execAsync(

package/lib/commands/reset.js

@@ -0,0 +1,287 @@
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const fs = require('fs-extra');
+const kleur = require('kleur');
+const ui = require('../utils/ui');
+const { createTranslator, detectDefaultLanguage } = require('../utils/i18n');
+const { printCompactHeader } = require('../utils/brand');
+const { readBundleId, readPackageName } = require('../utils/mobile-identity');
+const { spawnFlutterWithSpinner } = require('../utils/flutter-run');
+
+function runCmd(cmd, args) {
+  const res = spawnSync(cmd, args, { encoding: 'utf8' });
+  return {
+    code: res.status,
+    stdout: (res.stdout || '').trim(),
+    stderr: (res.stderr || '').trim(),
+  };
+}
+
+async function listFlutterDevices(projectDir) {
+  const res = spawnSync('flutter', ['devices', '--machine'], {
+    cwd: projectDir,
+    encoding: 'utf8',
+  });
+  if (res.status !== 0) return [];
+  try {
+    const parsed = JSON.parse(res.stdout);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function classifyTarget(device) {
+  const platform = (device.targetPlatform || '').toLowerCase();
+  if (platform === 'ios') {
+    return device.emulator ? 'ios-simulator' : 'ios-device';
+  }
+  if (platform.startsWith('android')) {
+    return device.emulator ? 'android-emulator' : 'android-device';
+  }
+  if (platform.startsWith('web')) {
+    return 'web';
+  }
+  return 'unknown';
+}
+
+function filterDevices(devices, options) {
+  return devices.filter((d) => {
+    const kind = classifyTarget(d);
+    if (options.device && d.id === options.device) return true;
+    if (options.ios && (kind === 'ios-simulator' || kind === 'ios-device')) {
+      return true;
+    }
+    if (
+      options.android &&
+      (kind === 'android-emulator' || kind === 'android-device')
+    ) {
+      return true;
+    }
+    if (options.web && kind === 'web') return true;
+    if (!options.ios && !options.android && !options.web && !options.device) {
+      return true;
+    }
+    return false;
+  });
+}
+
+async function pickDevice(devices, t) {
+  if (devices.length === 0) return null;
+  if (devices.length === 1) return devices[0];
+  const choice = await ui.select({
+    message: t('reset.prompt.pickDevice'),
+    options: devices.map((d) => ({
+      value: d.id,
+      label: `${d.name} ${kleur.dim(`(${classifyTarget(d)})`)}`,
+    })),
+  });
+  return devices.find((d) => d.id === choice) || null;
+}
+
+function resetIosSimulator(device, bundleId, t) {
+  ui.log.message(kleur.dim(`xcrun simctl uninstall ${device.id} ${bundleId}`));
+  const res = runCmd('xcrun', ['simctl', 'uninstall', device.id, bundleId]);
+  if (res.code !== 0) {
+    // simctl returns 0 even when app wasn't installed; non-zero is a real error
+    ui.log.warn(res.stderr || t('reset.warn.iosUninstallFailed'));
+    return false;
+  }
+  ui.log.success(t('reset.success.uninstalled'));
+  return true;
+}
+
+function resetIosDevice(device, bundleId, t) {
+  // Try Apple's devicectl (ships with Xcode 15+). Falls back to a manual
+  // instruction when devicectl isn't available or the uninstall fails.
+  const probe = runCmd('xcrun', ['devicectl', '--version']);
+  if (probe.code !== 0) {
+    noticeIosPhysical(t);
+    return false;
+  }
+  ui.log.message(
+    kleur.dim(
+      `xcrun devicectl device uninstall app --device ${device.id} ${bundleId}`
+    )
+  );
+  const res = runCmd('xcrun', [
+    'devicectl',
+    'device',
+    'uninstall',
+    'app',
+    '--device',
+    device.id,
+    bundleId,
+  ]);
+  if (res.code !== 0) {
+    ui.log.warn(res.stderr || t('reset.warn.iosDeviceUninstallFailed'));
+    noticeIosPhysical(t);
+    return false;
+  }
+  ui.log.success(t('reset.success.uninstalled'));
+  return true;
+}
+
+function resetAndroid(device, packageName, t) {
+  ui.log.message(kleur.dim(`adb -s ${device.id} uninstall ${packageName}`));
+  const res = runCmd('adb', ['-s', device.id, 'uninstall', packageName]);
+  // adb prints "Success" or "Failure [DELETE_FAILED_INTERNAL_ERROR]" / "not installed"
+  const out = `${res.stdout}\n${res.stderr}`.toLowerCase();
+  if (out.includes('success')) {
+    ui.log.success(t('reset.success.uninstalled'));
+    return true;
+  }
+  if (out.includes('not installed')) {
+    ui.log.message(kleur.dim(`– ${t('reset.info.notInstalled')}`));
+    return true;
+  }
+  ui.log.warn(res.stdout || res.stderr || t('reset.warn.androidUninstallFailed'));
+  return false;
+}
+
+function noticeIosPhysical(t) {
+  ui.log.warn(t('reset.warn.iosDeviceManual'));
+}
+
+function isXcodeRunning() {
+  const res = spawnSync('pgrep', ['-x', 'Xcode'], { encoding: 'utf8' });
+  return res.status === 0 && (res.stdout || '').trim().length > 0;
+}
+
+async function ensureXcodeClosed(t) {
+  if (!isXcodeRunning()) return true;
+  const choice = await ui.select({
+    message: t('reset.prompt.xcodeOpen'),
+    options: [
+      { value: 'close', label: t('reset.prompt.xcodeOpen.close') },
+      { value: 'skip', label: t('reset.prompt.xcodeOpen.skip') },
+      { value: 'cancel', label: t('reset.prompt.xcodeOpen.cancel') },
+    ],
+    initialValue: 'close',
+  });
+  if (choice === 'cancel') return false;
+  if (choice === 'close') {
+    spawnSync('osascript', ['-e', 'tell application "Xcode" to quit'], {
+      encoding: 'utf8',
+    });
+    // Give Xcode a moment to release the debug session before we proceed.
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+    ui.log.message(kleur.dim(t('reset.info.xcodeClosed')));
+  }
+  return true;
+}
+
+function noticeWeb(t) {
+  ui.log.warn(t('reset.warn.webIncognito'));
+}
+
+function runFlutterOnDevice(device, projectDir, t) {
+  return spawnFlutterWithSpinner(['run', '-d', device.id], projectDir, t);
+}
+
+async function runReset(directory, options = {}) {
+  const t = createTranslator(options.language || detectDefaultLanguage());
+  const projectDir = path.resolve(directory || '.');
+
+  if (!(await fs.pathExists(path.join(projectDir, 'pubspec.yaml')))) {
+    throw new Error(t('reset.error.notFlutterProject'));
+  }
+
+  printCompactHeader(t);
+  ui.intro(t('reset.title'));
+
+  const [bundleId, packageName] = await Promise.all([
+    readBundleId(projectDir),
+    readPackageName(projectDir),
+  ]);
+  if (!bundleId && !packageName) {
+    throw new Error(t('reset.error.noIdentifier'));
+  }
+
+  ui.log.message(`${kleur.dim('iOS bundle id:')} ${bundleId || kleur.dim('—')}`);
+  ui.log.message(`${kleur.dim('Android package:')} ${packageName || kleur.dim('—')}`);
+
+  const scanSpinner = ui.spinner();
+  scanSpinner.start(t('reset.scanning'));
+  const allDevices = await listFlutterDevices(projectDir);
+  const devices = filterDevices(allDevices, options);
+  scanSpinner.stop(t('reset.scanning'));
+
+  if (devices.length === 0) {
+    ui.log.warn(t('reset.warn.noDevices'));
+    return;
+  }
+
+  const target = await pickDevice(devices, t);
+  if (!target) {
+    ui.log.warn(t('reset.warn.nothingSelected'));
+    return;
+  }
+
+  const kind = classifyTarget(target);
+
+  if (kind === 'ios-device') {
+    const proceed = await ensureXcodeClosed(t);
+    if (!proceed) {
+      ui.outro(t('reset.outro.cancelled'));
+      return;
+    }
+  }
+
+  ui.log.step(kleur.bold(`${t('reset.resetting')}: ${target.name}`));
+
+  let didReset = false;
+  switch (kind) {
+    case 'ios-simulator':
+      if (!bundleId) {
+        ui.log.error(t('reset.error.noBundleId'));
+        break;
+      }
+      didReset = resetIosSimulator(target, bundleId, t);
+      break;
+    case 'ios-device':
+      if (!bundleId) {
+        ui.log.error(t('reset.error.noBundleId'));
+        break;
+      }
+      didReset = resetIosDevice(target, bundleId, t);
+      break;
+    case 'android-emulator':
+    case 'android-device':
+      if (!packageName) {
+        ui.log.error(t('reset.error.noPackageName'));
+        break;
+      }
+      didReset = resetAndroid(target, packageName, t);
+      break;
+    case 'web':
+      noticeWeb(t);
+      break;
+    default:
+      ui.log.warn(`${t('reset.warn.unknownPlatform')}: ${kind}`);
+  }
+
+  if (!didReset) {
+    ui.outro(t('reset.outro.skipped'));
+    return;
+  }
+
+  if (options.reinstall === false) {
+    ui.outro(t('reset.outro.uninstalledOnly'));
+    return;
+  }
+
+  const proceed = await ui.confirm({
+    message: t('reset.prompt.reinstallNow'),
+    initialValue: true,
+  });
+  if (!proceed) {
+    ui.outro(t('reset.outro.uninstalledOnly'));
+    return;
+  }
+
+  ui.log.step(kleur.bold(t('reset.reinstalling')));
+  await runFlutterOnDevice(target, projectDir, t);
+}
+
+module.exports = { runReset };

package/lib/commands/run.js

@@ -1,9 +1,9 @@
-const { spawn } = require('node:child_process');
 const path = require('node:path');
 const fs = require('fs-extra');
 const kleur = require('kleur');
 const { createTranslator, detectDefaultLanguage } = require('../utils/i18n');
 const { printCompactHeader } = require('../utils/brand');
+const { spawnFlutterWithSpinner } = require('../utils/flutter-run');
 
 /**
  * Read dart-define args from .vscode/launch.json.
@@ -54,25 +54,32 @@ async function runRun(directory, options = {}) {
 
   const args = ['run', ...deviceArgs, ...dartDefines];
 
+  const envDefine = dartDefines.find((a) => a.startsWith('--dart-define=ENV='));
+  const envValue = envDefine ? envDefine.split('=').pop() : null;
+  const deviceLabel = options.web
+    ? 'chrome'
+    : options.ios
+    ? 'ios'
+    : options.android
+    ? 'android'
+    : options.device || null;
+  const summaryParts = [];
+  if (envValue) summaryParts.push(`ENV=${envValue}`);
+  if (deviceLabel) summaryParts.push(`device: ${deviceLabel}`);
+  const summary = summaryParts.length ? ` (${summaryParts.join(', ')})` : '';
+
   printCompactHeader(t);
-  console.log(kleur.bold(`${t('run.launching')}`));
-  console.log(kleur.dim(`  flutter ${args.join(' ')}`));
+  console.log(kleur.bold(`${t('run.launching')}${summary}`));
   console.log(kleur.dim(`  ✦ ${t('run.updateHint.prefix')} `) + kleur.cyan('kasy update') + kleur.dim(` ${t('run.updateHint.suffix')}\n`));
 
-  return new Promise((resolve, reject) => {
-    const proc = spawn('flutter', args, { cwd: projectDir, stdio: 'inherit' });
-    proc.on('close', (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`flutter run exited with code ${code}`));
-    });
-    proc.on('error', (err) => {
-      if (err.code === 'ENOENT') {
-        reject(new Error(t('run.error.flutterNotFound')));
-      } else {
-        reject(err);
-      }
-    });
-  });
+  try {
+    await spawnFlutterWithSpinner(args, projectDir, t);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error(t('run.error.flutterNotFound'));
+    }
+    throw err;
+  }
 }
 
 module.exports = { runRun };

package/lib/commands/splash.js

@@ -0,0 +1,219 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const fsp = require('node:fs/promises');
+const { exec } = require('node:child_process');
+const { promisify } = require('node:util');
+const kleur = require('kleur');
+const ui = require('../utils/ui');
+const { printCompactHeader } = require('../utils/brand');
+const { createTranslator, detectDefaultLanguage } = require('../utils/i18n');
+
+const execAsync = promisify(exec);
+
+const ASSETS_DIR = path.join('assets', 'images');
+const LIGHT_NAME = 'splash_logo_light.png';
+const DARK_NAME = 'splash_logo_dark.png';
+
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+/**
+ * Parse the PNG IHDR chunk to read color type and detect transparency.
+ *
+ * PNG layout: 8-byte signature + chunks. The IHDR chunk is always first,
+ * placed at byte offset 8. It holds: length(4) + "IHDR"(4) + data(13) + crc(4).
+ * Color type is the 10th byte of data → absolute offset 25.
+ *
+ * Color types with alpha or transparency support:
+ *   4 = grayscale + alpha
+ *   6 = truecolor + alpha
+ *   3 = indexed (transparency only if a tRNS chunk is present)
+ *
+ * @param {string} filePath
+ * @returns {Promise<{ valid: boolean, hasAlpha: boolean, colorType: number, width: number, height: number }>}
+ */
+async function inspectPng(filePath) {
+  const handle = await fsp.open(filePath, 'r');
+  try {
+    const header = Buffer.alloc(33);
+    await handle.read(header, 0, 33, 0);
+    const sig = header.subarray(0, 8);
+    if (!sig.equals(PNG_SIGNATURE)) {
+      return { valid: false, hasAlpha: false, colorType: -1, width: 0, height: 0 };
+    }
+    const width = header.readUInt32BE(16);
+    const height = header.readUInt32BE(20);
+    const colorType = header.readUInt8(25);
+
+    let hasAlpha = colorType === 4 || colorType === 6;
+
+    if (!hasAlpha && colorType === 3) {
+      const { size } = await handle.stat();
+      const remaining = Math.min(size - 33, 256 * 1024);
+      if (remaining > 0) {
+        const tail = Buffer.alloc(remaining);
+        await handle.read(tail, 0, remaining, 33);
+        if (tail.includes(Buffer.from('tRNS'))) {
+          hasAlpha = true;
+        }
+      }
+    }
+
+    return { valid: true, hasAlpha, colorType, width, height };
+  } finally {
+    await handle.close();
+  }
+}
+
+async function assertKasyProject(projectDir, t) {
+  const kitSetupPath = path.join(projectDir, 'kit_setup.json');
+  const pubspecPath = path.join(projectDir, 'pubspec.yaml');
+  if (!(await fs.pathExists(kitSetupPath)) && !(await fs.pathExists(pubspecPath))) {
+    throw new Error(t('splash.error.notKasyProject'));
+  }
+  const assetsDir = path.join(projectDir, ASSETS_DIR);
+  await fs.ensureDir(assetsDir);
+}
+
+/**
+ * @param {string} flagValue
+ */
+function resolveInputPath(flagValue) {
+  if (!flagValue) return null;
+  const expanded = flagValue.startsWith('~')
+    ? path.join(require('node:os').homedir(), flagValue.slice(1))
+    : flagValue;
+  return path.resolve(expanded);
+}
+
+/**
+ * @param {string} projectDir
+ * @param {{ light?: string, dark?: string, skipGenerate?: boolean, language?: string }} options
+ */
+async function runSplash(projectDir, options = {}) {
+  const language = options.language || detectDefaultLanguage();
+  const t = createTranslator(language);
+
+  printCompactHeader();
+  ui.intro(kleur.bold().cyan(t('splash.intro')));
+
+  await assertKasyProject(projectDir, t);
+
+  const lightPath = resolveInputPath(options.light);
+  const darkPath = resolveInputPath(options.dark);
+
+  if (!lightPath || !darkPath) {
+    ui.log.error(t('splash.error.bothRequired'));
+    ui.log.message(kleur.dim('kasy splash --light <light.png> --dark <dark.png>'));
+    process.exit(1);
+  }
+
+  for (const [role, p] of [['light', lightPath], ['dark', darkPath]]) {
+    if (!(await fs.pathExists(p))) {
+      ui.log.error(t('splash.error.fileNotFound', { path: p }));
+      process.exit(1);
+    }
+  }
+
+  const inspectSpinner = ui.spinner();
+  inspectSpinner.start(t('splash.validating'));
+
+  let lightInfo;
+  let darkInfo;
+  try {
+    lightInfo = await inspectPng(lightPath);
+    darkInfo = await inspectPng(darkPath);
+  } catch (err) {
+    inspectSpinner.stop(`✖ ${err.message || t('splash.error.notPng')}`);
+    process.exit(1);
+  }
+
+  if (!lightInfo.valid || !darkInfo.valid) {
+    inspectSpinner.stop(`✖ ${t('splash.error.notPng')}`);
+    process.exit(1);
+  }
+
+  inspectSpinner.stop(t('splash.validated'));
+
+  const warnings = [];
+  if (!lightInfo.hasAlpha) {
+    warnings.push(t('splash.warn.noAlphaLight', { path: path.basename(lightPath) }));
+  }
+  if (!darkInfo.hasAlpha) {
+    warnings.push(t('splash.warn.noAlphaDark', { path: path.basename(darkPath) }));
+  }
+  if (lightInfo.width < 768 || lightInfo.height < 768) {
+    warnings.push(t('splash.warn.smallLight', {
+      w: lightInfo.width,
+      h: lightInfo.height,
+    }));
+  }
+  if (darkInfo.width < 768 || darkInfo.height < 768) {
+    warnings.push(t('splash.warn.smallDark', {
+      w: darkInfo.width,
+      h: darkInfo.height,
+    }));
+  }
+  if (warnings.length > 0) {
+    ui.note(warnings.map((w) => `${kleur.yellow('⚠')} ${w}`).join('\n'), t('splash.warn.title'));
+  }
+
+  const destLight = path.join(projectDir, ASSETS_DIR, LIGHT_NAME);
+  const destDark = path.join(projectDir, ASSETS_DIR, DARK_NAME);
+
+  const copySpinner = ui.spinner();
+  copySpinner.start(t('splash.copying'));
+  await fs.copy(lightPath, destLight, { overwrite: true });
+  await fs.copy(darkPath, destDark, { overwrite: true });
+  copySpinner.stop(t('splash.copied'));
+
+  if (options.skipGenerate) {
+    ui.note(t('splash.skipGenerate.hint'), t('splash.skipGenerate.title'));
+    ui.outro(t('splash.done'));
+    return;
+  }
+
+  const genSpinner = ui.spinner();
+  genSpinner.start(t('splash.generating'));
+  const result = await runFlutterNativeSplash(projectDir);
+  if (result.ok) {
+    genSpinner.stop(t('splash.generated'));
+  } else {
+    genSpinner.stop(`⚠ ${t('splash.error.generateFailed')}`);
+    if (result.stderr) {
+      ui.log.message(kleur.dim(result.stderr.split('\n').slice(0, 8).join('\n')));
+    }
+    ui.log.message(kleur.dim('dart run flutter_native_splash:create'));
+    process.exit(1);
+  }
+
+  const summary = [
+    `${kleur.bold(t('splash.summary.light'))}: ${kleur.white(LIGHT_NAME)} (${lightInfo.width}x${lightInfo.height})`,
+    `${kleur.bold(t('splash.summary.dark'))}:  ${kleur.white(DARK_NAME)} (${darkInfo.width}x${darkInfo.height})`,
+  ].join('\n');
+  ui.note(summary, t('splash.summary.title'));
+
+  ui.outro(t('splash.done'));
+}
+
+async function runFlutterNativeSplash(projectDir) {
+  try {
+    const { stdout, stderr } = await execAsync(
+      'dart run flutter_native_splash:create',
+      {
+        cwd: projectDir,
+        maxBuffer: 16 * 1024 * 1024,
+        timeout: 240_000,
+      },
+    );
+    return { ok: true, stdout, stderr };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err.message,
+      stdout: err.stdout || '',
+      stderr: err.stderr || '',
+    };
+  }
+}
+
+module.exports = { runSplash, inspectPng };

package/lib/commands/update.js

@@ -374,7 +374,7 @@ async function runUpdate(module, options = {}) {
 
     // build_runner (only for modules that generate code)
     if (NEEDS_BUILD_RUNNER.includes(normalized)) {
-      const spinner = ui.spinner();
+      const spinner = ui.timedSpinner();
       spinner.start(t('update.buildRunner'));
       try {
         await execAsync(

package/lib/scaffold/CHANGELOG.json

@@ -1,4 +1,13 @@
 {
+  "1.13.0": {
+    "modules": {
+      "onboarding": {
+        "pt": "Botão \"Já tem conta? Entrar\" na primeira tela do onboarding — quem já tem conta entra direto sem passar pelo fluxo todo, sem precisar criar usuário anônimo antes",
+        "en": "\"Already have an account? Log in\" button on the first onboarding screen — returning users go straight to sign-in instead of going through the full flow as an anonymous user first",
+        "es": "Botón \"¿Ya tienes cuenta? Iniciar sesión\" en la primera pantalla del onboarding — quien ya tiene cuenta entra directo sin pasar por todo el flujo como usuario anónimo"
+      }
+    }
+  },
   "1.10.0": {
     "modules": {
       "widget": {