kasy-cli 1.13.0 → 1.14.0

package/lib/utils/apple-release.js

@@ -5,7 +5,7 @@ const fs = require('fs-extra');
 const os = require('node:os');
 const kleur = require('kleur');
 const ui = require('./ui');
-const { exec } = require('node:child_process');
+const { exec, spawn } = require('node:child_process');
 const { promisify } = require('node:util');
 
 const execAsync = promisify(exec);
@@ -43,6 +43,27 @@ async function isKasyFlutterProject(projectDir) {
 }
 
 async function readBundleId(projectDir) {
+  // Source of truth is the Xcode project file — what the build actually uses
+  // when installing on a device. kit_setup.json can drift if the user renames
+  // the bundle id manually after `kasy new`, so it's only used as a fallback
+  // when the iOS project hasn't been generated yet.
+  const pbxPath = path.join(projectDir, 'ios', 'Runner.xcodeproj', 'project.pbxproj');
+  if (await fs.pathExists(pbxPath)) {
+    const content = await fs.readFile(pbxPath, 'utf8');
+    // Match the main target only — skip Widget/NotificationService extensions
+    // by picking the first identifier that doesn't contain a dot extension.
+    const matches = [...content.matchAll(/PRODUCT_BUNDLE_IDENTIFIER = ([^;]+);/g)];
+    for (const m of matches) {
+      const id = m[1].trim().replace(/"/g, '');
+      if (
+        !id.endsWith('.HomeWidgetExtension') &&
+        !id.endsWith('.NotificationService')
+      ) {
+        return id;
+      }
+    }
+    if (matches[0]) return matches[0][1].trim().replace(/"/g, '');
+  }
   const kitSetupPath = path.join(projectDir, 'kit_setup.json');
   if (await fs.pathExists(kitSetupPath)) {
     try {
@@ -52,12 +73,6 @@ async function readBundleId(projectDir) {
       // ignore
     }
   }
-  const pbxPath = path.join(projectDir, 'ios', 'Runner.xcodeproj', 'project.pbxproj');
-  if (await fs.pathExists(pbxPath)) {
-    const content = await fs.readFile(pbxPath, 'utf8');
-    const m = content.match(/PRODUCT_BUNDLE_IDENTIFIER = ([^;]+);/);
-    if (m) return m[1].trim().replace(/"/g, '');
-  }
   return null;
 }
 
@@ -247,15 +262,69 @@ async function runReleaseScript(projectDir, args, t) {
   if (!(await fs.pathExists(scriptPath))) {
     throw new Error(t('ios.error.noScript'));
   }
-  const cmd = `bash "${scriptPath}" ${args.join(' ')}`.trim();
-  try {
-    await execAsync(cmd, { cwd: projectDir, maxBuffer: 50 * 1024 * 1024 });
-  } catch (err) {
-    const output = [err.stdout, err.stderr, err.message].filter(Boolean).join('\n');
-    const error = new Error(output || err.message);
-    error.buildOutput = output;
-    throw error;
-  }
+
+  const isBuildOnly = args.includes('--no-upload');
+  const titleKey = isBuildOnly ? 'ios.build.task.building' : 'ios.release.task.building';
+  const doneKey = isBuildOnly ? 'ios.build.task.done' : 'ios.release.task.done';
+  const failKey = isBuildOnly ? 'ios.build.task.failed' : 'ios.release.task.failed';
+
+  const spinner = ui.timedSpinner();
+  spinner.start(t(titleKey));
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn('bash', [scriptPath, ...args], {
+      cwd: projectDir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let allOutput = '';
+    let uploadStage = false;
+
+    // Trim noise so the spinner message stays readable. Skip empty lines,
+    // pure dotted progress bars (e.g. "....."), and lines that are just
+    // separators. Show the last meaningful line as the spinner status.
+    const isMeaningful = (line) => {
+      if (!line) return false;
+      if (/^[.\s]+$/.test(line)) return false;
+      if (/^=+$/.test(line)) return false;
+      return true;
+    };
+
+    const handleChunk = (chunk) => {
+      const text = chunk.toString();
+      allOutput += text;
+
+      if (!uploadStage && /Uploading to App Store Connect/i.test(text)) {
+        uploadStage = true;
+        spinner.message(t('ios.release.task.uploading'));
+        return;
+      }
+
+      const lines = text.split('\n').map((l) => l.replace(/\r/g, '').trim()).filter(isMeaningful);
+      const lastLine = lines[lines.length - 1];
+      if (lastLine) spinner.message(lastLine);
+    };
+
+    proc.stdout.on('data', handleChunk);
+    proc.stderr.on('data', handleChunk);
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        spinner.stop(t(doneKey));
+        resolve();
+      } else {
+        spinner.stop(t(failKey), 2);
+        const error = new Error(allOutput || `release script exited with code ${code}`);
+        error.buildOutput = allOutput;
+        reject(error);
+      }
+    });
+
+    proc.on('error', (err) => {
+      spinner.stop(t(failKey), 2);
+      reject(err);
+    });
+  });
 }
 
 module.exports = {

package/lib/utils/checks.js

@@ -1,13 +1,10 @@
 const { exec } = require('node:child_process');
 const { promisify } = require('node:util');
-const readline = require('node:readline');
 const kleur = require('kleur');
-const oraPackage = require('ora');
 const ui = require('./ui');
 const { createTranslator, detectDefaultLanguage } = require('./i18n');
 
 const execAsync = promisify(exec);
-const ora = oraPackage.default || oraPackage;
 
 // Timeout para verificar se uma ferramenta está instalada (15 s é mais que suficiente)
 const TOOL_CHECK_TIMEOUT = 15_000;
@@ -19,19 +16,6 @@ const MIN_NODE_VERSION = '18.0.0';
 const MIN_FLUTTER_VERSION = '3.24.0';
 const MIN_DART_VERSION = '3.5.0';
 
-/**
- * Compare two semver strings. Returns true if actual >= required.
- */
-function meetsMinVersion(actual, required) {
-  if (!actual || !required) return true;
-  const parse = (v) => v.replace(/[^0-9.]/g, '').split('.').map(Number);
-  const [aMaj, aMin, aPat = 0] = parse(actual);
-  const [rMaj, rMin, rPat = 0] = parse(required);
-  if (aMaj !== rMaj) return aMaj > rMaj;
-  if (aMin !== rMin) return aMin > rMin;
-  return aPat >= rPat;
-}
-
 const BASE_CHECKS = [
   {
     name: 'Node.js',
@@ -175,128 +159,43 @@ function extractVersion(stdout, checkName) {
   return m ? m[0] : raw.slice(0, 20);
 }
 
-/**
- * Wait for the user to press Enter in the terminal.
- * Used to pause the flow so the user can install something or authenticate.
- */
-function waitForUserInput(prompt) {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const done = () => { rl.close(); resolve(); };
-    rl.question(`\n  ${kleur.cyan(prompt)}\n  `, done);
-    rl.on('close', resolve);
-    rl.on('error', resolve);
-  });
-}
-
 async function runSingleCheck(check, options = {}) {
   const showVersion = check.showVersion !== undefined ? check.showVersion : (options.showVersion !== undefined ? options.showVersion : true);
-  const silent = options.silent === true;
-  const t = check.t || createTranslator(check.language || detectDefaultLanguage());
-  const spinner = silent ? null : ora(t('checks.checking', { name: check.name })).start();
   let autoInstallFailed = false;
 
   try {
     const { stdout } = await execAsync(check.command, { encoding: 'utf8', timeout: TOOL_CHECK_TIMEOUT });
     const version = showVersion ? extractVersion(stdout, check.name) : null;
-    const msg = version
-      ? t('checks.foundWithVersion', { name: check.name, version })
-      : t('checks.found', { name: check.name });
-
-    if (!silent) {
-      // Warn if version is below minimum requirement
-      if (version && check.minVersion && !meetsMinVersion(version, check.minVersion)) {
-        spinner.warn(`${msg} ${kleur.yellow(`(mínimo recomendado: ${check.minVersion})`)}`);
-      } else {
-        spinner.succeed(msg);
-      }
-    }
     return { ...check, ok: true, version: version || null };
   } catch (err) {
     const diagnosis = diagnoseFailure(err);
     if (check.tryInstall) {
-      if (!silent) spinner.text = t(check.tryInstallMessageKey || 'setup.flutterfire.installing');
       try {
         await execAsync(check.tryInstall, { encoding: 'utf8', timeout: INSTALL_TIMEOUT });
         const { stdout: retryOut } = await execAsync(check.retryCommand || check.command, { encoding: 'utf8', timeout: TOOL_CHECK_TIMEOUT });
         const version = showVersion ? extractVersion(retryOut, check.name) : null;
-        const msg = version
-          ? t('checks.foundWithVersion', { name: check.name, version: version || 'installed' })
-          : t('checks.found', { name: check.name });
-        if (!silent) spinner.succeed(msg);
         return { ...check, ok: true, version: version || null };
       } catch {
         autoInstallFailed = true;
       }
     }
-
-    // Guided interactive prompt: show instructions and wait for the user to act.
-    if (check.waitPrompt && !silent) {
-      spinner.stop();
-      if (check.failHint) {
-        console.log(kleur.yellow(`\n  ⚠  ${check.name} não encontrado.\n`));
-        console.log(kleur.bold('  Execute:\n'));
-        console.log(kleur.cyan(`    ${check.failHint}\n`));
-      }
-      await waitForUserInput(check.waitPrompt);
-      try {
-        const { stdout: retryOut } = await execAsync(check.command, { encoding: 'utf8', timeout: TOOL_CHECK_TIMEOUT });
-        const version = showVersion ? extractVersion(retryOut, check.name) : null;
-        const msg = version
-          ? t('checks.foundWithVersion', { name: check.name, version })
-          : t('checks.found', { name: check.name });
-        spinner.succeed(msg);
-        return { ...check, ok: true, version: version || null };
-      } catch {
-        // Still failing — fall through to report
-      }
-    }
-
-    if (!silent) {
-      if (check.required) {
-        const detail = autoInstallFailed ? ` — ${t('checks.install.failed')}` : '';
-        const diagSuffix = diagnosis ? `\n    ${kleur.dim(`→ ${t(`checks.diagnostic.${diagnosis}`, { name: check.name })}`)}` : '';
-        spinner.fail(t('checks.missing', { name: check.name }) + detail + diagSuffix);
-      } else if (diagnosis) {
-        spinner.warn(t(`checks.diagnostic.${diagnosis}`, { name: check.name }));
-      } else {
-        const hint = !check.waitPrompt && check.failHint ? `\n    ${kleur.dim(`→ ${check.failHint}`)}` : '';
-        if (check.warnMessage) {
-          spinner.warn(check.warnMessage + hint);
-        } else if (check.warnMessageKey) {
-          spinner.warn(t(check.warnMessageKey) + hint);
-        } else {
-          spinner.warn(t('checks.notFound', { name: check.name }) + hint);
-        }
-      }
-    }
-
     return { ...check, ok: false, autoInstallFailed, diagnosis };
   }
 }
 
 async function runChecks(checks, title, options = {}) {
   const t = options.t || createTranslator(options.language || detectDefaultLanguage());
-  const { showVersion = true, compact = false } = options;
-
-  if (!compact) {
-    console.log(kleur.bold(`\n${title}`));
-    const results = [];
-    for (const check of checks) {
-      const result = await runSingleCheck({ ...check, t }, { showVersion });
-      results.push(result);
-    }
-    return results;
-  }
+  const { showVersion = true } = options;
 
-  // Compact mode: single spinner, show failures only
+  // Single spinner over all checks, show failures afterwards. The visual
+  // sits inside the clack rail (│) opened by the caller's ui.intro().
   const { spinnerLabel = title, doneLabel = title } = options;
   const spinner = ui.spinner();
   spinner.start(spinnerLabel);
 
   const results = [];
   for (const check of checks) {
-    results.push(await runSingleCheck({ ...check, t }, { showVersion, silent: true }));
+    results.push(await runSingleCheck({ ...check, t }, { showVersion }));
   }
 
   const failures = results.filter((r) => !r.ok);

package/lib/utils/flutter-run.js

@@ -0,0 +1,173 @@
+/**
+ * Shared launcher for `flutter run` invocations.
+ *
+ * Both `kasy run` and `kasy reset` (reinstall step) call this so the spinner,
+ * stage detection, elapsed timer, hot-reload stdin pass-through and SIGINT
+ * forwarding stay consistent in one place.
+ *
+ * Flow:
+ *  - Spawn flutter with piped stdio.
+ *  - Show a Clack spinner with elapsed time, ticking every second.
+ *  - As Flutter logs scroll, update the spinner message when we see a known
+ *    stage marker (Gradle, Xcode, install, sync, etc.).
+ *  - When Flutter signals "ready" (DAP key commands), flush buffered output,
+ *    drop into stdio pass-through and pipe stdin so hot reload works.
+ *  - On early exit, replay the buffer so the user can see the error.
+ */
+
+'use strict';
+
+const { spawn } = require('node:child_process');
+const kleur = require('kleur');
+const ui = require('./ui');
+
+// Markers that tell us the initial build is done and the app is running.
+const FLUTTER_READY_RE = /Flutter run key commands\.|is listening on|VM Service|Dart VM service|To hot reload|Hot restart/i;
+
+/**
+ * Map a chunk of Flutter output to a user-friendly stage label, or null
+ * if the chunk doesn't carry any of the known markers.
+ */
+function detectStage(text, t) {
+  if (/Running Gradle task 'assembleDebug'/.test(text)) {
+    return t('run.stage.gradleFirstTime');
+  }
+  if (/Running Gradle task/.test(text)) {
+    return t('run.stage.gradle');
+  }
+  if (/Running Xcode build/.test(text)) {
+    return t('run.stage.xcode');
+  }
+  if (/Running pod install/i.test(text)) {
+    return t('run.stage.pods');
+  }
+  if (/Installing build\/.+\.(apk|ipa|app)/i.test(text)) {
+    return t('run.stage.installing');
+  }
+  if (/Syncing files to device/i.test(text)) {
+    return t('run.stage.syncing');
+  }
+  if (/BUILD SUCCESSFUL/.test(text)) {
+    return t('run.stage.buildSuccess');
+  }
+  return null;
+}
+
+function formatElapsed(startTime) {
+  const elapsed = Math.floor((Date.now() - startTime) / 1000);
+  if (elapsed < 60) return `${elapsed}s`;
+  const m = Math.floor(elapsed / 60);
+  const s = elapsed % 60;
+  return `${m}m ${s}s`;
+}
+
+function render(stageMessage, startTime) {
+  return `${stageMessage}  ${kleur.dim(`[${formatElapsed(startTime)}]`)}`;
+}
+
+/**
+ * Spawn `flutter` with the given args inside `projectDir`, surfacing progress
+ * through a Clack spinner. Resolves on success, rejects on non-zero exit.
+ */
+function spawnFlutterWithSpinner(args, projectDir, t) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('flutter', args, {
+      cwd: projectDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    const spinner = ui.spinner();
+    const startTime = Date.now();
+    let stageMessage = t('run.spinner.building');
+    let ready = false;
+    const buffer = [];
+
+    spinner.start(render(stageMessage, startTime));
+
+    // Tick the elapsed time every second while still building. Once ready,
+    // the spinner is gone and we stop ticking.
+    const tick = setInterval(() => {
+      if (!ready) spinner.message(render(stageMessage, startTime));
+    }, 1000);
+
+    const flushAndSwitch = () => {
+      if (ready) return;
+      ready = true;
+      clearInterval(tick);
+      const total = formatElapsed(startTime);
+      spinner.stop(`${t('run.spinner.ready')}  ${kleur.dim(`[${total}]`)}`);
+      for (const chunk of buffer) process.stdout.write(chunk);
+      buffer.length = 0;
+      // Pipe stdin so the user can type r / R / q to control Flutter.
+      if (process.stdin.isTTY) {
+        try { process.stdin.setRawMode(true); } catch (_) {}
+        process.stdin.resume();
+        process.stdin.pipe(proc.stdin);
+      }
+    };
+
+    const handleStdout = (chunk) => {
+      const text = chunk.toString();
+      if (!ready) {
+        buffer.push(chunk);
+        const nextStage = detectStage(text, t);
+        if (nextStage && nextStage !== stageMessage) {
+          stageMessage = nextStage;
+          spinner.message(render(stageMessage, startTime));
+        }
+        if (FLUTTER_READY_RE.test(text)) flushAndSwitch();
+      } else {
+        process.stdout.write(chunk);
+      }
+    };
+
+    const handleStderr = (chunk) => {
+      if (!ready) {
+        buffer.push(chunk);
+        if (FLUTTER_READY_RE.test(chunk.toString())) flushAndSwitch();
+      } else {
+        process.stderr.write(chunk);
+      }
+    };
+
+    proc.stdout.on('data', handleStdout);
+    proc.stderr.on('data', handleStderr);
+
+    const sigintHandler = () => { try { proc.kill('SIGINT'); } catch (_) {} };
+    process.on('SIGINT', sigintHandler);
+
+    const cleanup = () => {
+      clearInterval(tick);
+      process.off('SIGINT', sigintHandler);
+      if (process.stdin.isTTY) {
+        try { process.stdin.setRawMode(false); } catch (_) {}
+        process.stdin.unpipe(proc.stdin);
+        process.stdin.pause();
+      }
+    };
+
+    proc.on('close', (code) => {
+      cleanup();
+      if (!ready) {
+        spinner.stop(t('run.spinner.failed'), 2);
+        for (const chunk of buffer) process.stdout.write(chunk);
+      }
+      if (code === 0) resolve();
+      else reject(new Error(`flutter exited with code ${code}`));
+    });
+
+    proc.on('error', (err) => {
+      cleanup();
+      if (!ready) spinner.stop(t('run.spinner.failed'), 2);
+      reject(err);
+    });
+  });
+}
+
+module.exports = {
+  spawnFlutterWithSpinner,
+  // Exported for tests and reuse in non-flutter spawn helpers.
+  detectStage,
+  formatElapsed,
+  FLUTTER_READY_RE,
+};