kasy-cli 1.2.1

package/lib/utils/license-gate.js

@@ -0,0 +1,72 @@
+const kleur = require('kleur');
+const { getStoredLicenseKey, isLicenseFormatValid, setStoredLicenseKey } = require('./license');
+const { promptLicenseKey } = require('./prompts');
+const { createTranslator, detectDefaultLanguage } = require('./i18n');
+
+function resolveCommandFromArgv(argv = []) {
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+
+    if (!arg) continue;
+
+    // Skip global options that take a value.
+    if (arg === '--lang' || arg === '-l') {
+      i += 1;
+      continue;
+    }
+
+    // Skip long flags with inline value and regular flags.
+    if (arg.startsWith('--') || (arg.startsWith('-') && arg.length > 1)) {
+      continue;
+    }
+
+    return arg;
+  }
+
+  return null;
+}
+
+function shouldRequireLicenseForArgv(_argv = []) {
+  // License validation is disabled in this public release.
+  // A future version will validate against a real server before enabling this.
+  return false;
+}
+
+async function ensureLicenseKey(options = {}) {
+  const language = options.language || detectDefaultLanguage();
+  const t = createTranslator(language);
+
+  const stored = getStoredLicenseKey();
+  if (stored && isLicenseFormatValid(stored)) {
+    console.log(kleur.cyan(t('license.checking')));
+    await new Promise((r) => setTimeout(r, 600));
+    console.log(kleur.green(t('license.saved')));
+    console.log('');
+    return stored;
+  }
+
+  console.log('');
+  console.log(kleur.yellow(t('license.required')));
+  console.log('');
+
+  const entered = await promptLicenseKey(stored || '', { t });
+  const normalized = entered.trim().toUpperCase();
+
+  console.log(kleur.cyan(t('license.checking')));
+  await new Promise((r) => setTimeout(r, 600));
+
+  if (!isLicenseFormatValid(normalized)) {
+    throw new Error(t('license.invalid'));
+  }
+
+  setStoredLicenseKey(normalized);
+  console.log(kleur.green(t('license.saved')));
+  console.log('');
+
+  return normalized;
+}
+
+module.exports = {
+  ensureLicenseKey,
+  shouldRequireLicenseForArgv
+};

package/lib/utils/license.js

@@ -0,0 +1,64 @@
+const path = require('node:path');
+const os = require('node:os');
+const { ensureDirSync, existsSync, readJsonSync, writeJsonSync } = require('fs-extra');
+
+const LICENSE_PATTERN = /^[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/;
+const CONFIG_DIR = path.join(os.homedir(), '.kasy');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+
+function isLicenseFormatValid(licenseKey) {
+  return LICENSE_PATTERN.test((licenseKey || '').trim().toUpperCase());
+}
+
+function readLocalConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    return {};
+  }
+
+  try {
+    return readJsonSync(CONFIG_PATH);
+  } catch {
+    return {};
+  }
+}
+
+function writeLocalConfig(config) {
+  ensureDirSync(CONFIG_DIR);
+  writeJsonSync(CONFIG_PATH, config, { spaces: 2 });
+}
+
+function getStoredLicenseKey() {
+  const config = readLocalConfig();
+  return config.licenseKey || '';
+}
+
+function setStoredLicenseKey(licenseKey) {
+  const config = readLocalConfig();
+  writeLocalConfig({
+    ...config,
+    licenseKey
+  });
+}
+
+function getStoredLanguage() {
+  const config = readLocalConfig();
+  const lang = config.language || '';
+  return /^(en|pt|es)$/i.test(lang) ? lang.toLowerCase() : '';
+}
+
+function setStoredLanguage(language) {
+  const config = readLocalConfig();
+  writeLocalConfig({
+    ...config,
+    language: String(language).toLowerCase()
+  });
+}
+
+module.exports = {
+  CONFIG_PATH,
+  isLicenseFormatValid,
+  getStoredLicenseKey,
+  setStoredLicenseKey,
+  getStoredLanguage,
+  setStoredLanguage,
+};

package/lib/utils/prompts.js

@@ -0,0 +1,213 @@
+const prompts = require('prompts');
+const { isLicenseFormatValid } = require('./license');
+const {
+  LANGUAGE_CHOICES,
+  createTranslator,
+  detectDefaultLanguage,
+  normalizeLanguage
+} = require('./i18n');
+const {
+  AVAILABLE_BACKENDS,
+  getVisibleFeatures,
+  normalizeBackend,
+  parseFeatureList
+} = require('../scaffold/catalog');
+
+const KASY_AUDIENCE = process.env.KASY_INTERNAL === '1' ? 'internal' : 'public';
+
+function getPromptOptions(t) {
+  return {
+    onCancel: () => {
+      throw new Error(t('prompt.cancelled'));
+    }
+  };
+}
+
+async function promptLanguage(language) {
+  const preferredLanguage = normalizeLanguage(language);
+  if (preferredLanguage) {
+    return preferredLanguage;
+  }
+
+  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;
+}
+
+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;
+}
+
+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();
+}
+
+async function runSetupWizard(options = {}) {
+  const t = options.t || createTranslator(options.language);
+  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'))
+    },
+    {
+      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');
+      }
+    }
+  ];
+
+  const backendFromArgv = normalizeBackend(options.selectedBackend);
+  if (!backendFromArgv) {
+    baseQuestions.push({
+      type: 'select',
+      name: 'backend',
+      message: t('prompt.backend.select'),
+      choices: AVAILABLE_BACKENDS.map((backend) => ({
+        title: backend.id,
+        value: backend.id
+      })),
+      initial: 0
+    });
+  }
+
+  if (selectedFeaturesFromArgv.length === 0) {
+    baseQuestions.push({
+      type: 'multiselect',
+      name: 'features',
+      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,
+        value: feature.id,
+        selected: false
+      })),
+      min: 0
+    });
+  }
+
+  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
+    };
+  }
+
+  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
+    };
+  }
+
+  return {
+    ...core,
+    backend,
+    features
+  };
+}
+
+module.exports = {
+  createTranslator,
+  promptLicenseKey,
+  promptLanguage,
+  promptProjectName,
+  runSetupWizard
+};

package/lib/utils/updates.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const https = require('node:https');
+const path = require('node:path');
+const { existsSync, readJsonSync, writeJsonSync, ensureDirSync } = require('fs-extra');
+const kleur = require('kleur');
+const pkg = require('../../package.json');
+const { CONFIG_PATH } = require('./license');
+
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 horas
+
+// ── Helpers de config ────────────────────────────────────────────────────────
+
+function readConfig() {
+  if (!existsSync(CONFIG_PATH)) return {};
+  try { return readJsonSync(CONFIG_PATH); } catch { return {}; }
+}
+
+function writeConfig(config) {
+  ensureDirSync(path.dirname(CONFIG_PATH));
+  writeJsonSync(CONFIG_PATH, config, { spaces: 2 });
+}
+
+// ── Comparação semver mínima (sem deps externas) ─────────────────────────────
+
+function isNewer(remote, local) {
+  const parse = (v) => String(v).replace(/^v/, '').split('.').map(Number);
+  const [rMaj, rMin, rPat] = parse(remote);
+  const [lMaj, lMin, lPat] = parse(local);
+  if (rMaj !== lMaj) return rMaj > lMaj;
+  if (rMin !== lMin) return rMin > lMin;
+  return rPat > lPat;
+}
+
+// ── Fetch assíncrono (dispara em background) ─────────────────────────────────
+
+function fetchLatestVersion() {
+  return new Promise((resolve) => {
+    const req = https.get(
+      'https://registry.npmjs.org/kasy-cli/latest',
+      { timeout: 3000 },
+      (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try { resolve(JSON.parse(data).version ?? null); }
+          catch { resolve(null); }
+        });
+      }
+    );
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
+
+// ── Função principal ─────────────────────────────────────────────────────────
+
+/**
+ * Mostra aviso de atualização (baseado no cache da última verificação — zero latência).
+ * Dispara refresh do cache em background se já passaram 24h.
+ * Nunca lança erro — falha silenciosa em qualquer cenário.
+ */
+async function checkForUpdates() {
+  try {
+    const config = readConfig();
+    const cache = config.updateCheck || {};
+
+    // Exibe aviso baseado no cache — não espera rede
+    if (cache.latestVersion && isNewer(cache.latestVersion, pkg.version)) {
+      console.log(
+        '\n' +
+        kleur.bgYellow().black(' UPDATE ') + '  ' +
+        kleur.bold(`v${cache.latestVersion} disponível`) +
+        kleur.dim(`  (você tem v${pkg.version})`) +
+        '\n' +
+        kleur.dim('         ') + kleur.cyan('npm install -g kasy-cli') +
+        '\n'
+      );
+    }
+
+    // Atualiza cache em background a cada 24h — não bloqueia o CLI
+    const now = Date.now();
+    if (!cache.checkedAt || now - cache.checkedAt > CHECK_INTERVAL_MS) {
+      fetchLatestVersion()
+        .then((version) => {
+          if (!version) return;
+          const fresh = readConfig();
+          writeConfig({ ...fresh, updateCheck: { latestVersion: version, checkedAt: now } });
+        })
+        .catch(() => {});
+    }
+  } catch {
+    // Nunca travar o CLI por causa de verificação de update
+  }
+}
+
+module.exports = { checkForUpdates };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "kasy-cli",
+  "version": "1.2.1",
+  "description": "CLI for scaffolding production-ready Flutter SaaS apps with Firebase, Supabase, or API REST backends.",
+  "bin": {
+    "kasy": "./bin/kasy.js"
+  },
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "docs/",
+    "README.md"
+  ],
+  "keywords": [
+    "flutter",
+    "saas",
+    "cli",
+    "scaffold",
+    "firebase",
+    "supabase",
+    "dart",
+    "boilerplate",
+    "starter"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepack": "node scripts/bundle-template.js",
+    "start": "node ./bin/kasy.js",
+    "setup": "node ./bin/kasy.js setup",
+    "doctor": "node ./bin/kasy.js doctor",
+    "features": "node ./bin/kasy.js features",
+    "validate": "node ./bin/kasy.js validate --analyze-only",
+    "extract:patch": "node ./scripts/extract_patch.js",
+    "check:firebase": "node ./scripts/check-firebase-template.js",
+    "test:google-ios": "node ./test/google-ios-url-scheme.test.js",
+    "test:apple-release": "node ./test/apple-release.test.js",
+    "test:localize-docs": "node ./test/localize-release-docs.test.js"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "fs-extra": "^11.2.0",
+    "gradient-string": "^1.2.0",
+    "kleur": "^4.1.5",
+    "ora": "^8.0.1",
+    "prompts": "^2.4.2",
+    "yaml": "^2.4.2"
+  }
+}

package/templates/firebase/.env.example

@@ -0,0 +1,24 @@
+# Copie para .env no desenvolvimento local (gitignored).
+# O app lê .env em runtime (AppEnv); --dart-define e .dart_defines são fallback.
+
+ENV=dev
+
+# Firebase Cloud Functions (região + project id do seu projeto)
+BACKEND_URL=https://europe-west1-YOUR_PROJECT_ID.cloudfunctions.net
+
+# LLM Chat — proxy Cloud Function (LLM_API_KEY fica no Firebase Secret)
+LLM_CHAT_ENDPOINT=https://europe-west1-YOUR_PROJECT_ID.cloudfunctions.net/llmChat
+
+# RevenueCat
+RC_ANDROID_API_KEY=YOUR_REVENUECAT_ANDROID_KEY
+RC_IOS_API_KEY=YOUR_REVENUECAT_IOS_KEY
+RC_WEB_API_KEY=YOUR_REVENUECAT_WEB_KEY
+
+# App Store Connect — in-app review / link da loja
+APP_STORE_ID=YOUR_APP_STORE_ID
+
+# Sentry (apenas prod)
+SENTRY_DSN=YOUR_SENTRY_DSN
+
+# Mixpanel
+MIXPANEL_TOKEN=YOUR_MIXPANEL_TOKEN

package/templates/firebase/.firebaserc

@@ -0,0 +1,5 @@
+{
+  "projects": {
+    "default": "fir-kit-8e56b"
+  }
+}

package/templates/firebase/.kasy/apple.env.example

@@ -0,0 +1,8 @@
+# App Store Connect API — copy to apple.env and fill in (never commit apple.env)
+# Run: kasy ios configure
+
+APP_STORE_API_KEY=
+APP_STORE_ISSUER_ID=
+
+# Optional: numeric App Store Connect app ID (for reference / future sync)
+# APP_STORE_APP_ID=

package/templates/firebase/.kasy/codemagic.env.example

@@ -0,0 +1,7 @@
+# Codemagic API — copy to codemagic.env and fill in (never commit codemagic.env)
+# Run: kasy codemagic configure
+
+CODEMAGIC_API_TOKEN=
+CODEMAGIC_APP_ID=
+CODEMAGIC_WORKFLOW_ID=ios-workflow
+CODEMAGIC_BRANCH=main

package/templates/firebase/.metadata

@@ -0,0 +1,30 @@
+# This file tracks properties of this Flutter project.
+# Used by Flutter tool to assess capabilities and perform upgrades etc.
+#
+# This file should be version controlled and should not be manually edited.
+
+version:
+  revision: "3b62efc2a3da49882f43c372e0bc53daef7295a6"
+  channel: "stable"
+
+project_type: app
+
+# Tracks metadata for the flutter migrate command
+migration:
+  platforms:
+    - platform: root
+      create_revision: 3b62efc2a3da49882f43c372e0bc53daef7295a6
+      base_revision: 3b62efc2a3da49882f43c372e0bc53daef7295a6
+    - platform: web
+      create_revision: 3b62efc2a3da49882f43c372e0bc53daef7295a6
+      base_revision: 3b62efc2a3da49882f43c372e0bc53daef7295a6
+
+  # User provided section
+
+  # List of Local paths (relative to this file) that should be
+  # ignored by the migrate tool.
+  #
+  # Files that are not part of the templates will be ignored by default.
+  unmanaged_files:
+    - 'lib/main.dart'
+    - 'ios/Runner.xcodeproj/project.pbxproj'

package/templates/firebase/.windsurfrules

@@ -0,0 +1,95 @@
+# Kasy — Flutter Guidelines
+
+## Project description
+
+[Describe your project here and remove this line.]
+
+## Expected workflow
+- Review feature requirements
+- Plan implementation
+- Update schema if needed
+- Implement core functionality
+- Ensure new features don't break existing ones
+
+## Dart General Guidelines
+
+### Basic Principles
+- Use English for all code and documentation
+- Always declare the type of each variable and function (parameters and return value)
+- Name variables to reflect how they are used
+- Avoid using type `dynamic`
+- Create necessary types
+- Don't leave blank lines within a function
+- One export per file
+- Prefer super constructor
+
+### Nomenclature
+- Use PascalCase for classes
+- Use camelCase for variables, functions, and methods
+- Use underscores_case for file and directory names
+- Avoid magic numbers — define constants
+- Start each function with a verb
+- Use verbs for boolean variables: isLoading, hasError, canDelete
+- Use complete words instead of abbreviations (except: API, URL, i, j, err, ctx)
+- Prefer noun for class names, verb for methods
+
+### Imports
+- Always use package imports: `import 'package:kasy_kit/core/data/entities/upload_result.dart';`
+- Package name is `kasy_kit`
+- Never use relative imports for files in `lib/`
+
+## Architecture (3 layers)
+
+### Folder structure
+
+```
+lib
+├── core
+│   ├── bottom_menu
+│   ├── data
+│   │   ├── api
+│   │   ├── entities
+│   │   └── models
+│   ├── guards
+│   ├── initializer
+│   ├── security
+│   ├── shared_preferences
+│   ├── states
+│   └── widgets
+└── modules
+    └── module_name
+        ├── api
+        │   └── entities
+        ├── domain
+        ├── providers
+        │   └── models
+        ├── repositories
+        └── ui
+            ├── component
+            └── widgets
+```
+
+### Layer 1 — Data (API)
+- Fetches data from Firebase, Supabase, or REST API
+- Returns entities (not domain models)
+- Not covered by unit tests
+- Only repositories can use API classes
+
+### Layer 2 — Domain
+- Repositories transform entities into domain models
+- Business logic lives here
+- Use `@freezed` for immutability and union types
+- Prefer typed value objects (e.g., `Email` instead of `String`)
+
+### Layer 3 — Presentation
+- Pages listen to Riverpod notifiers via `ref.watch`
+- Notifier state uses `@freezed`
+- Views only trigger actions — no business logic in widgets
+
+## Unit Tests
+
+- Use fakes, not mocks: implement the API class as an interface
+- Tests describe: `[CONTEXT], [ACTION] => [EXPECTED RESULT]`
+- Use `pumpPage` from `test/test_utils.dart` to inject fakes
+- Test from the user's point of view (tap a button, not call a function directly)
+- Fakes go in `test/test_utils.dart` via provider overrides