kasy-cli 1.21.1 → 1.21.3

package/bin/kasy.js

@@ -436,9 +436,26 @@ function buildProgram(language) {
       .description(t('cli.command.upgrade.description'))
       .action(() => {
         const { spawnSync } = require('node:child_process');
+        const path = require('node:path');
         printCompactHeader(t);
         console.log(kleur.cyan(t('cli.command.upgrade.running')) + '\n');
-        const result = spawnSync('npm', ['install', '-g', 'kasy-cli'], { stdio: 'inherit', shell: true });
+        // Update INTO the prefix the CLI actually lives in. The installer uses
+        // `npm install -g --prefix ~/.kasy`, so a bare `npm install -g` would
+        // land in npm's default global prefix and the old copy on PATH would
+        // keep winning. Derive the prefix from this file's own location:
+        //   unix: <prefix>/lib/node_modules/kasy-cli/bin  → drop lib + node_modules
+        //   win:  <prefix>/node_modules/kasy-cli/bin       → drop node_modules
+        const segs = __dirname.split(path.sep);
+        const nm = segs.lastIndexOf('node_modules');
+        let prefix = null;
+        if (nm > 0) {
+          let p = segs.slice(0, nm);
+          if (p[p.length - 1] === 'lib') p = p.slice(0, -1);
+          prefix = p.join(path.sep) || null;
+        }
+        const args = ['install', '-g', 'kasy-cli@latest'];
+        if (prefix) args.push('--prefix', prefix);
+        const result = spawnSync('npm', args, { stdio: 'inherit', shell: true });
         if (result.status === 0) {
           console.log('\n' + kleur.green('✓ ' + t('cli.command.upgrade.done')) + '\n');
         } else {

package/lib/commands/doctor.js

@@ -6,9 +6,10 @@ const { createTranslator, detectDefaultLanguage } = require('../utils/i18n');
 const {
   getBaseChecks,
   getPlatformChecks,
-  getBackendChecks,
   runChecks,
-  hasRequiredFailures
+  hasRequiredFailures,
+  probeTools,
+  BACKEND_TOOLS,
 } = require('../utils/checks');
 const {
   validateAppleSetup,
@@ -21,11 +22,35 @@ const { validateGoogleIosUrlScheme, validateAppleSignInEntitlement, validateFace
 const { listBillingAccounts, checkGcloudAuth } = require('../scaffold/backends/firebase/setup-from-scratch');
 const { printCompactHeader } = require('../utils/brand');
 
-function collectOptionalBackendChecks() {
-  return [
-    ...getBackendChecks('firebase'),
-    ...getBackendChecks('supabase')
-  ];
+/**
+ * Read-only backend tools status + a per-backend "what you need" view, so
+ * `kasy doctor` answers "what do I have, what's missing, and for which backend".
+ */
+async function printBackendReadiness(t) {
+  const status = await probeTools();
+
+  ui.log.step(kleur.bold(t('doctor.tools.title')));
+  for (const key of ['firebase', 'flutterfire', 'supabase', 'gcloud']) {
+    const s = status[key];
+    if (s.ok) {
+      ui.log.success(`${s.name}${s.version ? ` — ${s.version}` : ''}`);
+    } else if (key === 'gcloud') {
+      ui.log.message(kleur.dim(`○ ${s.name} — ${t('doctor.gcloud.note')}`));
+    } else {
+      ui.log.warn(`${s.name} — ${t('checks.notFound.short')}`);
+    }
+  }
+
+  ui.log.step(kleur.bold(t('doctor.byBackend.title')));
+  const labels = { firebase: '🔥 Firebase', supabase: '🟢 Supabase', api: '🔗 API REST' };
+  for (const [backend, req] of Object.entries(BACKEND_TOOLS)) {
+    const missing = req.required.filter((k) => !status[k].ok).map((k) => status[k].name);
+    if (missing.length === 0) {
+      ui.log.success(`${labels[backend]} — ${t('doctor.backend.ready')}`);
+    } else {
+      ui.log.warn(`${labels[backend]} — ${t('doctor.backend.missing', { tools: missing.join(', ') })}`);
+    }
+  }
 }
 
 /**
@@ -242,12 +267,7 @@ async function runDoctor(options = {}) {
     { t, compact: true, spinnerLabel: t('doctor.baseEnvironment'), doneLabel: t('doctor.baseEnvironment') }
   );
 
-  const optionalBackend = collectOptionalBackendChecks();
-  if (optionalBackend.length > 0) {
-    await runChecks(optionalBackend, t('doctor.optionalBackend'), {
-      t, compact: true, spinnerLabel: t('doctor.optionalBackend'), doneLabel: t('doctor.optionalBackend'),
-    });
-  }
+  await printBackendReadiness(t);
 
   // ── Google Cloud billing account (Firebase Blaze) ─────────────────────
   // Only meaningful when gcloud is authenticated; otherwise users already saw

package/lib/utils/checks.js

@@ -92,7 +92,16 @@ const PLATFORM_CHECKS = {
   linux: []
 };
 
-/** Firebase CLI + FlutterFire — required for push notifications (FCM) on all backends */
+/**
+ * Firebase CLI + FlutterFire — required for push notifications (FCM) on EVERY
+ * backend (Firebase, Supabase, API), since FCM is the shared push layer.
+ *
+ * gcloud is deliberately NOT in this list. It's only needed to create a Firebase
+ * project FROM SCRATCH (an opt-in path), so checking it for every backend made
+ * the Supabase/API setup offer to install gcloud for no reason — and the user
+ * doesn't even need it there. The create-from-scratch flow verifies gcloud on
+ * its own (checkGcloudAuth in new.js), exactly when it's actually required.
+ */
 const FIREBASE_CHECKS = [
   {
     name: 'Firebase CLI',
@@ -113,22 +122,6 @@ const FIREBASE_CHECKS = [
     pubGlobalBin: 'flutterfire',
     tryInstallMessageKey: 'setup.flutterfire.installing',
   },
-  {
-    name: 'gcloud CLI (create-from-scratch)',
-    command: 'gcloud --version',
-    required: false,
-    installGuide: () => getInstallGuide('gcloud'),
-    confirmInstall: true,
-    waitPromptKey: 'checks.waitPrompt.gcloud.install',
-  },
-  {
-    name: 'gcloud auth (create-from-scratch)',
-    command: 'gcloud auth print-access-token',
-    required: false,
-    showVersion: false,
-    failHint: 'gcloud auth login',
-    waitPromptKey: 'checks.waitPrompt.gcloud.auth',
-  },
 ];
 
 const BACKEND_CHECKS = {
@@ -413,6 +406,39 @@ function hasRequiredFailures(results) {
   return results.some((result) => result.required && !result.ok);
 }
 
+// Backend tools probed by `kasy doctor`, plus which backend needs which. gcloud
+// is listed only as Firebase-optional (create-from-scratch), matching the rule
+// that Supabase/API never need it. Keep in sync with BACKEND_CHECKS above.
+const PROBE_TOOLS = [
+  { key: 'firebase', name: 'Firebase CLI', command: 'firebase --version' },
+  { key: 'flutterfire', name: 'FlutterFire CLI', command: 'flutterfire --version', pubGlobalBin: 'flutterfire' },
+  { key: 'supabase', name: 'Supabase CLI', command: 'supabase --version' },
+  { key: 'gcloud', name: 'gcloud', command: 'gcloud --version' },
+];
+
+const BACKEND_TOOLS = {
+  firebase: { required: ['firebase', 'flutterfire'], optional: ['gcloud'] },
+  supabase: { required: ['firebase', 'flutterfire', 'supabase'], optional: [] },
+  api: { required: ['firebase', 'flutterfire'], optional: [] },
+};
+
+/**
+ * Read-only probe of the backend tools (never installs anything) — for the
+ * doctor's "what do I have / what's missing" view. Runs in parallel.
+ * @returns {Promise<Object<string, {name, ok, version}>>}
+ */
+async function probeTools(tools = PROBE_TOOLS) {
+  const entries = await Promise.all(tools.map(async (tool) => {
+    const res = await verifyTool(tool);
+    return [tool.key, {
+      name: tool.name,
+      ok: res.ok,
+      version: res.ok ? extractVersion(res.stdout, tool.name) : null,
+    }];
+  }));
+  return Object.fromEntries(entries);
+}
+
 module.exports = {
   getBaseChecks,
   getPlatformChecks,
@@ -420,4 +446,6 @@ module.exports = {
   getInstallGuide,
   runChecks,
   hasRequiredFailures,
+  probeTools,
+  BACKEND_TOOLS,
 };

package/lib/utils/i18n/messages-en.js

@@ -80,6 +80,11 @@ module.exports = {
     'doctor.title': 'Kasy Doctor',
     'doctor.baseEnvironment': 'Base environment',
     'doctor.optionalBackend': 'Optional backend tooling',
+    'doctor.tools.title': 'Backend tools',
+    'doctor.byBackend.title': 'What each backend needs',
+    'doctor.backend.ready': 'all set',
+    'doctor.backend.missing': 'still missing: {tools}',
+    'doctor.gcloud.note': 'optional, only to create a Firebase project from scratch',
     'doctor.gcpBilling.title': 'Google Cloud Billing (Firebase Blaze)',
     'doctor.gcpBilling.found': '{count} active billing account(s):',
     'doctor.gcpBilling.missing': 'No billing account found. Create one before running `kasy new` with Firebase:',

package/lib/utils/i18n/messages-es.js

@@ -80,6 +80,11 @@ module.exports = {
     'doctor.title': 'Kasy Doctor',
     'doctor.baseEnvironment': 'Entorno base',
     'doctor.optionalBackend': 'Herramientas opcionales de backend',
+    'doctor.tools.title': 'Herramientas de backend',
+    'doctor.byBackend.title': 'Qué necesita cada backend',
+    'doctor.backend.ready': 'todo listo',
+    'doctor.backend.missing': 'falta instalar: {tools}',
+    'doctor.gcloud.note': 'opcional, solo para crear un proyecto Firebase desde cero',
     'doctor.gcpBilling.title': 'Google Cloud Billing (Firebase Blaze)',
     'doctor.gcpBilling.found': '{count} cuenta(s) de facturación activa(s):',
     'doctor.gcpBilling.missing': 'No se encontró ninguna cuenta de facturación. Crea una antes de ejecutar `kasy new` con Firebase:',

package/lib/utils/i18n/messages-pt.js

@@ -80,6 +80,11 @@ module.exports = {
     'doctor.title': 'Kasy Doctor',
     'doctor.baseEnvironment': 'Ambiente base',
     'doctor.optionalBackend': 'Ferramentas opcionais de backend',
+    'doctor.tools.title': 'Ferramentas de backend',
+    'doctor.byBackend.title': 'O que cada backend precisa',
+    'doctor.backend.ready': 'tudo pronto',
+    'doctor.backend.missing': 'falta instalar: {tools}',
+    'doctor.gcloud.note': 'opcional, só para criar um projeto Firebase do zero',
     'doctor.gcpBilling.title': 'Google Cloud Billing (Firebase Blaze)',
     'doctor.gcpBilling.found': '{count} conta(s) de faturamento ativa(s):',
     'doctor.gcpBilling.missing': 'Nenhuma conta de faturamento encontrada. Crie uma antes de rodar `kasy new` com Firebase:',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kasy-cli",
-  "version": "1.21.1",
+  "version": "1.21.3",
   "description": "CLI for scaffolding production-ready Flutter SaaS apps with Firebase, Supabase, or API REST backends.",
   "bin": {
     "kasy": "./bin/kasy.js"