kasy-cli 1.10.0 → 1.13.0

package/bin/kasy.js

@@ -15,6 +15,7 @@ const { runRemove } = require('../lib/commands/remove');
 const { runUpdate } = require('../lib/commands/update');
 const { runDocs } = require('../lib/commands/docs');
 const { runNotificationsText } = require('../lib/commands/notifications');
+const { runSplash } = require('../lib/commands/splash');
 const {
   runConfigure: runIosConfigure,
   runBuild: runIosBuild,
@@ -242,14 +243,15 @@ function buildProgram(language) {
   const langName = t('cli.command.setup.langName');
   applyLocalizedHelp(
     program
-      .command('setup')
+      .command('setup', { hidden: true })
       .argument(`[${directoryName}]`, t('cli.command.setup.directoryArg'), '.')
       .option(`-l, --lang <${langName}>`, t('cli.command.setup.langOption'))
       .option('-b, --backend <backend>', t('cli.command.setup.backendOption'))
       .option('--with <features>', t('cli.command.setup.featuresOption'))
       .description(t('cli.command.setup.description'))
       .action(async (directory, options) => {
-        // `setup` is an alias for `new` — unified flow
+        // `setup` is an alias for `new` — unified flow.
+        // Hidden from root help to reduce noise; still callable.
         await runNew(directory, {
           language: options.lang,
           backend: options.backend,
@@ -509,6 +511,26 @@ function buildProgram(language) {
     t
   );
 
+  applyLocalizedHelp(
+    program
+      .command('splash')
+      .argument('[directory]', 'Project folder (default: current directory)', '.')
+      .requiredOption('--light <path>', 'PNG with dark logo (shown in light mode)')
+      .requiredOption('--dark <path>', 'PNG with light logo (shown in dark mode)')
+      .option('--skip-generate', 'Only copy files, do not run flutter_native_splash:create', false)
+      .description(t('cli.command.splash.description'))
+      .action(async (directory, options) => {
+        const dir = directory || '.';
+        await runSplash(dir, {
+          language,
+          light: options.light,
+          dark: options.dark,
+          skipGenerate: options.skipGenerate,
+        });
+      }),
+    t
+  );
+
   const notificationsCmd = program
     .command('notifications')
     .description(t('cli.command.notifications.description'));
@@ -516,7 +538,6 @@ function buildProgram(language) {
     notificationsCmd
       .command('text')
       .argument('[directory]', 'Project folder (default: current directory)', '.')
-      .option('-d, --directory <path>', 'Project folder (default: current directory)')
       .option('--locale <code>', 'i18n files to update: pt, en, es, or all (default: all)', 'all')
       .option('--demo-title <text>', 'Home → Features demo notification title')
       .option('--demo-body <text>', 'Home → Features demo card description / instant notification body')
@@ -524,7 +545,7 @@ function buildProgram(language) {
       .option('--reminder-body <text>', 'Scheduled reminder notification body')
       .description(t('cli.command.notifications.text.description'))
       .action(async (directory, options) => {
-        const dir = options.directory || directory || '.';
+        const dir = directory || '.';
         await runNotificationsText(dir, {
           language,
           directory: dir,

package/lib/commands/check.js

@@ -110,67 +110,67 @@ async function runCheck(options = {}) {
   const t = createTranslator(lang);
 
   printCompactHeader(t);
-  ui.intro('Kasy Check — Push Notifications');
+  ui.intro(t('check.intro'));
 
   // ── Detect backend ────────────────────────────────────────────────────────
   const isFirebase = await fs.pathExists(path.join(projectDir, 'firebase.json'));
   const isSupabase = await fs.pathExists(path.join(projectDir, 'supabase'));
 
   if (isFirebase && !isSupabase) {
-    ok('Firebase backend');
-    info('Firebase usa Application Default Credentials — nenhuma configuração extra necessária.');
+    ok(t('check.firebase.detected'));
+    info(t('check.firebase.adcInfo'));
     const firebaseProjectId = await readFirebaseProjectId(projectDir);
     const apnsLines = [
-      kleur.yellow('Push iOS requer APNs Key (não verificável via CLI)'),
-      kleur.dim('Firebase Console → Cloud Messaging → app iOS → Chave de autenticação APNs'),
+      kleur.yellow(t('check.apns.warn')),
+      kleur.dim(t('check.apns.where')),
     ];
     if (firebaseProjectId) {
       apnsLines.push(kleur.cyan(`https://console.firebase.google.com/project/${firebaseProjectId}/settings/cloudmessaging`));
     }
     ui.note(apnsLines.join('\n'));
-    ui.outro('Done');
+    ui.outro(t('check.done'));
     return;
   }
 
   if (!isSupabase) {
-    ui.log.error('Diretório não parece ser um projeto Kasy.');
-    ui.cancel('Aborted');
+    ui.log.error(t('check.notKasy'));
+    ui.cancel(t('check.aborted'));
     process.exit(1);
   }
 
   // ── 1. Project linked? ────────────────────────────────────────────────────
   const projectRef = await readProjectRef(projectDir);
   if (!projectRef) {
-    fail('Projeto Supabase não vinculado', 'execute: supabase link --project-ref SEU_REF');
-    ui.cancel('Aborted');
+    fail(t('check.supabase.notLinked'), t('check.supabase.notLinkedHint'));
+    ui.cancel(t('check.aborted'));
     process.exit(1);
   }
-  ok('Projeto vinculado', projectRef);
+  ok(t('check.supabase.linked'), projectRef);
 
   // ── Read secrets list ─────────────────────────────────────────────────────
   const spinner = ui.spinner();
-  spinner.start('Verificando secrets…');
+  spinner.start(t('check.spin.secrets'));
   const secrets = await listSecretNames(projectDir);
-  spinner.stop('Secrets verificados');
+  spinner.stop(t('check.spin.secretsDone'));
 
   if (!secrets) {
-    warn('Não foi possível listar secrets', 'verifique: supabase login');
+    warn(t('check.secrets.listFailed'), t('check.secrets.checkLogin'));
   }
 
   // ── 2. FIREBASE_PROJECT_ID ────────────────────────────────────────────────
   const firebaseProjectId = await readFirebaseProjectId(projectDir);
   if (secrets) {
     if (secrets.has('FIREBASE_PROJECT_ID')) {
-      ok('FIREBASE_PROJECT_ID configurado');
+      ok(t('check.fbProjId.ok'));
     } else {
-      fail('FIREBASE_PROJECT_ID ausente');
+      fail(t('check.fbProjId.missing'));
       if (firebaseProjectId) {
-        ui.log.message(kleur.gray(`Corrija: supabase secrets set FIREBASE_PROJECT_ID="${firebaseProjectId}"`));
+        ui.log.message(kleur.gray(t('check.fbProjId.fixHint', { id: firebaseProjectId })));
         if (options.fix) {
           const r = await runCmd(`supabase secrets set FIREBASE_PROJECT_ID="${firebaseProjectId}"`, projectDir);
           r.ok
-            ? ok('FIREBASE_PROJECT_ID → configurado automaticamente')
-            : fail('FIREBASE_PROJECT_ID → falhou ao configurar', r.error);
+            ? ok(t('check.fbProjId.fixed'))
+            : fail(t('check.fbProjId.fixFailed'), r.error);
         }
       }
     }
@@ -179,15 +179,15 @@ async function runCheck(options = {}) {
   // ── 3. FIREBASE_SERVICE_ACCOUNT_JSON ─────────────────────────────────────
   if (secrets) {
     if (secrets.has('FIREBASE_SERVICE_ACCOUNT_JSON')) {
-      ok('FIREBASE_SERVICE_ACCOUNT_JSON configurado');
+      ok(t('check.fbSak.ok'));
     } else {
-      fail('FIREBASE_SERVICE_ACCOUNT_JSON ausente');
+      fail(t('check.fbSak.missing'));
 
       if (options.fix && firebaseProjectId) {
         const fixSpinner = ui.spinner();
-        fixSpinner.start('Gerando e configurando chave FCM…');
+        fixSpinner.start(t('check.fbSak.spin'));
         const fcmResult = await createFcmServiceAccountKey(firebaseProjectId);
-        fixSpinner.stop('Chave FCM gerada');
+        fixSpinner.stop(t('check.fbSak.spinDone'));
 
         if (fcmResult.ok) {
           const secretSteps = await setSupabaseSecrets(projectDir, {
@@ -196,62 +196,52 @@ async function runCheck(options = {}) {
           });
           const setStep = secretSteps.find((s) => s.name === 'secret FIREBASE_SERVICE_ACCOUNT_JSON');
           setStep?.ok
-            ? ok('FIREBASE_SERVICE_ACCOUNT_JSON → configurado automaticamente')
-            : fail('FIREBASE_SERVICE_ACCOUNT_JSON → falhou ao configurar', setStep?.error);
+            ? ok(t('check.fbSak.fixed'))
+            : fail(t('check.fbSak.fixFailed'), setStep?.error);
         } else {
-          fail('FIREBASE_SERVICE_ACCOUNT_JSON → não foi possível gerar chave', fcmResult.error);
-          ui.log.message(kleur.gray(
-            'Manual: Firebase Console → Configurações → Contas de serviço → Gerar chave\n' +
-            "Depois: supabase secrets set FIREBASE_SERVICE_ACCOUNT_JSON='$(cat chave.json)'"
-          ));
+          fail(t('check.fbSak.genFailed'), fcmResult.error);
+          ui.log.message(kleur.gray(t('check.fbSak.manual')));
         }
       } else {
-        ui.log.message(kleur.gray(
-          'Corrija automaticamente: kasy check --fix\n' +
-          'Ou manualmente: Firebase Console → Configurações → Contas de serviço → Gerar chave\n' +
-          "Depois: supabase secrets set FIREBASE_SERVICE_ACCOUNT_JSON='$(cat chave.json)'"
-        ));
+        ui.log.message(kleur.gray(t('check.fbSak.hint')));
       }
     }
   }
 
   // ── 4. Edge function send-push-notification ────────────────────────────────
   const fnSpinner = ui.spinner();
-  fnSpinner.start('Verificando edge functions…');
+  fnSpinner.start(t('check.fn.spin'));
   const functions = await listDeployedFunctions(projectDir);
-  fnSpinner.stop('Edge functions verificadas');
+  fnSpinner.stop(t('check.fn.spinDone'));
 
   if (!functions) {
-    warn('Não foi possível listar edge functions', 'verifique: supabase login');
+    warn(t('check.fn.listFailed'), t('check.secrets.checkLogin'));
   } else if (functions.has('send-push-notification')) {
-    ok('Edge function send-push-notification deployada');
+    ok(t('check.fn.deployed'));
   } else {
-    fail('Edge function send-push-notification não deployada');
+    fail(t('check.fn.missing'));
     if (options.fix) {
       const deploySpinner = ui.spinner();
-      deploySpinner.start('Publicando send-push-notification…');
+      deploySpinner.start(t('check.fn.deploySpin'));
       const r = await runCmd('supabase functions deploy send-push-notification', projectDir);
       r.ok
-        ? deploySpinner.stop('send-push-notification → deployada automaticamente')
-        : deploySpinner.error(`send-push-notification → falhou no deploy${r.error ? ` — ${r.error}` : ''}`);
+        ? deploySpinner.stop(t('check.fn.deployDone'))
+        : deploySpinner.error(`${t('check.fn.deployFailed')}${r.error ? ` — ${r.error}` : ''}`);
     } else {
-      ui.log.message(kleur.gray(
-        'Corrija automaticamente: kasy check --fix\n' +
-        'Ou manualmente: supabase functions deploy send-push-notification'
-      ));
+      ui.log.message(kleur.gray(t('check.fn.hint')));
     }
   }
 
   // ── 5. APNs reminder ─────────────────────────────────────────────────────
   const apnsLines = [
-    kleur.yellow('Push iOS requer APNs Key (não verificável via CLI)'),
-    kleur.dim('Firebase Console → Cloud Messaging → app iOS → Chave de autenticação APNs'),
+    kleur.yellow(t('check.apns.warn')),
+    kleur.dim(t('check.apns.where')),
   ];
   if (firebaseProjectId) {
     apnsLines.push(kleur.cyan(`https://console.firebase.google.com/project/${firebaseProjectId}/settings/cloudmessaging`));
   }
   ui.note(apnsLines.join('\n'));
-  ui.outro('Done');
+  ui.outro(t('check.done'));
 }
 
 module.exports = { runCheck };

package/lib/commands/deploy.js

@@ -123,14 +123,14 @@ async function deployFirebase(projectDir, options, tr) {
   }
 
   const spinner = ui.spinner();
-  spinner.start('Deploying Firebase...');
+  spinner.start(tr('deploy.firebase.spin'));
   let steps;
   try {
     steps = await runFirebaseDeploy(projectDir, null, firebaseProjectId, {
       functionsRegion,
       onProgress: (key) => { spinner.message(String(key)); },
     });
-    spinner.stop('Firebase deploy completed');
+    spinner.stop(tr('deploy.firebase.spinDone'));
   } catch (err) {
     spinner.error(err.message);
     throw err;
@@ -145,9 +145,9 @@ async function deployFirebase(projectDir, options, tr) {
   // ── APNs reminder — required for iOS push notifications ──────────────────
   // Cannot be automated: the .p8 key only exists in Apple Developer Portal.
   const apnsBody = [
-    kleur.yellow('Push iOS: configure a APNs Key no Firebase Console'),
-    kleur.dim('1. Apple Developer Portal → Keys → criar APNs Key (.p8)'),
-    kleur.dim('2. Firebase Console → Cloud Messaging → app iOS → upload da APNs Key'),
+    kleur.yellow(tr('deploy.apns.title')),
+    kleur.dim(tr('deploy.apns.step1')),
+    kleur.dim(tr('deploy.apns.step2')),
     kleur.cyan(`https://console.firebase.google.com/project/${firebaseProjectId}/settings/cloudmessaging`),
   ].join('\n');
   ui.note(apnsBody);
@@ -155,28 +155,28 @@ async function deployFirebase(projectDir, options, tr) {
 
 // ── Supabase deploy ───────────────────────────────────────────────────────────
 
-async function deploySupabase(projectDir) {
+async function deploySupabase(projectDir, tr) {
   // ── 1. Get project ref ──────────────────────────────────────────────────
   const projectRef = await readSupabaseProjectRef(projectDir);
   if (!projectRef) {
-    ui.log.error('Projeto Supabase não está vinculado neste diretório.');
-    ui.log.message(kleur.gray('Execute: supabase link --project-ref SEU_PROJECT_REF'));
+    ui.log.error(tr('deploy.supabase.notLinked'));
+    ui.log.message(kleur.gray(tr('deploy.supabase.linkHint')));
     process.exit(1);
   }
-  ui.log.message(kleur.gray(`Project ref: ${kleur.cyan(projectRef)}`));
+  ui.log.message(kleur.gray(tr('deploy.supabase.projectRef', { ref: kleur.cyan(projectRef) })));
 
   // ── 2. FCM Service Account JSON ─────────────────────────────────────────
   const alreadySet = await isServiceAccountJsonSet(projectDir);
   if (alreadySet) {
-    printStep(true, false, 'FIREBASE_SERVICE_ACCOUNT_JSON já configurado');
+    printStep(true, false, tr('deploy.supabase.sakAlready'));
   } else {
     const firebaseProjectId = await readFirebaseProjectId(projectDir);
 
     if (firebaseProjectId) {
       const fcmSpinner = ui.spinner();
-      fcmSpinner.start('Gerando chave FCM (Service Account)…');
+      fcmSpinner.start(tr('deploy.supabase.sakSpin'));
       const fcmResult = await createFcmServiceAccountKey(firebaseProjectId);
-      fcmSpinner.stop('Chave FCM gerada');
+      fcmSpinner.stop(tr('deploy.supabase.sakSpinDone'));
 
       if (fcmResult.ok) {
         const secretSteps = await setSupabaseSecrets(projectDir, {
@@ -186,23 +186,23 @@ async function deploySupabase(projectDir) {
         for (const s of secretSteps) printStep(s.ok, false, s.name, s.error);
       } else {
         printStep(false, false, 'FIREBASE_SERVICE_ACCOUNT_JSON', fcmResult.error);
-        ui.log.warn("Configure manualmente: supabase secrets set FIREBASE_SERVICE_ACCOUNT_JSON='...'");
+        ui.log.warn(tr('deploy.supabase.sakManual'));
       }
     } else {
-      printStep(false, false, 'FIREBASE_SERVICE_ACCOUNT_JSON', 'google-services.json não encontrado — configure manualmente');
+      printStep(false, false, 'FIREBASE_SERVICE_ACCOUNT_JSON', tr('deploy.supabase.sakNoGS'));
     }
   }
 
   // ── 3. Deploy edge functions ────────────────────────────────────────────
   const fnSpinner = ui.spinner();
-  fnSpinner.start('Publicando edge functions…');
+  fnSpinner.start(tr('deploy.supabase.fnSpin'));
   const fnResult = await deployFunctions(projectDir);
-  fnSpinner.stop('Edge functions processadas');
+  fnSpinner.stop(tr('deploy.supabase.fnSpinDone'));
 
   if (Array.isArray(fnResult)) {
     fnResult.forEach((s) => printStep(s.ok, s.skipped, s.name, s.error));
   } else if (fnResult.skipped) {
-    printStep(true, true, 'edge functions (nenhuma encontrada)');
+    printStep(true, true, tr('deploy.supabase.fnNone'));
   } else {
     printStep(fnResult.ok, false, 'supabase functions deploy', fnResult.error);
   }
@@ -210,9 +210,9 @@ async function deploySupabase(projectDir) {
   // ── 4. APNs reminder ────────────────────────────────────────────────────
   const firebaseProjectId = await readFirebaseProjectId(projectDir);
   const apnsLines = [
-    kleur.yellow('Push iOS: configure a APNs Key no Firebase Console'),
-    kleur.dim('1. Apple Developer Portal → Keys → criar APNs Key (.p8)'),
-    kleur.dim('2. Firebase Console → Cloud Messaging → app iOS → upload da APNs Key'),
+    kleur.yellow(tr('deploy.apns.title')),
+    kleur.dim(tr('deploy.apns.step1')),
+    kleur.dim(tr('deploy.apns.step2')),
   ];
   if (firebaseProjectId) {
     apnsLines.push(kleur.cyan(`https://console.firebase.google.com/project/${firebaseProjectId}/settings/cloudmessaging`));
@@ -240,17 +240,17 @@ async function runDeployCommand(directory, options = {}, { language: langHint }
 
   if (isFirebase) {
     printCompactHeader(tr);
-    ui.intro('Deploy — Firebase');
+    ui.intro(tr('deploy.firebase.intro'));
     await deployFirebase(projectDir, options, tr);
-    ui.outro('Deploy concluído');
+    ui.outro(tr('deploy.outro'));
     return;
   }
 
   if (isSupabase) {
     printCompactHeader(tr);
-    ui.intro('Deploy — Supabase');
-    await deploySupabase(projectDir);
-    ui.outro('Deploy concluído');
+    ui.intro(tr('deploy.supabase.intro'));
+    await deploySupabase(projectDir, tr);
+    ui.outro(tr('deploy.outro'));
     return;
   }
 

package/lib/commands/splash.js

@@ -0,0 +1,220 @@
+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
+ * @param {string} role 'light' | 'dark'
+ */
+function resolveInputPath(flagValue, role) {
+  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, 'light');
+  const darkPath = resolveInputPath(options.dark, '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/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": {