@launchframe/cli 1.0.0-beta.2 → 1.0.0-beta.21

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

@@ -14,14 +14,14 @@ function makeClickable(text, url) {
 }
 
 /**
- * Check if user has SSH access to LaunchFrame modules repository
+ * Check if user has SSH access to LaunchFrame services repository
  * @returns {Promise<{hasAccess: boolean, error?: string}>}
  */
 async function checkGitHubAccess() {
   try {
     // Test SSH access by checking if we can list remote refs
     execSync(
-      'git ls-remote git@github.com:launchframe-dev/modules.git HEAD',
+      'git ls-remote git@github.com:launchframe-dev/services.git HEAD',
       { 
         timeout: 15000,
         stdio: 'pipe' // Don't show output
@@ -37,27 +37,29 @@ async function checkGitHubAccess() {
 }
 
 /**
- * Display message when user doesn't have access to modules repository
- * Guides them to either purchase or setup SSH keys
+ * Display message when user doesn't have access to services repository
+ * 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 modules repository\n'));
-  
+
+  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/project-helpers.js

@@ -7,7 +7,11 @@ const chalk = require('chalk');
  */
 function isLaunchFrameProject() {
   const markerPath = path.join(process.cwd(), '.launchframe');
-  return fs.existsSync(markerPath);
+  try {
+    return fs.existsSync(markerPath) && fs.statSync(markerPath).isFile();
+  } catch (error) {
+    return false;
+  }
 }
 
 /**

package/src/utils/{module-cache.js → service-cache.js}

@@ -3,8 +3,9 @@ const fs = require('fs-extra');
 const os = require('os');
 const { execSync } = require('child_process');
 const chalk = require('chalk');
+const logger = require('./logger');
 
-const MODULES_REPO = 'git@github.com:launchframe-dev/modules.git';
+const SERVICES_REPO = 'git@github.com:launchframe-dev/services.git';
 const BRANCH = 'main';
 
 /**
@@ -15,9 +16,9 @@ const BRANCH = 'main';
 function getCacheDir() {
   const homeDir = os.homedir();
   // Use same path structure on all platforms
-  // Windows: C:\Users\username\.launchframe\cache\modules
-  // Mac/Linux: /home/username/.launchframe/cache/modules
-  return path.join(homeDir, '.launchframe', 'cache', 'modules');
+  // Windows: C:\Users\username\.launchframe\cache\services
+  // Mac/Linux: /home/username/.launchframe/cache/services
+  return path.join(homeDir, '.launchframe', 'cache', 'services');
 }
 
 /**
@@ -32,36 +33,32 @@ async function cacheExists() {
 
 /**
  * Initialize cache with sparse checkout
- * Clones only the repository structure, no modules yet
+ * Clones only the repository structure, no services yet
  * @returns {Promise<void>}
  */
 async function initializeCache() {
   const cacheDir = getCacheDir();
-  
-  console.log(chalk.blue('🔄 Initializing module cache...'));
-  
+
+  logger.detail('Initializing services cache...');
+
   try {
-    // Ensure parent directory exists
     await fs.ensureDir(path.dirname(cacheDir));
-    
-    // Sparse clone (only root files, no modules)
+
     execSync(
-      `git clone --sparse --depth 1 --branch ${BRANCH} ${MODULES_REPO} "${cacheDir}"`,
-      { 
-        stdio: 'pipe', // Hide output
-        timeout: 60000 // 1 minute timeout
+      `git clone --sparse --depth 1 --branch ${BRANCH} ${SERVICES_REPO} "${cacheDir}"`,
+      {
+        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}`);
   }
@@ -74,70 +71,67 @@ async function initializeCache() {
  */
 async function updateCache() {
   const cacheDir = getCacheDir();
-  
-  console.log(chalk.blue('🔄 Updating module 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}`);
   }
 }
 
 /**
- * Expand sparse checkout to include specific modules
- * @param {string[]} moduleNames - Array of module names to expand
+ * Expand sparse checkout to include specific services
+ * @param {string[]} serviceNames - Array of services names to expand
  * @returns {Promise<void>}
  */
-async function expandModules(moduleNames) {
+async function expandServices(serviceNames) {
   const cacheDir = getCacheDir();
-  
-  console.log(chalk.blue(`📦 Loading modules: ${moduleNames.join(', ')}...`));
-  
+
+  logger.detail(`Loading services: ${serviceNames.join(', ')}...`);
+
   try {
-    // Get current sparse checkout list
-    let currentModules = [];
+    let currentServices = [];
     try {
       const output = execSync('git sparse-checkout list', {
         cwd: cacheDir,
         stdio: 'pipe',
         encoding: 'utf8'
       });
-      currentModules = output.trim().split('\n').filter(Boolean);
+      currentServices = output.trim().split('\n').filter(Boolean);
     } catch (error) {
-      // No modules yet, that's fine
+      // No services yet, that's fine
     }
-    
-    // Add new modules to the list
-    const allModules = [...new Set([...currentModules, ...moduleNames])];
-    
-    // Set sparse checkout to include all modules
-    execSync(`git sparse-checkout set ${allModules.join(' ')}`, {
+
+    const allServices = [...new Set([...currentServices, ...serviceNames])];
+
+    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('✓ Modules loaded'));
+
+    logger.detail('Services loaded');
   } catch (error) {
-    throw new Error(`Failed to expand modules: ${error.message}`);
+    throw new Error(`Failed to expand services: ${error.message}`);
   }
 }
 
 /**
- * Get path to a specific module in the cache
- * @param {string} moduleName - Module name (e.g., 'backend', 'admin-portal')
- * @returns {string} Absolute path to module
+ * Get path to a specific service in the cache
+ * @param {string} serviceName - Service name (e.g., 'backend', 'admin-portal')
+ * @returns {string} Absolute path to service
  */
-function getModulePath(moduleName) {
+function getServicePath(serviceName) {
   const cacheDir = getCacheDir();
-  return path.join(cacheDir, moduleName);
+  return path.join(cacheDir, serviceName);
 }
 
 /**
@@ -149,24 +143,24 @@ function getCachePath() {
 }
 
 /**
- * Clear the entire module cache
+ * Clear the entire service cache
  * Useful for troubleshooting or forcing fresh download
  * @returns {Promise<void>}
  */
 async function clearCache() {
   const cacheDir = getCacheDir();
-  
+
   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'));
   }
 }
 
 /**
- * Get cache information (size, last update, modules)
- * @returns {Promise<{exists: boolean, path: string, size?: number, modules?: string[], lastUpdate?: Date}>}
+ * Get cache information (size, last update, services)
+ * @returns {Promise<{exists: boolean, path: string, size?: number, services?: string[], lastUpdate?: Date}>}
  */
 async function getCacheInfo() {
   const cacheDir = getCacheDir();
@@ -174,13 +168,13 @@ async function getCacheInfo() {
     exists: false,
     path: cacheDir
   };
-  
+
   if (!(await cacheExists())) {
     return info;
   }
-  
+
   info.exists = true;
-  
+
   try {
     // Get cache size (du command works on Unix/Mac, different on Windows)
     if (process.platform === 'win32') {
@@ -201,19 +195,19 @@ async function getCacheInfo() {
   } catch (error) {
     // Size calculation failed, not critical
   }
-  
+
   try {
-    // Get list of expanded modules
+    // Get list of expanded services
     const output = execSync('git sparse-checkout list', {
       cwd: cacheDir,
       encoding: 'utf8',
       stdio: 'pipe'
     });
-    info.modules = output.trim().split('\n').filter(Boolean);
+    info.services = output.trim().split('\n').filter(Boolean);
   } catch (error) {
-    info.modules = [];
+    info.services = [];
   }
-  
+
   try {
     // Get last update time from git log
     const output = execSync('git log -1 --format=%cd --date=iso', {
@@ -225,17 +219,17 @@ async function getCacheInfo() {
   } catch (error) {
     // Last update time failed, not critical
   }
-  
+
   return info;
 }
 
 /**
  * Ensure cache is ready (initialize if needed, update if exists)
  * This is the main entry point for cache management
- * @param {string[]} requiredModules - Modules needed for the operation
+ * @param {string[]} requiredServices - Services needed for the operation
  * @returns {Promise<string>} Path to cache root
  */
-async function ensureCacheReady(requiredModules) {
+async function ensureCacheReady(requiredServices) {
   try {
     if (!(await cacheExists())) {
       // Cache doesn't exist, initialize it
@@ -244,10 +238,10 @@ async function ensureCacheReady(requiredModules) {
       // Cache exists, update it
       await updateCache();
     }
-    
-    // Expand sparse checkout to include required modules
-    await expandModules(requiredModules);
-    
+
+    // Expand sparse checkout to include required services
+    await expandServices(requiredServices);
+
     return getCachePath();
   } catch (error) {
     // If we fail and it's a network error, provide helpful message
@@ -265,8 +259,8 @@ module.exports = {
   cacheExists,
   initializeCache,
   updateCache,
-  expandModules,
-  getModulePath,
+  expandServices,
+  getServicePath,
   getCachePath,
   clearCache,
   getCacheInfo,