@launchframe/cli 1.0.0-beta.9 → 1.0.1

package/src/services/module-config.js

@@ -0,0 +1,25 @@
+// Module configuration - defines files, sections, and dependencies for each module
+const MODULE_CONFIG = {
+  blog: {
+    website: {
+      files: [
+        'src/lib/blog.ts',
+        'src/types/blog.ts',
+        'src/app/blog',
+        'src/components/blog',
+        'src/app/sitemap.ts',
+        'content/blog',
+      ],
+      sections: {
+        'src/components/layout/Navbar.tsx': ['BLOG_NAV_LINK'],
+        'src/components/layout/Footer.tsx': ['BLOG_FOOTER_LINK'],
+      },
+      dependencies: {
+        'gray-matter': '^4.0.3',
+        'marked': '^12.0.0',
+      },
+    },
+  },
+};
+
+module.exports = { MODULE_CONFIG };

package/src/services/module-registry.js

@@ -0,0 +1,12 @@
+// Module registry - available modules for LaunchFrame services
+const MODULE_REGISTRY = {
+  blog: {
+    name: 'blog',
+    displayName: 'Blog',
+    description: 'Markdown-based blog using local .md files with YAML front-matter — no database required',
+    services: ['website'],
+    version: '1.0.0'
+  }
+};
+
+module.exports = { MODULE_REGISTRY };

package/src/services/variant-config.js

@@ -21,24 +21,16 @@ const VARIANT_CONFIG = {
         // Complete files/folders to copy
         files: [
           'src/modules/domain/projects',           // Entire projects module
-          'src/modules/domain/ai/services/project-config.service.ts', // Project config service
           'src/guards/project-ownership.guard.ts', // Project ownership guard (header-based)
           'src/guards/project-param.guard.ts',     // Project param guard (route-based)
-          'src/modules/auth/auth.service.ts',      // Auth service with multi-tenant support
-          'src/modules/auth/auth.controller.ts',   // Auth controller with multi-tenant support
           'src/modules/users/users.service.ts',    // Users service with multi-tenant support
           'src/modules/users/users.controller.ts', // Users controller with multi-tenant support
           'src/modules/users/create-user.dto.ts'   // CreateUserDto with businessId
         ],
 
         // Code sections to insert into base template files
+        // Note: main.ts uses PRIMARY_DOMAIN env var for dynamic CORS - no sections needed
         sections: {
-          'src/main.ts': [
-            'PROJECT_IMPORTS',              // Add project-related imports
-            'PROJECT_CUSTOM_DOMAINS',       // Add custom domains query
-            'PROJECT_CUSTOM_DOMAINS_CORS',  // Add custom domains to CORS
-            'PROJECT_GUARD'                 // Add ProjectOwnershipGuard registration
-          ],
           'src/modules/app/app.module.ts': [
             'PROJECTS_MODULE_IMPORT',       // Add ProjectsModule import
             'PROJECTS_MODULE'               // Add ProjectsModule to imports array
@@ -60,11 +52,15 @@ const VARIANT_CONFIG = {
         }
       },
 
-      // B2B2C variant: Adds regular_user support (for single-tenant only)
+      // B2B2C variant: Adds regular_user support with separate customer auth
       'b2b2c': {
         // Complete files to copy
         files: [
-          'src/modules/users/user-business.entity.ts',  // Business-to-user linking entity
+          'src/modules/users/user-business.entity.ts',           // Business-to-user linking entity
+          'src/modules/auth/auth-customer.ts',                   // Customer auth config (regular_user, customer_ cookie)
+          'src/modules/auth/better-auth-customer.controller.ts', // Customer auth controller (/api/auth/customer)
+          'src/modules/auth/auth.module.ts',                     // Auth module with customer controller
+          'src/modules/auth/better-auth.guard.ts',               // Guard handling both auth instances
         ],
 
         // Code sections to insert
@@ -77,6 +73,9 @@ const VARIANT_CONFIG = {
           'src/modules/users/users.module.ts': [
             'B2B2C_IMPORTS',           // Add UserBusiness import
             'B2B2C_ENTITIES'           // Add UserBusiness to TypeORM
+          ],
+          'src/database/migrations/1764300000001-CreateSessionsTable.ts': [
+            'B2B2C_TENANT_COLUMN'      // Add tenant_id column for session scoping
           ]
         }
       },
@@ -126,8 +125,7 @@ const VARIANT_CONFIG = {
         // Complete files to copy (has both multi-tenant and B2B2C features)
         files: [
           'src/modules/users/user-business.entity.ts',         // Business-to-user linking entity
-          'src/modules/auth/auth.service.ts',                  // Combined auth service
-          'src/modules/auth/auth.controller.ts',               // Combined auth controller
+          'src/modules/auth/auth.ts',                          // Combined Better Auth config
           'src/modules/users/users.service.ts',                // Combined users service
           'src/modules/users/users.controller.ts',             // Combined users controller
           'src/modules/domain/projects/projects.module.ts'     // Projects module with UserBusiness
@@ -310,6 +308,14 @@ const VARIANT_CONFIG = {
           'src/store/useProjectStore.ts'          // Project state
         ],
         sections: {}
+      },
+
+      'b2b2c': {
+        // B2B2C uses separate auth endpoint for customer sessions
+        files: [
+          'src/lib/auth-client.ts'                // Auth client with /api/auth/customer basePath
+        ],
+        sections: {}
       }
     },
 
@@ -395,6 +401,11 @@ function resolveVariantChoices(backendChoices) {
     choices['admin-portal'].userModel = backendChoices.userModel;
   }
 
+  // Special case: customers-portal inherits BOTH tenancy and userModel
+  if (choices['customers-portal']) {
+    choices['customers-portal'].userModel = backendChoices.userModel;
+  }
+
   // Special case: infrastructure needs BOTH tenancy and userModel for proper variant resolution
   if (choices['infrastructure']) {
     choices['infrastructure'].tenancy = backendChoices.tenancy;

package/src/utils/docker-helper.js

@@ -159,7 +159,6 @@ async function buildFullAppImages(projectRoot, projectName, githubOrg, envFilePa
       `DOCS_URL=${envVars.DOCS_URL || ''}`,
       `CONTACT_EMAIL=${envVars.CONTACT_EMAIL || ''}`,
       `CTA_LINK=${envVars.CTA_LINK || ''}`,
-      `LIVE_DEMO_URL=${envVars.LIVE_DEMO_URL || ''}`,
       `MIXPANEL_PROJECT_TOKEN=${envVars.MIXPANEL_PROJECT_TOKEN || ''}`,
       `GOOGLE_ANALYTICS_ID=${envVars.GOOGLE_ANALYTICS_ID || ''}`
     ];
@@ -245,15 +244,130 @@ async function buildWaitlistImage(projectRoot, projectName, githubOrg) {
     });
 
     spinner.succeed(`waitlist built and pushed successfully`);
+
+    // Clean up local image after push
+    const cleanupSpinner = ora('Cleaning up local waitlist image...').start();
+    try {
+      await execAsync(`docker rmi ${imageName}`, { timeout: 30000 });
+      cleanupSpinner.succeed('Cleaned up local waitlist image');
+    } catch (error) {
+      cleanupSpinner.info('Could not remove local waitlist image (may be in use)');
+    }
   } catch (error) {
     spinner.fail(`Failed to build waitlist`);
     throw new Error(`Build failed for waitlist: ${error.message}`);
   }
 }
 
+/**
+ * Clean up local Docker images after push
+ * @param {string} registry - Registry URL (e.g., 'ghcr.io/myorg')
+ * @param {string} projectName - Project name
+ * @param {string[]} services - List of services to clean up
+ * @returns {Promise<void>}
+ */
+async function cleanupLocalImages(registry, projectName, services) {
+  const spinner = ora('Cleaning up local Docker images...').start();
+
+  const imagesToRemove = services.map(service => `${registry}/${projectName}-${service}:latest`);
+  let removedCount = 0;
+
+  for (const imageName of imagesToRemove) {
+    try {
+      await execAsync(`docker rmi ${imageName}`, { timeout: 30000 });
+      removedCount++;
+    } catch (error) {
+      // Image might not exist or be in use, continue
+    }
+  }
+
+  if (removedCount > 0) {
+    spinner.succeed(`Cleaned up ${removedCount} local Docker image(s)`);
+  } else {
+    spinner.info('No local images to clean up');
+  }
+}
+
+/**
+ * Complete build and push workflow - checks Docker, logs in to GHCR, builds and pushes images
+ * @param {Object} options - Workflow options
+ * @param {string} options.projectRoot - Project root directory
+ * @param {string} options.projectName - Project name
+ * @param {string} options.githubOrg - GitHub organization/username
+ * @param {string} options.ghcrToken - GitHub Container Registry token
+ * @param {string} options.envProdPath - Path to .env.prod file
+ * @param {string[]} options.installedServices - List of installed services
+ * @param {string} [options.serviceName] - Optional specific service to build (if not provided, builds all)
+ * @returns {Promise<void>}
+ */
+async function buildAndPushWorkflow(options) {
+  const {
+    projectRoot,
+    projectName,
+    githubOrg,
+    ghcrToken,
+    envProdPath,
+    installedServices,
+    serviceName
+  } = options;
+
+  // Step 1: Check Docker is running
+  const dockerSpinner = ora('Checking Docker...').start();
+
+  const dockerRunning = await checkDockerRunning();
+  if (!dockerRunning) {
+    dockerSpinner.fail('Docker is not running');
+    throw new Error('Docker is not running. Please start Docker and try again.');
+  }
+
+  dockerSpinner.succeed('Docker is running');
+
+  // Step 2: Login to GHCR
+  if (!ghcrToken) {
+    throw new Error('GHCR token not found. Run deploy:configure to set up your GitHub token.');
+  }
+
+  await loginToGHCR(githubOrg, ghcrToken);
+
+  // Step 3: Build and push images
+  console.log(chalk.yellow('\n📦 Building and pushing images...\n'));
+
+  const registry = `ghcr.io/${githubOrg}`;
+
+  if (serviceName) {
+    // Build specific service
+    if (!installedServices.includes(serviceName)) {
+      throw new Error(`Service "${serviceName}" not found in installed services. Available: ${installedServices.join(', ')}`);
+    }
+
+    await buildAndPushImage(
+      serviceName,
+      path.join(projectRoot, serviceName),
+      registry,
+      projectName
+    );
+
+    // Clean up local image after push
+    await cleanupLocalImages(registry, projectName, [serviceName]);
+
+    console.log(chalk.green.bold(`\n✅ ${serviceName} built and pushed to GHCR!\n`));
+  } else {
+    // Build all services
+    await buildFullAppImages(projectRoot, projectName, githubOrg, envProdPath, installedServices);
+
+    // Clean up local images after push
+    await cleanupLocalImages(registry, projectName, installedServices);
+
+    console.log(chalk.green.bold('\n✅ All images built and pushed to GHCR!\n'));
+  }
+}
+
 module.exports = {
   checkDockerRunning,
   loginToGHCR,
+  buildAndPushImage,
   buildFullAppImages,
-  buildWaitlistImage
+  buildWaitlistImage,
+  buildAndPushWorkflow,
+  cleanupLocalImages
 };

package/src/utils/env-generator.js

@@ -25,28 +25,31 @@ async function generateEnvFile(projectRoot, answers) {
 
   // Generate secure secrets
   const secrets = {
-    JWT_SECRET: generateSecret(32),
+    BETTER_AUTH_SECRET: generateSecret(32),
     DB_PASSWORD: generateSecret(24),
     BULL_ADMIN_TOKEN: generateSecret(24)
   };
 
   // Create variable mappings
+  // Note: PRIMARY_DOMAIN and ADMIN_EMAIL are NOT replaced here - they stay as placeholders
+  // until deploy:configure and deploy:set-env are run
   const variables = {
     '{{PROJECT_NAME}}': answers.projectName,
     '{{PROJECT_NAME_UPPER}}': answers.projectNameUpper,
-    '{{PRIMARY_DOMAIN}}': answers.primaryDomain,
-    '{{ADMIN_EMAIL}}': answers.adminEmail,
+    '{{PROJECT_DISPLAY_NAME}}': answers.projectDisplayName,
 
     // Replace placeholder passwords with generated secrets
     'your_secure_postgres_password': secrets.DB_PASSWORD,
-    'your_jwt_secret_key_change_this_in_production': secrets.JWT_SECRET,
+    'your_better_auth_secret_minimum_32_chars': secrets.BETTER_AUTH_SECRET,
     'your_bull_admin_token': secrets.BULL_ADMIN_TOKEN
   };
 
-  // Replace variables in template
+  // Replace variables in template (only those with defined values)
   let envContent = envTemplate;
   for (const [placeholder, value] of Object.entries(variables)) {
-    envContent = envContent.split(placeholder).join(value);
+    if (value !== undefined && value !== null) {
+      envContent = envContent.split(placeholder).join(value);
+    }
   }
 
   // Write .env file

package/src/utils/env-validator.js

@@ -59,13 +59,15 @@ async function validateEnvProd(envProdPath) {
 }
 
 /**
- * Generate a secure random string for secrets
+ * Generate a secure random string for secrets (URL-safe)
  * @param {number} length - Length of string to generate
  * @returns {string}
  */
 function generateSecret(length = 32) {
   const crypto = require('crypto');
-  return crypto.randomBytes(length).toString('base64').slice(0, length);
+  // Use hex encoding to avoid URL-unsafe characters (+, /, =)
+  // Hex produces 2 chars per byte, so divide by 2
+  return crypto.randomBytes(Math.ceil(length / 2)).toString('hex').slice(0, length);
 }
 
 module.exports = {

package/src/utils/github-access.js

@@ -38,26 +38,28 @@ async function checkGitHubAccess() {
 
 /**
  * Display message when user doesn't have access to services repository
- * Guides them to either purchase or setup SSH keys
+ * Guides them to either get beta access or setup SSH keys
  */
 function showAccessDeniedMessage() {
-  const purchaseUrl = 'https://buy.polar.sh/polar_cl_Zy4YqEwhoIEdUrAH8vHaWuZtwZuv306sYMnq118MbKi';
+  const betaUrl = 'https://launchframe.dev/';
   const docsUrl = 'https://docs.launchframe.dev/guide/quick-start#add-ssh-key-to-repo';
-  
+
   console.log(chalk.red('\n❌ Cannot access LaunchFrame services repository\n'));
-  
+
   console.log(chalk.white('This could mean:\n'));
-  console.log(chalk.gray('  1. You haven\'t purchased LaunchFrame yet'));
-  console.log(chalk.gray('  2. You purchased but haven\'t added your SSH key to the repo\n'));
-  
-  console.log(chalk.cyan('→ New customers:'));
-  console.log('  ' + chalk.blue.bold.underline(makeClickable('Purchase LaunchFrame', purchaseUrl)));
-  console.log('  ' + chalk.cyan(purchaseUrl + '\n'));
-  
-  console.log(chalk.cyan('→ Existing customers:'));
+  console.log(chalk.gray('  1. You don\'t have beta access yet'));
+  console.log(chalk.gray('  2. You have access but haven\'t added your SSH key to the repo\n'));
+
+  console.log(chalk.cyan('→ Get beta access:'));
+  console.log(chalk.white('  LaunchFrame is in open beta for 100 users.'));
+  console.log(chalk.white('  Get free lifetime access at:'));
+  console.log('  ' + chalk.blue.bold.underline(makeClickable('launchframe.dev', betaUrl)));
+  console.log('  ' + chalk.cyan(betaUrl + '\n'));
+
+  console.log(chalk.cyan('→ Already have access?'));
   console.log('  ' + chalk.blue.bold.underline(makeClickable('Setup SSH key (docs)', docsUrl)));
   console.log('  ' + chalk.cyan(docsUrl + '\n'));
-  
+
   console.log(chalk.gray('After setup, run: launchframe init\n'));
 }
 

package/src/utils/logger.js

@@ -0,0 +1,93 @@
+const chalk = require('chalk');
+
+/**
+ * Simple logger with verbose mode support
+ *
+ * Usage:
+ *   logger.setVerbose(true);
+ *   logger.info('Main message');    // Always shown
+ *   logger.detail('Nested detail'); // Only shown in verbose mode
+ */
+
+let verboseMode = false;
+
+/**
+ * Enable or disable verbose mode
+ * @param {boolean} enabled
+ */
+function setVerbose(enabled) {
+  verboseMode = enabled;
+}
+
+/**
+ * Check if verbose mode is enabled
+ * @returns {boolean}
+ */
+function isVerbose() {
+  return verboseMode;
+}
+
+/**
+ * Log a main info message (always shown)
+ * @param {string} message
+ */
+function info(message) {
+  console.log(message);
+}
+
+/**
+ * Log a success message (always shown)
+ * @param {string} message
+ */
+function success(message) {
+  console.log(chalk.green(message));
+}
+
+/**
+ * Log an error message (always shown)
+ * @param {string} message
+ */
+function error(message) {
+  console.error(chalk.red(message));
+}
+
+/**
+ * Log a warning message (always shown)
+ * @param {string} message
+ */
+function warn(message) {
+  console.warn(chalk.yellow(message));
+}
+
+/**
+ * Log a detail/nested message (only in verbose mode)
+ * @param {string} message
+ * @param {number} indent - Indentation level (default 1)
+ */
+function detail(message, indent = 1) {
+  if (verboseMode) {
+    const prefix = '  '.repeat(indent);
+    console.log(chalk.gray(`${prefix}${message}`));
+  }
+}
+
+/**
+ * Log a step within an operation (only in verbose mode)
+ * @param {string} message
+ */
+function step(message) {
+  if (verboseMode) {
+    console.log(chalk.gray(`  - ${message}`));
+  }
+}
+
+module.exports = {
+  setVerbose,
+  isVerbose,
+  info,
+  success,
+  error,
+  warn,
+  detail,
+  step
+};

package/src/utils/module-installer.js

@@ -0,0 +1,58 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+const { replaceSection } = require('./section-replacer');
+
+/**
+ * Install a module into a project
+ * @param {string} moduleName - Name of the module to install
+ * @param {Object} moduleConfig - Config object from MODULE_CONFIG[moduleName]
+ */
+async function installModule(moduleName, moduleConfig) {
+  const templateRoot = path.resolve(__dirname, '../../../services');
+  const cwd = process.cwd();
+
+  for (const [serviceName, config] of Object.entries(moduleConfig)) {
+    const moduleFilesDir = path.join(templateRoot, 'modules', moduleName, serviceName, 'files');
+    const moduleSectionsDir = path.join(templateRoot, 'modules', moduleName, serviceName, 'sections');
+    const serviceDir = path.join(cwd, serviceName);
+
+    // Copy files
+    for (const filePath of config.files) {
+      const src = path.join(moduleFilesDir, filePath);
+      const dest = path.join(serviceDir, filePath);
+      console.log(`  Adding ${filePath}`);
+      await fs.copy(src, dest, { overwrite: true });
+    }
+
+    // Inject sections
+    for (const [targetFile, markerNames] of Object.entries(config.sections)) {
+      const targetFilePath = path.join(serviceDir, targetFile);
+      const targetBasename = path.basename(targetFile);
+
+      for (const markerName of markerNames) {
+        const sectionFile = path.join(moduleSectionsDir, `${targetBasename}.${markerName}`);
+        console.log(`  Injecting ${markerName} into ${targetFile}`);
+        const sectionContent = await fs.readFile(sectionFile, 'utf8');
+        await replaceSection(targetFilePath, markerName, sectionContent);
+      }
+    }
+
+    // Merge dependencies into package.json and sync lockfile
+    if (config.dependencies && Object.keys(config.dependencies).length > 0) {
+      const packageJsonPath = path.join(serviceDir, 'package.json');
+      const packageJson = await fs.readJson(packageJsonPath);
+      packageJson.dependencies = {
+        ...packageJson.dependencies,
+        ...config.dependencies,
+      };
+      await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+
+      // Run npm install to sync package-lock.json, otherwise `npm ci` will fail on rebuild
+      console.log(`\nRunning npm install in ${serviceName}...`);
+      execSync('npm install', { cwd: serviceDir, stdio: 'inherit' });
+    }
+  }
+}
+
+module.exports = { installModule };

package/src/utils/project-helpers.js

@@ -95,6 +95,36 @@ function isWaitlistInstalled(config = null) {
   return (config.installedServices || []).includes('waitlist');
 }
 
+/**
+ * Get list of installed modules
+ */
+function getInstalledModules() {
+  const config = getProjectConfig();
+  return config.installedModules || [];
+}
+
+/**
+ * Check if a module is installed
+ */
+function isModuleInstalled(moduleName) {
+  const installedModules = getInstalledModules();
+  return installedModules.includes(moduleName);
+}
+
+/**
+ * Add a module to the installed modules list
+ */
+function addInstalledModule(moduleName) {
+  const config = getProjectConfig();
+  if (!config.installedModules) {
+    config.installedModules = [];
+  }
+  if (!config.installedModules.includes(moduleName)) {
+    config.installedModules.push(moduleName);
+    updateProjectConfig(config);
+  }
+}
+
 module.exports = {
   isLaunchFrameProject,
   requireProject,
@@ -104,5 +134,8 @@ module.exports = {
   isComponentInstalled,
   addInstalledComponent,
   getPrimaryDomain,
-  isWaitlistInstalled
+  isWaitlistInstalled,
+  getInstalledModules,
+  isModuleInstalled,
+  addInstalledModule
 };

package/src/utils/service-cache.js

@@ -3,6 +3,7 @@ const fs = require('fs-extra');
 const os = require('os');
 const { execSync } = require('child_process');
 const chalk = require('chalk');
+const logger = require('./logger');
 
 const SERVICES_REPO = 'git@github.com:launchframe-dev/services.git';
 const BRANCH = 'main';
@@ -38,30 +39,26 @@ async function cacheExists() {
 async function initializeCache() {
   const cacheDir = getCacheDir();
 
-  console.log(chalk.blue('🔄 Initializing services cache...'));
+  logger.detail('Initializing services cache...');
 
   try {
-    // Ensure parent directory exists
     await fs.ensureDir(path.dirname(cacheDir));
 
-    // Sparse clone (only root files, no services)
     execSync(
       `git clone --sparse --depth 1 --branch ${BRANCH} ${SERVICES_REPO} "${cacheDir}"`,
       {
-        stdio: 'pipe', // Hide output
-        timeout: 60000 // 1 minute timeout
+        stdio: 'pipe',
+        timeout: 60000
       }
     );
 
-    // Configure sparse checkout (starts with empty set)
     execSync('git sparse-checkout init --cone', {
       cwd: cacheDir,
       stdio: 'pipe'
     });
 
-    console.log(chalk.green('✓ Cache initialized'));
+    logger.detail('Cache initialized');
   } catch (error) {
-    // Clean up partial clone on failure
     await fs.remove(cacheDir);
     throw new Error(`Failed to initialize cache: ${error.message}`);
   }
@@ -75,16 +72,16 @@ async function initializeCache() {
 async function updateCache() {
   const cacheDir = getCacheDir();
 
-  console.log(chalk.blue('🔄 Updating service cache...'));
+  logger.detail('Updating service cache...');
 
   try {
     execSync('git pull origin main', {
       cwd: cacheDir,
       stdio: 'pipe',
-      timeout: 30000 // 30 seconds
+      timeout: 30000
     });
 
-    console.log(chalk.green('✓ Cache updated'));
+    logger.detail('Cache updated');
   } catch (error) {
     throw new Error(`Failed to update cache: ${error.message}`);
   }
@@ -98,10 +95,9 @@ async function updateCache() {
 async function expandServices(serviceNames) {
   const cacheDir = getCacheDir();
 
-  console.log(chalk.blue(`📦 Loading services: ${serviceNames.join(', ')}...`));
+  logger.detail(`Loading services: ${serviceNames.join(', ')}...`);
 
   try {
-    // Get current sparse checkout list
     let currentServices = [];
     try {
       const output = execSync('git sparse-checkout list', {
@@ -114,17 +110,15 @@ async function expandServices(serviceNames) {
       // No services yet, that's fine
     }
 
-    // Add new services to the list
     const allServices = [...new Set([...currentServices, ...serviceNames])];
 
-    // Set sparse checkout to include all services
     execSync(`git sparse-checkout set ${allServices.join(' ')}`, {
       cwd: cacheDir,
       stdio: 'pipe',
-      timeout: 60000 // 1 minute (may need to download files)
+      timeout: 60000
     });
 
-    console.log(chalk.green('✓ Services loaded'));
+    logger.detail('Services loaded');
   } catch (error) {
     throw new Error(`Failed to expand services: ${error.message}`);
   }
@@ -158,7 +152,7 @@ async function clearCache() {
 
   if (await fs.pathExists(cacheDir)) {
     await fs.remove(cacheDir);
-    console.log(chalk.green('✓ Cache cleared'));
+    console.log(chalk.green('Cache cleared'));
   } else {
     console.log(chalk.gray('Cache is already empty'));
   }