@launchframe/cli 1.0.0-beta.14 → 1.0.0-beta.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@launchframe/cli",
-  "version": "1.0.0-beta.14",
+  "version": "1.0.0-beta.17",
   "description": "Production-ready B2B SaaS boilerplate with subscriptions, credits, and multi-tenancy",
   "main": "src/index.js",
   "bin": {

package/src/commands/deploy-build.js

@@ -0,0 +1,137 @@
+const chalk = require('chalk');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const ora = require('ora');
+const path = require('path');
+const { requireProject, getProjectConfig } = require('../utils/project-helpers');
+const { checkDockerRunning, loginToGHCR, buildFullAppImages, buildAndPushImage } = require('../utils/docker-helper');
+
+const execAsync = promisify(exec);
+
+/**
+ * Build, push, and deploy Docker images
+ * @param {string} [serviceName] - Optional specific service to build (e.g., 'backend', 'admin-portal')
+ */
+async function deployBuild(serviceName) {
+  requireProject();
+
+  const serviceLabel = serviceName ? `(${serviceName})` : '(all services)';
+  console.log(chalk.blue.bold(`\n🔨 LaunchFrame Build & Deploy ${serviceLabel}\n`));
+
+  const config = getProjectConfig();
+  const projectRoot = process.cwd();
+
+  // Validate deployment is configured
+  if (!config.deployConfigured || !config.deployment) {
+    console.log(chalk.red('❌ Error: Deployment not configured yet\n'));
+    console.log(chalk.gray('Run this command first:'));
+    console.log(chalk.white('  launchframe deploy:configure\n'));
+    process.exit(1);
+  }
+
+  const { vpsHost, vpsUser, vpsAppFolder, githubOrg } = config.deployment;
+  const { projectName, installedServices } = config;
+  const envProdPath = path.join(projectRoot, 'infrastructure', '.env.prod');
+
+  // Step 1: Check Docker is running
+  console.log(chalk.yellow('🐳 Step 1: Checking Docker...\n'));
+
+  const dockerSpinner = ora('Checking Docker...').start();
+
+  const dockerRunning = await checkDockerRunning();
+  if (!dockerRunning) {
+    dockerSpinner.fail('Docker is not running');
+    console.log(chalk.red('\n❌ Please start Docker and try again.\n'));
+    process.exit(1);
+  }
+
+  dockerSpinner.succeed('Docker is running');
+
+  // Step 2: Login to GHCR
+  console.log(chalk.yellow('\n🔐 Step 2: Logging in to GitHub Container Registry...\n'));
+
+  const ghcrToken = config.deployment.ghcrToken;
+  if (!ghcrToken) {
+    console.log(chalk.red('❌ Error: GHCR token not found in .launchframe config\n'));
+    console.log(chalk.gray('Run deploy:configure to set up your GitHub token.\n'));
+    process.exit(1);
+  }
+
+  try {
+    await loginToGHCR(githubOrg, ghcrToken);
+  } catch (error) {
+    console.log(chalk.red(`\n❌ ${error.message}\n`));
+    process.exit(1);
+  }
+
+  // Step 3: Build and push images
+  console.log(chalk.yellow('\n📦 Step 3: Building and pushing images...\n'));
+
+  try {
+    if (serviceName) {
+      // Build specific service
+      if (!installedServices.includes(serviceName)) {
+        console.log(chalk.red(`❌ Service "${serviceName}" not found in installed services.\n`));
+        console.log(chalk.gray(`Available services: ${installedServices.join(', ')}\n`));
+        process.exit(1);
+      }
+
+      const registry = `ghcr.io/${githubOrg}`;
+      await buildAndPushImage(
+        serviceName,
+        path.join(projectRoot, serviceName),
+        registry,
+        projectName
+      );
+      console.log(chalk.green.bold(`\n✅ ${serviceName} built and pushed to GHCR!\n`));
+    } else {
+      // Build all services
+      await buildFullAppImages(projectRoot, projectName, githubOrg, envProdPath, installedServices);
+      console.log(chalk.green.bold('\n✅ All images built and pushed to GHCR!\n'));
+    }
+  } catch (error) {
+    console.log(chalk.red(`\n❌ Build failed: ${error.message}\n`));
+    process.exit(1);
+  }
+
+  // Step 4: Pull images on VPS
+  console.log(chalk.yellow('\n🚀 Step 4: Pulling images on VPS...\n'));
+
+  const pullSpinner = ora('Pulling images on VPS...').start();
+
+  try {
+    await execAsync(
+      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml pull"`,
+      { timeout: 600000 } // 10 minutes
+    );
+    pullSpinner.succeed('Images pulled on VPS');
+  } catch (error) {
+    pullSpinner.fail('Failed to pull images');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+
+  // Step 5: Restart services
+  console.log(chalk.yellow('\n🔄 Step 5: Restarting services...\n'));
+
+  const restartSpinner = ora('Restarting services...').start();
+
+  try {
+    await execAsync(
+      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d"`,
+      { timeout: 300000 } // 5 minutes
+    );
+    restartSpinner.succeed('Services restarted');
+  } catch (error) {
+    restartSpinner.fail('Failed to restart services');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+
+  // Success!
+  console.log(chalk.green.bold('\n✅ Build and deploy complete!\n'));
+
+  console.log(chalk.gray('Your updated application is now running.\n'));
+}
+
+module.exports = { deployBuild };

package/src/commands/deploy-set-env.js

@@ -164,6 +164,7 @@ async function deploySetEnv() {
   if (config.deployment?.primaryDomain) {
     const domain = config.deployment.primaryDomain;
     const urlReplacements = {
+      'PRIMARY_DOMAIN': domain,
       'API_BASE_URL': `https://api.${domain}`,
       'ADMIN_BASE_URL': `https://admin.${domain}`,
       'FRONTEND_BASE_URL': `https://app.${domain}`,

package/src/commands/deploy-up.js

@@ -106,7 +106,7 @@ async function deployUp() {
 
   try {
     const { stdout: psOutput } = await execAsync(
-      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml ps"`,
+      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml ps"`,
       { timeout: 30000 }
     );
 
@@ -139,7 +139,7 @@ async function deployUp() {
   console.log(chalk.gray('   Just push to GitHub - CI/CD will handle deployment automatically!\n'));
 
   console.log(chalk.white('3. Monitor services:'));
-  console.log(chalk.gray(`   Run: ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose logs -f"\n`));
+  console.log(chalk.gray(`   Run: ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml logs -f"\n`));
 }
 
 module.exports = { deployUp };

package/src/commands/help.js

@@ -7,16 +7,19 @@ const { isLaunchFrameProject, isWaitlistInstalled } = require('../utils/project-
 function help() {
   const inProject = isLaunchFrameProject();
 
-  console.log(chalk.blue.bold('\n🚀 LaunchFrame CLI\n'));
+  console.log(chalk.blue.bold('\nLaunchFrame CLI\n'));
   console.log(chalk.white('Usage:'));
-  console.log(chalk.gray('  launchframe [command]\n'));
+  console.log(chalk.gray('  launchframe [command] [options]\n'));
+  console.log(chalk.white('Global options:'));
+  console.log(chalk.gray('  --verbose, -v           Show detailed output\n'));
 
   if (inProject) {
     console.log(chalk.white('Deployment commands:'));
     console.log(chalk.gray('  deploy:configure  Configure production deployment settings'));
     console.log(chalk.gray('  deploy:set-env    Configure production environment variables'));
     console.log(chalk.gray('  deploy:init       Initialize VPS and build Docker images'));
-    console.log(chalk.gray('  deploy:up         Start services on VPS\n'));
+    console.log(chalk.gray('  deploy:up         Start services on VPS'));
+    console.log(chalk.gray('  deploy:build [service]  Build, push, and deploy (all or specific service)\n'));
 
     // Conditionally show waitlist commands
     if (isWaitlistInstalled()) {
@@ -83,6 +86,8 @@ function help() {
     console.log(chalk.gray('  launchframe init\n'));
     console.log(chalk.gray('  # Non-interactive mode'));
     console.log(chalk.gray('  launchframe init --project-name my-saas --tenancy single --user-model b2b\n'));
+    console.log(chalk.gray('  # With verbose output'));
+    console.log(chalk.gray('  launchframe init --verbose\n'));
   }
 }
 

package/src/commands/init.js

@@ -6,6 +6,7 @@ const { generateProject } = require('../generator');
 const { checkGitHubAccess, showAccessDeniedMessage } = require('../utils/github-access');
 const { ensureCacheReady } = require('../utils/service-cache');
 const { isLaunchFrameProject } = require('../utils/project-helpers');
+const logger = require('../utils/logger');
 
 /**
  * Check if running in development mode (local) vs production (npm install)
@@ -23,28 +24,28 @@ function isDevMode() {
  * @param {string} options.userModel - User model: 'b2b' or 'b2b2c' (skips prompt if provided)
  */
 async function init(options = {}) {
-  console.log(chalk.blue.bold('\n🚀 Welcome to LaunchFrame!\n'));
+  console.log(chalk.blue.bold('\nLaunchFrame\n'));
 
   // Check if in development mode
   const devMode = isDevMode();
-  
+
   if (!devMode) {
     // Production mode: Check GitHub access
-    console.log(chalk.blue('🔍 Checking repository access...\n'));
-    
+    console.log(chalk.gray('Checking repository access...'));
+
     const accessCheck = await checkGitHubAccess();
-    
+
     if (!accessCheck.hasAccess) {
-      // No access - show purchase/setup message
       showAccessDeniedMessage();
-      process.exit(1); // Exit with error code
+      process.exit(1);
     }
-    
-    console.log(chalk.green('✓ Repository access confirmed\n'));
+
+    console.log(chalk.green('Repository access confirmed\n'));
   }
+
   // Check if already in a LaunchFrame project
   if (isLaunchFrameProject()) {
-    console.error(chalk.red('\n❌ Error: Already in a LaunchFrame project'));
+    console.error(chalk.red('Error: Already in a LaunchFrame project'));
     console.log(chalk.gray('Use other commands to manage your project, or run init from outside the project.\n'));
     process.exit(1);
   }
@@ -54,12 +55,10 @@ async function init(options = {}) {
 
     // If project name provided via flag, skip prompts
     if (options.projectName) {
-      // Validate project name format
       if (!/^[a-z0-9-]+$/.test(options.projectName)) {
         throw new Error('Project name must contain only lowercase letters, numbers, and hyphens');
       }
 
-      // Auto-generate display name from slug
       const projectDisplayName = options.projectName
         .split('-')
         .map(word => word.charAt(0).toUpperCase() + word.slice(1))
@@ -75,91 +74,74 @@ async function init(options = {}) {
         projectNameCamel: options.projectName.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())
       };
 
-      console.log(chalk.gray(`Using project name: ${options.projectName}`));
-      console.log(chalk.gray(`Using display name: ${projectDisplayName}`));
-      console.log(chalk.gray(`Using description: ${projectDescription}\n`));
+      logger.detail(`Project name: ${options.projectName}`);
+      logger.detail(`Display name: ${projectDisplayName}`);
+      logger.detail(`Description: ${projectDescription}`);
     } else {
-      // Get user inputs via interactive prompts
       answers = await runInitPrompts();
     }
 
     // Get variant selections (multi-tenancy, B2B vs B2B2C)
     let variantChoices;
-    
-    // If both flags provided, skip variant prompts
+
     if (options.tenancy && options.userModel) {
-      // Validate tenancy value
       if (!['single', 'multi'].includes(options.tenancy)) {
         throw new Error('Invalid --tenancy value. Must be "single" or "multi"');
       }
-      
-      // Validate userModel value
+
       if (!['b2b', 'b2b2c'].includes(options.userModel)) {
         throw new Error('Invalid --user-model value. Must be "b2b" or "b2b2c"');
       }
-      
-      // Convert short flag values to full variant names
+
       const tenancyMap = {
         'single': 'single-tenant',
         'multi': 'multi-tenant'
       };
-      
+
       variantChoices = {
         tenancy: tenancyMap[options.tenancy],
         userModel: options.userModel
       };
-      
-      console.log(chalk.gray(`Using tenancy: ${options.tenancy}`));
-      console.log(chalk.gray(`Using user model: ${options.userModel}\n`));
+
+      logger.detail(`Tenancy: ${options.tenancy}`);
+      logger.detail(`User model: ${options.userModel}`);
     } else {
-      // Run interactive variant prompts
       variantChoices = await runVariantPrompts();
     }
 
-    // Determine which services are needed based on variant choices
-    const requiredServices = [
-      'backend',
-      'admin-portal',
-      'infrastructure',
-      'website'
-    ];
-    
-    // Add customers-portal only if B2B2C mode
+    // Determine which services are needed
+    const requiredServices = ['backend', 'admin-portal', 'infrastructure', 'website'];
+
     if (variantChoices.userModel === 'b2b2c') {
       requiredServices.push('customers-portal');
     }
 
-    // Determine template source (dev mode = local, production = cache)
+    // Determine template source
     let templateRoot;
-    
+
     if (devMode) {
-      // Dev mode: Use local services directory
       templateRoot = path.resolve(__dirname, '../../../services');
-      console.log(chalk.gray(`[DEV MODE] Using local services: ${templateRoot}\n`));
+      logger.detail(`[DEV MODE] Using local services: ${templateRoot}`);
     } else {
-      // Production mode: Use cache
       try {
         templateRoot = await ensureCacheReady(requiredServices);
       } catch (error) {
-        console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+        console.error(chalk.red(`Error: ${error.message}\n`));
         process.exit(1);
       }
     }
 
-    // Generate project with variant selections
-    console.log(chalk.yellow('\n⚙️  Generating project...\n'));
+    // Generate project
+    console.log(chalk.white('\nGenerating project...\n'));
     await generateProject(answers, variantChoices, templateRoot);
 
-    console.log(chalk.green.bold('\n✅ Project generated successfully!\n'));
+    console.log(chalk.green.bold('\nProject created successfully!\n'));
     console.log(chalk.white('Next steps:'));
-    console.log(chalk.white(`  cd ${answers.projectName}`));
-    console.log(chalk.white('  launchframe docker:up    # Start all services\n'));
-    console.log(chalk.gray('Optional:'));
-    console.log(chalk.gray('  # Review and customize infrastructure/.env if needed'));
-    console.log(chalk.gray('  launchframe docker:build # Rebuild images after changes\n'));
+    console.log(chalk.gray(`  cd ${answers.projectName}`));
+    console.log(chalk.gray('  launchframe docker:up\n'));
 
   } catch (error) {
-    console.error(chalk.red('\n❌ Error:'), error.message);
+    console.error(chalk.red('Error:'), error.message);
     process.exit(1);
   }
 }

package/src/generator.js

@@ -1,11 +1,13 @@
 const path = require('path');
 const fs = require('fs-extra');
 const { execSync } = require('child_process');
+const chalk = require('chalk');
 const { replaceVariables } = require('./utils/variable-replacer');
 const { copyDirectory } = require('./utils/file-ops');
 const { generateEnvFile } = require('./utils/env-generator');
 const { processServiceVariant } = require('./utils/variant-processor');
 const { resolveVariantChoices } = require('./services/variant-config');
+const logger = require('./utils/logger');
 
 /**
  * Initialize git repository in a service directory
@@ -14,13 +16,13 @@ const { resolveVariantChoices } = require('./services/variant-config');
  */
 function initGitRepo(servicePath, serviceName) {
   try {
-    console.log(`🔧 Initializing git repository for ${serviceName}...`);
+    logger.detail(`Initializing git repository for ${serviceName}`);
     execSync('git init', { cwd: servicePath, stdio: 'ignore' });
     execSync('git add .', { cwd: servicePath, stdio: 'ignore' });
     execSync('git commit -m "Initial commit"', { cwd: servicePath, stdio: 'ignore' });
-    console.log(`✅ Git repository initialized for ${serviceName}`);
+    logger.detail(`Git initialized: ${serviceName}`);
   } catch (error) {
-    console.warn(`⚠️  Could not initialize git repository for ${serviceName}: ${error.message}`);
+    logger.warn(`Could not initialize git for ${serviceName}: ${error.message}`);
   }
 }
 
@@ -34,12 +36,11 @@ async function generateProject(answers, variantChoices, templateRoot) {
   const { projectName } = answers;
 
   // Define source (template) and destination paths
-  // templateRoot is now passed as parameter (cache or local dev path)
-  const projectRoot = path.resolve(__dirname, '../..'); // For root-level files like .github, README.md
+  const projectRoot = path.resolve(__dirname, '../..'); // For root-level files
   const destinationRoot = path.resolve(process.cwd(), projectName);
 
-  console.log(`📁 Template source: ${templateRoot}`);
-  console.log(`📁 Destination: ${destinationRoot}\n`);
+  logger.detail(`Template source: ${templateRoot}`);
+  logger.detail(`Destination: ${destinationRoot}`);
 
   // Ensure destination directory exists
   await fs.ensureDir(destinationRoot);
@@ -60,8 +61,8 @@ async function generateProject(answers, variantChoices, templateRoot) {
   // Resolve variant choices for all services
   const allServiceVariants = resolveVariantChoices(variantChoices);
 
-  // Step 1: Process backend service with variants
-  console.log('🔧 Processing backend service...');
+  // Process backend
+  console.log(chalk.gray('  Processing backend...'));
   await processServiceVariant(
     'backend',
     allServiceVariants.backend,
@@ -71,11 +72,10 @@ async function generateProject(answers, variantChoices, templateRoot) {
   );
   initGitRepo(path.join(destinationRoot, 'backend'), 'backend');
 
-  // Step 2: Process admin-portal service with variants
-  // Note: admin-portal folder might not exist yet in templates, skip if missing
+  // Process admin-portal
   const adminPortalTemplatePath = path.join(templateRoot, 'admin-portal/base');
   if (await fs.pathExists(adminPortalTemplatePath)) {
-    console.log('🔧 Processing admin-portal service...');
+    console.log(chalk.gray('  Processing admin-portal...'));
     await processServiceVariant(
       'admin-portal',
       allServiceVariants['admin-portal'],
@@ -85,8 +85,8 @@ async function generateProject(answers, variantChoices, templateRoot) {
     );
     initGitRepo(path.join(destinationRoot, 'admin-portal'), 'admin-portal');
   } else {
-    // Fallback: Copy admin-portal directly without variants (for now)
-    console.log('📋 Copying admin-portal service (no variants yet)...');
+    // Fallback: Copy admin-portal directly without variants
+    console.log(chalk.gray('  Copying admin-portal...'));
     const adminPortalSource = path.join(templateRoot, 'admin-portal');
     if (await fs.pathExists(adminPortalSource)) {
       await copyDirectory(adminPortalSource, path.join(destinationRoot, 'admin-portal'));
@@ -95,12 +95,11 @@ async function generateProject(answers, variantChoices, templateRoot) {
     }
   }
 
-  // Step 3: Process customers-portal service (ONLY if B2B2C selected)
+  // Process customers-portal (only if B2B2C)
   if (variantChoices.userModel === 'b2b2c') {
-    // Note: customers-portal folder might not exist yet in templates, skip if missing
     const customersPortalTemplatePath = path.join(templateRoot, 'customers-portal/base');
     if (await fs.pathExists(customersPortalTemplatePath)) {
-      console.log('🔧 Processing customers-portal service...');
+      console.log(chalk.gray('  Processing customers-portal...'));
       await processServiceVariant(
         'customers-portal',
         allServiceVariants['customers-portal'],
@@ -110,8 +109,7 @@ async function generateProject(answers, variantChoices, templateRoot) {
       );
       initGitRepo(path.join(destinationRoot, 'customers-portal'), 'customers-portal');
     } else {
-      // Fallback: Copy customers-portal directly without variants (for now)
-      console.log('📋 Copying customers-portal service (B2B2C mode)...');
+      console.log(chalk.gray('  Copying customers-portal...'));
       const customersPortalSource = path.join(templateRoot, 'customers-portal');
       if (await fs.pathExists(customersPortalSource)) {
         await copyDirectory(customersPortalSource, path.join(destinationRoot, 'customers-portal'));
@@ -120,11 +118,11 @@ async function generateProject(answers, variantChoices, templateRoot) {
       }
     }
   } else {
-    console.log('📋 Skipping customers-portal (B2B mode - admin users only)');
+    logger.detail('Skipping customers-portal (B2B mode)');
   }
 
-  // Step 4: Process infrastructure with variants (docker-compose files conditionally include customers-portal)
-  console.log('🔧 Processing infrastructure...');
+  // Process infrastructure
+  console.log(chalk.gray('  Processing infrastructure...'));
   await processServiceVariant(
     'infrastructure',
     allServiceVariants.infrastructure,
@@ -134,7 +132,8 @@ async function generateProject(answers, variantChoices, templateRoot) {
   );
   initGitRepo(path.join(destinationRoot, 'infrastructure'), 'infrastructure');
 
-  console.log('📋 Copying website...');
+  // Process website
+  console.log(chalk.gray('  Processing website...'));
   await copyDirectory(
     path.join(templateRoot, 'website'),
     path.join(destinationRoot, 'website')
@@ -142,14 +141,9 @@ async function generateProject(answers, variantChoices, templateRoot) {
   await replaceVariables(path.join(destinationRoot, 'website'), variables);
   initGitRepo(path.join(destinationRoot, 'website'), 'website');
 
-  // Step 5: Copy additional files (from project root, not services/)
-  console.log('📋 Copying additional files...');
-  const additionalFiles = [
-    '.github',
-    'README.md',
-    '.gitignore',
-    'LICENSE'
-  ];
+  // Copy additional files
+  logger.detail('Copying additional files...');
+  const additionalFiles = ['.github', 'README.md', '.gitignore', 'LICENSE'];
 
   for (const file of additionalFiles) {
     const sourcePath = path.join(projectRoot, file);
@@ -166,16 +160,15 @@ async function generateProject(answers, variantChoices, templateRoot) {
     }
   }
 
-  // Step 6: Generate .env file with localhost defaults
-  console.log('\n🔐 Generating .env file with secure secrets...');
+  // Generate .env file
+  console.log(chalk.gray('  Generating environment file...'));
   const { envPath } = await generateEnvFile(destinationRoot, answers);
-  console.log(`✅ Environment file created: ${envPath}`);
+  logger.detail(`Environment file: ${envPath}`);
 
-  // Step 7: Create .launchframe marker file with variant metadata
-  console.log('📝 Creating LaunchFrame marker file...');
+  // Create .launchframe marker file
+  logger.detail('Creating project marker file...');
   const markerPath = path.join(destinationRoot, '.launchframe');
 
-  // Determine which services were installed
   const installedServices = ['backend', 'admin-portal', 'infrastructure', 'website'];
   if (variantChoices.userModel === 'b2b2c') {
     installedServices.push('customers-portal');
@@ -188,12 +181,9 @@ async function generateProject(answers, variantChoices, templateRoot) {
     projectDisplayName: answers.projectDisplayName,
     deployConfigured: false,
     installedServices: installedServices,
-    // Store variant choices for future reference
     variants: variantChoices
   };
   await fs.writeJson(markerPath, markerContent, { spaces: 2 });
-
-  console.log('✅ Base project generated with variants applied');
 }
 
 module.exports = { generateProject };

package/src/index.js

@@ -2,6 +2,7 @@
 
 const chalk = require('chalk');
 const { isLaunchFrameProject } = require('./utils/project-helpers');
+const logger = require('./utils/logger');
 
 // Import commands
 const { init } = require('./commands/init');
@@ -9,6 +10,7 @@ const { deployConfigure } = require('./commands/deploy-configure');
 const { deploySetEnv } = require('./commands/deploy-set-env');
 const { deployInit } = require('./commands/deploy-init');
 const { deployUp } = require('./commands/deploy-up');
+const { deployBuild } = require('./commands/deploy-build');
 const { waitlistDeploy } = require('./commands/waitlist-deploy');
 const { waitlistUp } = require('./commands/waitlist-up');
 const { waitlistDown } = require('./commands/waitlist-down');
@@ -65,6 +67,11 @@ async function main() {
   const inProject = isLaunchFrameProject();
   const flags = parseFlags(args);
 
+  // Set verbose mode globally
+  if (flags.verbose || flags.v) {
+    logger.setVerbose(true);
+  }
+
   // No command provided
   if (!command) {
     help();
@@ -92,6 +99,9 @@ async function main() {
     case 'deploy:up':
       await deployUp();
       break;
+    case 'deploy:build':
+      await deployBuild(args[1]); // Optional service name
+      break;
     case 'waitlist:deploy':
       await waitlistDeploy();
       break;
@@ -156,7 +166,7 @@ async function main() {
       help();
       break;
     default:
-      console.error(chalk.red(`\n❌ Unknown command: ${command}\n`));
+      console.error(chalk.red(`\nUnknown command: ${command}\n`));
       help();
       process.exit(1);
   }

package/src/utils/docker-helper.js

@@ -254,6 +254,7 @@ async function buildWaitlistImage(projectRoot, projectName, githubOrg) {
 module.exports = {
   checkDockerRunning,
   loginToGHCR,
+  buildAndPushImage,
   buildFullAppImages,
   buildWaitlistImage
 };

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/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'));
   }

package/src/utils/variant-processor.js

@@ -15,6 +15,7 @@ const { replaceVariables } = require('./variable-replacer');
 const { getVariantConfig, getVariantsToApply } = require('../services/variant-config');
 const fs = require('fs-extra');
 const path = require('path');
+const logger = require('./logger');
 
 /**
  * Process service with variant modifications
@@ -32,7 +33,7 @@ async function processServiceVariant(
   replacements,
   templateRoot
 ) {
-  console.log(`\n📦 Processing ${serviceName} with choices:`, variantChoices);
+  logger.detail(`Processing ${serviceName} with choices: ${JSON.stringify(variantChoices)}`, 2);
 
   const serviceConfig = getVariantConfig(serviceName);
   if (!serviceConfig) {
@@ -41,33 +42,33 @@ async function processServiceVariant(
 
   const basePath = path.join(templateRoot, serviceConfig.base);
 
-  // Step 1: Copy base template (minimal - B2B + single-tenant)
-  console.log(`  📁 Copying base template from ${serviceConfig.base}`);
+  // Copy base template
+  logger.detail(`Copying base template from ${serviceConfig.base}`, 2);
   await copyDirectory(basePath, destination, {
     exclude: ['node_modules', '.git', 'dist', '.env']
   });
 
-  // Step 2: Determine which variants to apply
+  // Determine which variants to apply
   const variantsToApply = getVariantsToApply(variantChoices);
 
   if (variantsToApply.length === 0) {
-    console.log(`  ✅ Using base template (no variants to apply)`);
+    logger.detail('Using base template (no variants)', 2);
   } else {
-    console.log(`  🔧 Applying variants: ${variantsToApply.join(', ')}`);
+    logger.detail(`Applying variants: ${variantsToApply.join(', ')}`, 2);
   }
 
-  // Step 3: Apply each variant
+  // Apply each variant
   for (const variantName of variantsToApply) {
     const variantConfig = serviceConfig.variants[variantName];
 
     if (!variantConfig) {
-      console.warn(`  ⚠️  No configuration found for variant: ${variantName}, skipping`);
+      logger.warn(`No configuration found for variant: ${variantName}, skipping`);
       continue;
     }
 
-    console.log(`\n  ✨ Applying ${variantName} variant:`);
+    logger.detail(`Applying ${variantName} variant`, 2);
 
-    // Step 3a: Copy variant FILES
+    // Copy variant FILES
     await copyVariantFiles(
       variantName,
       variantConfig.files || [],
@@ -76,7 +77,7 @@ async function processServiceVariant(
       templateRoot
     );
 
-    // Step 3b: Insert variant SECTIONS
+    // Insert variant SECTIONS
     await insertVariantSections(
       variantName,
       variantConfig.sections || {},
@@ -86,15 +87,15 @@ async function processServiceVariant(
     );
   }
 
-  // Step 4: Clean up unused section markers
-  console.log(`\n  🧹 Cleaning up unused section markers`);
+  // Clean up unused section markers
+  logger.detail('Cleaning up unused section markers', 2);
   await cleanupSectionMarkers(serviceName, serviceConfig, variantsToApply, destination);
 
-  // Step 5: Replace template variables ({{PROJECT_NAME}}, etc.)
-  console.log(`\n  🔤 Replacing template variables`);
+  // Replace template variables
+  logger.detail('Replacing template variables', 2);
   await replaceVariables(destination, replacements);
 
-  console.log(`  ✅ ${serviceName} processing complete\n`);
+  logger.detail(`${serviceName} complete`, 2);
 }
 
 /**
@@ -110,7 +111,7 @@ async function cleanupSectionMarkers(serviceName, serviceConfig, appliedVariants
   const unappliedVariants = allVariants.filter(v => !appliedVariants.includes(v));
 
   if (unappliedVariants.length === 0) {
-    console.log(`    ✓ No unused section markers to clean`);
+    logger.detail('No unused section markers to clean', 3);
     return;
   }
 
@@ -146,8 +147,6 @@ async function cleanupSectionMarkers(serviceName, serviceConfig, appliedVariants
       // Remove each unused section marker (keep content, remove only marker comments)
       for (const sectionName of sectionNames) {
         // Try all comment formats (// for JS/TS, {/* */} for JSX, # for YAML/Shell)
-        // Capture: START marker, content, END marker - replace with just content
-        // Include leading whitespace before markers to prevent indentation issues
         const slashPattern = new RegExp(
           `^[ \\t]*\\/\\/ ${sectionName}_START\\n([\\s\\S]*?)^[ \\t]*\\/\\/ ${sectionName}_END\\n?`,
           'gm'
@@ -185,14 +184,14 @@ async function cleanupSectionMarkers(serviceName, serviceConfig, appliedVariants
         totalCleaned++;
       }
     } catch (error) {
-      console.warn(`    ⚠️  Could not clean markers in ${filePath}:`, error.message);
+      logger.warn(`Could not clean markers in ${filePath}: ${error.message}`);
     }
   }
 
   if (totalCleaned > 0) {
-    console.log(`    ✓ Cleaned up section markers in ${totalCleaned} file(s)`);
+    logger.detail(`Cleaned section markers in ${totalCleaned} file(s)`, 3);
   } else {
-    console.log(`    ✓ No unused section markers found`);
+    logger.detail('No unused section markers found', 3);
   }
 }
 
@@ -206,11 +205,11 @@ async function cleanupSectionMarkers(serviceName, serviceConfig, appliedVariants
  */
 async function copyVariantFiles(variantName, files, filesDir, destination, templateRoot) {
   if (!files || files.length === 0) {
-    console.log(`    📂 No files to copy for ${variantName}`);
+    logger.detail(`No files to copy for ${variantName}`, 3);
     return;
   }
 
-  console.log(`    📂 Copying ${files.length} file(s)/folder(s):`);
+  logger.detail(`Copying ${files.length} file(s) for ${variantName}`, 3);
 
   const variantFilesPath = path.join(templateRoot, filesDir, variantName);
 
@@ -219,22 +218,18 @@ async function copyVariantFiles(variantName, files, filesDir, destination, templ
     const destPath = path.join(destination, filePath);
 
     try {
-      // Check if source exists
       if (!await fs.pathExists(sourcePath)) {
-        console.warn(`      ⚠️  Source not found: ${filePath}, skipping`);
+        logger.warn(`Source not found: ${filePath}, skipping`);
         continue;
       }
 
-      // Create parent directory if needed
       await fs.ensureDir(path.dirname(destPath));
-
-      // Copy file or directory
       await fs.copy(sourcePath, destPath, { overwrite: true });
 
       const isDir = (await fs.stat(sourcePath)).isDirectory();
-      console.log(`      ✓ Copied ${isDir ? 'folder' : 'file'}: ${filePath}`);
+      logger.detail(`Copied ${isDir ? 'folder' : 'file'}: ${filePath}`, 4);
     } catch (error) {
-      console.warn(`      ⚠️  Could not copy ${filePath}:`, error.message);
+      logger.warn(`Could not copy ${filePath}: ${error.message}`);
     }
   }
 }
@@ -249,45 +244,41 @@ async function copyVariantFiles(variantName, files, filesDir, destination, templ
  */
 async function insertVariantSections(variantName, sections, sectionsDir, destination, templateRoot) {
   if (!sections || Object.keys(sections).length === 0) {
-    console.log(`    ✏️  No sections to insert for ${variantName}`);
+    logger.detail(`No sections to insert for ${variantName}`, 3);
     return;
   }
 
   const sectionFiles = Object.keys(sections);
-  console.log(`    ✏️  Inserting sections into ${sectionFiles.length} file(s):`);
+  logger.detail(`Inserting sections into ${sectionFiles.length} file(s)`, 3);
 
   const variantSectionsPath = path.join(templateRoot, sectionsDir, variantName);
 
   for (const [filePath, sectionNames] of Object.entries(sections)) {
     const targetFilePath = path.join(destination, filePath);
 
-    // Check if target file exists
     if (!await fs.pathExists(targetFilePath)) {
-      console.warn(`      ⚠️  Target file not found: ${filePath}, skipping sections`);
+      logger.warn(`Target file not found: ${filePath}, skipping sections`);
       continue;
     }
 
-    console.log(`      📝 ${filePath}:`);
+    logger.detail(`Processing ${filePath}`, 4);
 
     for (const sectionName of sectionNames) {
       try {
-        // Read section content from file
         const fileName = path.basename(filePath);
         const sectionFileName = `${fileName}.${sectionName}`;
         const sectionFilePath = path.join(variantSectionsPath, sectionFileName);
 
         if (!await fs.pathExists(sectionFilePath)) {
-          console.warn(`        ⚠️  Section file not found: ${sectionFileName}, skipping`);
+          logger.warn(`Section file not found: ${sectionFileName}, skipping`);
           continue;
         }
 
         const sectionContent = await fs.readFile(sectionFilePath, 'utf-8');
-
-        // Insert section content into target file
         await replaceSection(targetFilePath, sectionName, sectionContent);
-        console.log(`        ✓ Inserted [${sectionName}]`);
+        logger.detail(`Inserted [${sectionName}]`, 5);
       } catch (error) {
-        console.warn(`        ⚠️  Could not insert section ${sectionName}:`, error.message);
+        logger.warn(`Could not insert section ${sectionName}: ${error.message}`);
       }
     }
   }