kasy-cli 1.5.3 → 1.6.0

package/lib/utils/checks.js

@@ -3,6 +3,7 @@ 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);
@@ -290,7 +291,8 @@ async function runChecks(checks, title, options = {}) {
 
   // Compact mode: single spinner, show failures only
   const { spinnerLabel = title, doneLabel = title } = options;
-  process.stdout.write(`  ${kleur.dim(spinnerLabel + '...')}\n`);
+  const spinner = ui.spinner();
+  spinner.start(spinnerLabel);
 
   const results = [];
   for (const check of checks) {
@@ -298,26 +300,35 @@ async function runChecks(checks, title, options = {}) {
   }
 
   const failures = results.filter((r) => !r.ok);
+  const requiredFailures = failures.filter((r) => r.required);
 
   if (failures.length === 0) {
-    console.log(kleur.green(`  ✔ ${doneLabel}`));
+    spinner.stop(doneLabel);
     return results;
   }
 
+  // Close the spinner reflecting what actually happened: red ▲ if a required
+  // check failed, default green ✦ if only optional checks failed (warnings).
+  if (requiredFailures.length > 0) {
+    spinner.error(doneLabel);
+  } else {
+    spinner.stop(doneLabel);
+  }
+
   for (const result of failures) {
-    const hint = result.failHint ? `\n    ${kleur.dim(`→ ${result.failHint}`)}` : '';
+    const hint = result.failHint ? `\n${kleur.dim(`→ ${result.failHint}`)}` : '';
     if (result.required) {
       const detail = result.autoInstallFailed ? ` — ${t('checks.install.failed')}` : '';
-      const diagSuffix = result.diagnosis ? `\n    ${kleur.dim(`→ ${t(`checks.diagnostic.${result.diagnosis}`, { name: result.name })}`)}` : '';
-      console.log(kleur.red(`  ✖ ${t('checks.missing', { name: result.name })}${detail}${diagSuffix}${hint}`));
+      const diagSuffix = result.diagnosis ? `\n${kleur.dim(`→ ${t(`checks.diagnostic.${result.diagnosis}`, { name: result.name })}`)}` : '';
+      ui.log.error(`${t('checks.missing', { name: result.name })}${detail}${diagSuffix}${hint}`);
     } else if (result.diagnosis) {
-      console.log(kleur.yellow(`  ⚠ ${t(`checks.diagnostic.${result.diagnosis}`, { name: result.name })}`));
+      ui.log.warn(t(`checks.diagnostic.${result.diagnosis}`, { name: result.name }));
     } else if (result.warnMessage) {
-      console.log(kleur.yellow(`  ⚠ ${result.warnMessage}${hint}`));
+      ui.log.warn(`${result.warnMessage}${hint}`);
     } else if (result.warnMessageKey) {
-      console.log(kleur.yellow(`  ⚠ ${t(result.warnMessageKey)}${hint}`));
+      ui.log.warn(`${t(result.warnMessageKey)}${hint}`);
     } else {
-      console.log(kleur.yellow(`  ⚠ ${t('checks.notFound', { name: result.name })}${hint}`));
+      ui.log.warn(`${t('checks.notFound', { name: result.name })}${hint}`);
     }
   }
 

package/lib/utils/prompts.js

@@ -1,4 +1,4 @@
-const prompts = require('prompts');
+const ui = require('./ui');
 const { isLicenseFormatValid } = require('./license');
 const {
   LANGUAGE_CHOICES,
@@ -15,11 +15,9 @@ const {
 
 const KASY_AUDIENCE = process.env.KASY_INTERNAL === '1' ? 'internal' : 'public';
 
-function getPromptOptions(t) {
-  return {
-    onCancel: () => {
-      throw new Error(t('prompt.cancelled'));
-    }
+function makeCancel(t) {
+  return () => {
+    throw new Error(t('prompt.cancelled'));
   };
 }
 
@@ -30,178 +28,120 @@ async function promptLanguage(language) {
   }
 
   const detectedLanguage = detectDefaultLanguage();
-  const initial = Math.max(
-    0,
-    LANGUAGE_CHOICES.findIndex((choice) => choice.value === detectedLanguage)
-  );
-
   const t = createTranslator(detectedLanguage);
-  const response = await prompts(
-    {
-      type: 'select',
-      name: 'language',
-      message: t('prompt.language.select'),
-      choices: LANGUAGE_CHOICES,
-      initial
-    },
-    getPromptOptions(t)
-  );
 
-  return normalizeLanguage(response.language) || detectedLanguage;
+  const value = await ui.select({
+    message: t('prompt.language.select'),
+    initialValue: detectedLanguage,
+    options: LANGUAGE_CHOICES.map((choice) => ({
+      value: choice.value,
+      label: choice.title,
+    })),
+    onCancel: makeCancel(t),
+  });
+
+  return normalizeLanguage(value) || detectedLanguage;
 }
 
 async function promptLicenseKey(initial = '', options = {}) {
   const t = options.t || createTranslator(options.language);
-  const response = await prompts(
-    {
-      type: 'text',
-      name: 'licenseKey',
-      message: t('prompt.license.enter'),
-      initial,
-      validate: (value) => {
-        if (isLicenseFormatValid(value)) {
-          return true;
-        }
-
-        return t('prompt.license.invalid');
-      }
-    },
-    getPromptOptions(t)
-  );
-
-  return response.licenseKey;
+  const value = await ui.text({
+    message: t('prompt.license.enter'),
+    initialValue: initial,
+    validate: (v) => (isLicenseFormatValid(v) ? undefined : t('prompt.license.invalid')),
+    onCancel: makeCancel(t),
+  });
+  return value;
 }
 
 async function promptProjectName(options = {}) {
   const t = options.t || createTranslator(options.language);
-  const response = await prompts(
-    {
-      type: 'text',
-      name: 'projectName',
-      message: t('prompt.projectName.enter'),
-      initial: t('prompt.projectName.default'),
-      validate: (value) => (value && value.trim() ? true : t('prompt.projectName.required'))
-    },
-    getPromptOptions(t)
-  );
-  return response.projectName.trim();
+  const value = await ui.text({
+    message: t('prompt.projectName.enter'),
+    initialValue: t('prompt.projectName.default'),
+    validate: (v) => (v && v.trim() ? undefined : t('prompt.projectName.required')),
+    onCancel: makeCancel(t),
+  });
+  return String(value).trim();
 }
 
 async function runSetupWizard(options = {}) {
   const t = options.t || createTranslator(options.language);
+  const cancel = makeCancel(t);
   const defaultAppName = options.defaultAppName || 'MyApp';
   const selectedFeaturesFromArgv = parseFeatureList(options.selectedFeatures);
 
-  const baseQuestions = [
-    {
-      type: 'text',
-      name: 'appName',
-      message: t('prompt.appName.enter'),
-      initial: defaultAppName,
-      validate: (value) => (value && value.trim() ? true : t('prompt.appName.required'))
+  const appName = await ui.text({
+    message: t('prompt.appName.enter'),
+    initialValue: defaultAppName,
+    validate: (v) => (v && v.trim() ? undefined : t('prompt.appName.required')),
+    onCancel: cancel,
+  });
+  const bundleId = await ui.text({
+    message: t('prompt.bundleId.enter'),
+    initialValue: 'com.example.app',
+    validate: (v) => {
+      if (!v || !v.trim()) return t('prompt.bundleId.required');
+      const valid = /^[a-zA-Z][\w]*(\.[a-zA-Z][\w]*)+$/.test(v.trim());
+      return valid ? undefined : t('prompt.bundleId.invalid');
     },
-    {
-      type: 'text',
-      name: 'bundleId',
-      message: t('prompt.bundleId.enter'),
-      initial: 'com.example.app',
-      validate: (value) => {
-        if (!value || !value.trim()) {
-          return t('prompt.bundleId.required');
-        }
-
-        const valid = /^[a-zA-Z][\w]*(\.[a-zA-Z][\w]*)+$/.test(value.trim());
-        return valid ? true : t('prompt.bundleId.invalid');
-      }
-    }
-  ];
+    onCancel: cancel,
+  });
+
+  const core = { appName, bundleId };
 
   const backendFromArgv = normalizeBackend(options.selectedBackend);
-  if (!backendFromArgv) {
-    baseQuestions.push({
-      type: 'select',
-      name: 'backend',
+  let backend = backendFromArgv;
+  if (!backend) {
+    backend = await ui.select({
       message: t('prompt.backend.select'),
-      choices: AVAILABLE_BACKENDS.map((backend) => ({
-        title: backend.id,
-        value: backend.id
-      })),
-      initial: 0
+      initialValue: AVAILABLE_BACKENDS[0]?.id,
+      options: AVAILABLE_BACKENDS.map((b) => ({ value: b.id, label: b.id })),
+      onCancel: cancel,
     });
   }
 
-  if (selectedFeaturesFromArgv.length === 0) {
-    baseQuestions.push({
-      type: 'multiselect',
-      name: 'features',
+  let features;
+  if (selectedFeaturesFromArgv.length > 0) {
+    features = selectedFeaturesFromArgv;
+  } else {
+    const selected = await ui.multiselect({
       message: t('prompt.features.select'),
-      instructions: t('prompt.features.instructions'),
-      choices: getVisibleFeatures({ audience: KASY_AUDIENCE }).map((feature) => ({
-        title: feature.status === 'internal' ? `${feature.id} [beta]` : feature.id,
+      options: getVisibleFeatures({ audience: KASY_AUDIENCE }).map((feature) => ({
         value: feature.id,
-        selected: false
+        label: feature.status === 'internal' ? `${feature.id} [beta]` : feature.id,
       })),
-      min: 0
+      initialValues: [],
+      required: false,
+      onCancel: cancel,
     });
+    features = parseFeatureList(selected);
   }
 
-  const core = await prompts(baseQuestions, getPromptOptions(t));
-  const backend = backendFromArgv || core.backend;
-  const features = selectedFeaturesFromArgv.length > 0
-    ? selectedFeaturesFromArgv
-    : parseFeatureList(core.features);
-
   if (backend === 'firebase') {
-    const firebaseAnswers = await prompts(
-      {
-        type: 'text',
-        name: 'firebaseProjectId',
-        message: t('prompt.firebase.projectId.enter'),
-        validate: (value) => (value && value.trim() ? true : t('prompt.firebase.projectId.required'))
-      },
-      getPromptOptions(t)
-    );
-
-    return {
-      ...core,
-      backend,
-      features,
-      ...firebaseAnswers
-    };
+    const firebaseProjectId = await ui.text({
+      message: t('prompt.firebase.projectId.enter'),
+      validate: (v) => (v && v.trim() ? undefined : t('prompt.firebase.projectId.required')),
+      onCancel: cancel,
+    });
+    return { ...core, backend, features, firebaseProjectId };
   }
 
   if (backend === 'supabase') {
-    const supabaseAnswers = await prompts(
-      [
-        {
-          type: 'text',
-          name: 'supabaseUrl',
-          message: t('prompt.supabase.url.enter'),
-          validate: (value) => (value && value.trim() ? true : t('prompt.supabase.url.required'))
-        },
-        {
-          type: 'text',
-          name: 'supabaseAnonKey',
-          message: t('prompt.supabase.anonKey.enter'),
-          validate: (value) => (value && value.trim() ? true : t('prompt.supabase.anonKey.required'))
-        }
-      ],
-      getPromptOptions(t)
-    );
-
-    return {
-      ...core,
-      backend,
-      features,
-      ...supabaseAnswers
-    };
+    const supabaseUrl = await ui.text({
+      message: t('prompt.supabase.url.enter'),
+      validate: (v) => (v && v.trim() ? undefined : t('prompt.supabase.url.required')),
+      onCancel: cancel,
+    });
+    const supabaseAnonKey = await ui.text({
+      message: t('prompt.supabase.anonKey.enter'),
+      validate: (v) => (v && v.trim() ? undefined : t('prompt.supabase.anonKey.required')),
+      onCancel: cancel,
+    });
+    return { ...core, backend, features, supabaseUrl, supabaseAnonKey };
   }
 
-  return {
-    ...core,
-    backend,
-    features
-  };
+  return { ...core, backend, features };
 }
 
 module.exports = {

package/lib/utils/ui.js

@@ -48,6 +48,21 @@ async function text({ message, placeholder, initialValue, defaultValue, validate
   return handleCancel(result, onCancel);
 }
 
+async function password({ message, mask, validate, onCancel }) {
+  const result = await clack.password({
+    message,
+    mask,
+    validate: validate
+      ? (value) => {
+          const out = validate(value);
+          if (out === true || out == null) return undefined;
+          return out;
+        }
+      : undefined,
+  });
+  return handleCancel(result, onCancel);
+}
+
 async function confirm({ message, initialValue = true, onCancel }) {
   const result = await clack.confirm({ message, initialValue });
   return handleCancel(result, onCancel);
@@ -63,13 +78,87 @@ function outro(message) { clack.outro(message); }
 function note(message, title) { clack.note(message, title); }
 function cancel(message) { clack.cancel(message); }
 
+/**
+ * Spinner integrated with Clack's vertical line (│).
+ * Returns: { start(msg), message(msg), stop(msg, code?) }
+ * code: 0 = success (✦), 1 = cancel (■), 2 = error (▲)
+ */
 function spinner() { return clack.spinner(); }
 
+/**
+ * Multi-step spinner: each .next(text) succeeds the previous step
+ * with the previous message, then starts a new step with `text`.
+ * Mimics the old ora-based makeProgressSpinner() but uses Clack's
+ * vertical-line aesthetic so the line stays connected.
+ */
+function makeStepper() {
+  let current = null;
+  let currentMsg = '';
+  return {
+    next(text) {
+      if (current) current.stop(currentMsg);
+      current = clack.spinner();
+      currentMsg = text;
+      current.start(text);
+    },
+    update(text) {
+      if (current) {
+        currentMsg = text;
+        current.message(text);
+      }
+    },
+    succeed(text) {
+      if (current) {
+        current.stop(text || currentMsg);
+        current = null;
+        currentMsg = '';
+      }
+    },
+    fail(text) {
+      if (current) {
+        // .error() renders the red ▲ icon; .stop() defaults to green ✦ success.
+        current.error(text || currentMsg);
+        current = null;
+        currentMsg = '';
+      }
+    },
+    warn(text) {
+      // Clack has no "warn" terminal state — prefix with ⚠ and close as success.
+      if (current) {
+        current.stop(`⚠ ${text || currentMsg}`);
+        current = null;
+        currentMsg = '';
+      }
+    },
+    stop() {
+      if (current) {
+        current.stop(currentMsg);
+        current = null;
+        currentMsg = '';
+      }
+    },
+  };
+}
+
+/**
+ * Long-running task with rolling log output (e.g. pub get, build_runner).
+ * Shows last N lines while running; collapses to a single ✦ on success.
+ * Options: { title, limit, retainLog }
+ */
+function taskLog(options) { return clack.taskLog(options); }
+
+/**
+ * Progress bar for operations with known total steps.
+ * Returns: { start(msg), advance(n, msg?), message(msg), stop(msg) }
+ */
+function progress(options) { return clack.progress(options); }
+
 const log = clack.log;
 
 module.exports = {
   select,
   text,
+  password,
   confirm,
   multiselect,
   intro,
@@ -77,6 +166,9 @@ module.exports = {
   note,
   cancel,
   spinner,
+  makeStepper,
+  taskLog,
+  progress,
   log,
   isCancel: clack.isCancel,
 };

package/lib/utils/updates.js

@@ -4,8 +4,8 @@ const https = require('node:https');
 const path = require('node:path');
 const { existsSync, readJsonSync, writeJsonSync, ensureDirSync } = require('fs-extra');
 const kleur = require('kleur');
-const prompts = require('prompts');
 const pkg = require('../../package.json');
+const ui = require('./ui');
 const { CONFIG_PATH } = require('./license');
 
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 horas
@@ -106,19 +106,20 @@ async function warnIfOutdatedBeforeNew(t) {
     if (!cache.latestVersion || !isNewer(cache.latestVersion, pkg.version)) return;
 
     const hint = t ? t('new.outdated.hint') : 'projetos criados agora não terão as últimas melhorias.';
-    console.log('');
     console.log(
+      '\n' +
       kleur.bgYellow().black(' UPDATE ') + '  ' +
       kleur.bold(`v${cache.latestVersion} disponível`) +
-      kleur.dim(`  — ${hint}`)
+      kleur.dim(`  — ${hint}`) +
+      '\n'
     );
-    console.log('');
 
-    const { upgrade } = await prompts({
-      type: 'confirm',
-      name: 'upgrade',
+    // Called BEFORE any ui.intro fires in kasy new, so this prompt runs as a
+    // standalone Clack confirm (no rail to break). On cancel we exit cleanly.
+    const upgrade = await ui.confirm({
       message: t ? t('new.outdated.upgradeNow') : 'Atualizar antes de criar? (requer assinatura ativa)',
-      initial: false,
+      initialValue: false,
+      onCancel: () => process.exit(0),
     });
 
     if (upgrade) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kasy-cli",
-  "version": "1.5.3",
+  "version": "1.6.0",
   "description": "CLI for scaffolding production-ready Flutter SaaS apps with Firebase, Supabase, or API REST backends.",
   "bin": {
     "kasy": "./bin/kasy.js"
@@ -45,6 +45,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.4.0",
+    "boxen": "^8.0.1",
     "commander": "^12.0.0",
     "fs-extra": "^11.2.0",
     "gradient-string": "^1.2.0",