@launchframe/cli 1.0.0-beta.9 → 1.0.0

package/src/commands/dev-queue.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { spawnSync, spawn } = require('child_process');
+const { requireProject } = require('../utils/project-helpers');
+
+async function devQueue() {
+  requireProject();
+
+  const infrastructurePath = path.join(process.cwd(), 'infrastructure');
+
+  if (!fs.existsSync(infrastructurePath)) {
+    console.error(chalk.red('\n❌ Error: infrastructure/ directory not found'));
+    console.log(chalk.gray('Make sure you are in the root of your LaunchFrame project.\n'));
+    process.exit(1);
+  }
+
+  // Check backend container is running
+  const psResult = spawnSync(
+    'docker',
+    [
+      'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+      'ps', '--status', 'running', '-q', 'backend'
+    ],
+    { cwd: infrastructurePath, encoding: 'utf8' }
+  );
+
+  if (!psResult.stdout || psResult.stdout.trim() === '') {
+    console.error(chalk.red('\n❌ Backend container is not running.'));
+    console.log(chalk.gray('Start local services first:'));
+    console.log(chalk.white('  launchframe docker:up\n'));
+    process.exit(1);
+  }
+
+  // Read BULL_ADMIN_TOKEN from backend container
+  const tokenResult = spawnSync(
+    'docker',
+    [
+      'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+      'exec', '-T', 'backend', 'sh', '-c', 'echo $BULL_ADMIN_TOKEN'
+    ],
+    { cwd: infrastructurePath, encoding: 'utf8' }
+  );
+
+  const token = (tokenResult.stdout || '').trim();
+
+  if (!token) {
+    console.error(chalk.red('\n❌ Could not read BULL_ADMIN_TOKEN from backend container.'));
+    console.log(chalk.gray('Make sure the backend is fully started and BULL_ADMIN_TOKEN is set in your .env\n'));
+    process.exit(1);
+  }
+
+  // Read BACKEND_PORT from backend container (fallback to 4000)
+  const portResult = spawnSync(
+    'docker',
+    [
+      'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+      'exec', '-T', 'backend', 'sh', '-c', 'echo $BACKEND_PORT'
+    ],
+    { cwd: infrastructurePath, encoding: 'utf8' }
+  );
+
+  const port = (portResult.stdout || '').trim() || '4000';
+
+  const url = `http://localhost:${port}/admin/queues/${token}`;
+
+  console.log(chalk.green('\n Opening Bull queue dashboard...'));
+  console.log(chalk.gray(`  ${url}\n`));
+
+  // Open URL with platform-appropriate command
+  const platform = process.platform;
+  let openCmd;
+  if (platform === 'darwin') {
+    openCmd = 'open';
+  } else if (platform === 'win32') {
+    openCmd = 'start';
+  } else {
+    openCmd = 'xdg-open';
+  }
+
+  const child = spawn(openCmd, [url], { detached: true, stdio: 'ignore' });
+  child.unref();
+}
+
+module.exports = { devQueue };

package/src/commands/docker-build.js

@@ -6,8 +6,9 @@ const { requireProject } = require('../utils/project-helpers');
 
 /**
  * Build Docker images for the project
+ * @param {string} [serviceName] - Optional service to build (builds all if omitted)
  */
-async function dockerBuild() {
+async function dockerBuild(serviceName) {
   requireProject();
 
   const infrastructurePath = path.join(process.cwd(), 'infrastructure');
@@ -18,11 +19,11 @@ async function dockerBuild() {
     process.exit(1);
   }
 
-  console.log(chalk.blue.bold('\n🔨 Building Docker Images\n'));
-  console.log(chalk.gray('This will build all service images for local development...\n'));
+  const target = serviceName ? `${serviceName} service` : 'all services';
+  console.log(chalk.blue.bold(`\n🔨 Building Docker Images (${target})\n`));
 
   try {
-    const buildCommand = 'docker-compose -f docker-compose.yml -f docker-compose.dev.yml build';
+    const buildCommand = `docker-compose -f docker-compose.yml -f docker-compose.dev.yml build${serviceName ? ` ${serviceName}` : ''}`;
 
     console.log(chalk.gray(`Running: ${buildCommand}\n`));
 
@@ -32,8 +33,10 @@ async function dockerBuild() {
     });
 
     console.log(chalk.green.bold('\n✅ Docker images built successfully!\n'));
-    console.log(chalk.white('Next steps:'));
-    console.log(chalk.gray('  launchframe docker:up    # Start all services\n'));
+    if (!serviceName) {
+      console.log(chalk.white('Next steps:'));
+      console.log(chalk.gray('  launchframe docker:up    # Start all services\n'));
+    }
 
   } catch (error) {
     console.error(chalk.red('\n❌ Error during build:'), error.message);

package/src/commands/help.js

@@ -7,16 +7,21 @@ 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'));
+  console.log(chalk.gray('  --version               Show version number\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)'));
+    console.log(chalk.gray('  deploy:sync-features          Sync local features and plan assignments to production\n'));
 
     // Conditionally show waitlist commands
     if (isWaitlistInstalled()) {
@@ -33,18 +38,37 @@ function help() {
     console.log(chalk.gray('  docker:logs [service]       View logs from all services or specific service'));
     console.log(chalk.gray('  docker:destroy              Remove all resources (containers, volumes, images)'));
     console.log(chalk.gray('    --force, -f               Skip confirmation prompt\n'));
+    console.log(chalk.white('Database Migrations:'));
+    console.log(chalk.gray('  migration:run              Run pending database migrations'));
+    console.log(chalk.gray('  migration:create           Create new database migration'));
+    console.log(chalk.gray('  migration:revert           Revert last database migration\n'));
+    console.log(chalk.white('Database:'));
+    console.log(chalk.gray('  database:console           Open a PostgreSQL console (local)'));
+    console.log(chalk.gray('    --remote                 Connect to the production database\n'));
+
     console.log(chalk.white('Service Management:'));
     console.log(chalk.gray('  service:add <name>     Add an optional service to your project'));
     console.log(chalk.gray('  service:list           List available services'));
     console.log(chalk.gray('  service:remove <name>  Remove installed service\n'));
+    console.log(chalk.white('Module Management:'));
+    console.log(chalk.gray('  module:add <name>      Add a module to your project'));
+    console.log(chalk.gray('  module:list            List available modules\n'));
     console.log(chalk.white('Available Services:'));
     console.log(chalk.gray('  waitlist          Coming soon page with email collection\n'));
     console.log(chalk.white('Cache Management:'));
     console.log(chalk.gray('  cache:info        Show cache location, size, and cached services'));
     console.log(chalk.gray('  cache:update      Force update cache to latest version'));
     console.log(chalk.gray('  cache:clear       Delete cache (re-download on next use)\n'));
+    console.log(chalk.white('Dev Helpers:'));
+    console.log(chalk.gray('  dev:add-user      Generate and insert a random test user into the local database'));
+    console.log(chalk.gray('  dev:queue         Open the Bull queue dashboard in the browser'));
+    console.log(chalk.gray('  dev:logo          Generate and inject favicon/logo assets from logo.svg'));
+    console.log(chalk.gray('  dev:npm-install <service> [packages...]  Install npm packages using node:20-alpine\n'));
     console.log(chalk.white('Other commands:'));
     console.log(chalk.gray('  doctor            Check project health and configuration'));
+    console.log(chalk.gray('  telemetry         Show telemetry status'));
+    console.log(chalk.gray('    --enable          Enable anonymous usage data collection'));
+    console.log(chalk.gray('    --disable         Disable anonymous usage data collection'));
     console.log(chalk.gray('  help              Show this help message\n'));
     console.log(chalk.white('Examples:'));
     console.log(chalk.gray('  # Deploy full app to production'));
@@ -70,19 +94,19 @@ function help() {
   } else {
     console.log(chalk.white('Available commands:'));
     console.log(chalk.gray('  init                        Initialize a new LaunchFrame project'));
-    console.log(chalk.gray('    --project-name <name>     Project name (skips prompt)'));
-    console.log(chalk.gray('    --tenancy <single|multi>  Tenancy model (skips prompt)'));
-    console.log(chalk.gray('    --user-model <b2b|b2b2c>  User model (skips prompt)'));
     console.log(chalk.gray('  help                        Show this help message\n'));
+    console.log(chalk.white('Telemetry:'));
+    console.log(chalk.gray('  telemetry                   Show telemetry status'));
+    console.log(chalk.gray('    --enable                  Enable anonymous usage data collection'));
+    console.log(chalk.gray('    --disable                 Disable anonymous usage data collection\n'));
     console.log(chalk.white('Cache Management:'));
     console.log(chalk.gray('  cache:info        Show cache location, size, and cached services'));
     console.log(chalk.gray('  cache:update      Force update cache to latest version'));
     console.log(chalk.gray('  cache:clear       Delete cache (re-download on next use)\n'));
     console.log(chalk.white('Examples:'));
-    console.log(chalk.gray('  # Interactive mode'));
     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,8 @@ 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');
+const { trackEvent } = require('../utils/telemetry');
 
 /**
  * Check if running in development mode (local) vs production (npm install)
@@ -23,28 +25,30 @@ 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
+      trackEvent('command_executed', { command: 'init', success: false, error_message: 'access_denied' });
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      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 +58,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 +77,81 @@ 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'));
+    trackEvent('command_executed', {
+      command: 'init',
+      success: true,
+      tenancy: variantChoices.tenancy,
+      user_model: variantChoices.userModel
+    });
+
+    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/commands/migration-create.js

@@ -0,0 +1,40 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { execSync } = require('child_process');
+const { requireProject } = require('../utils/project-helpers');
+
+async function migrateCreate() {
+  requireProject();
+
+  const infrastructurePath = path.join(process.cwd(), 'infrastructure');
+
+  if (!fs.existsSync(infrastructurePath)) {
+    console.error(chalk.red('\n❌ Error: infrastructure/ directory not found'));
+    console.log(chalk.gray('Make sure you are in the root of your LaunchFrame project.\n'));
+    process.exit(1);
+  }
+
+  const migrationName = process.argv[3];
+
+  if (!migrationName) {
+    console.error(chalk.red('\n❌ Error: migration name is required'));
+    console.log(chalk.gray('Usage: launchframe migrate:create <name>\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue.bold(`\n🗄️  Creating migration: ${migrationName}\n`));
+
+  try {
+    execSync(`docker compose -f docker-compose.yml -f docker-compose.dev.yml exec backend npm run migration:create -- ${migrationName}`, {
+      cwd: infrastructurePath,
+      stdio: 'inherit'
+    });
+    console.log(chalk.green.bold('\n✅ Migration created successfully.\n'));
+  } catch (error) {
+    console.error(chalk.red('\n❌ Error creating migration:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { migrateCreate };

package/src/commands/migration-revert.js

@@ -0,0 +1,32 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { execSync } = require('child_process');
+const { requireProject } = require('../utils/project-helpers');
+
+async function migrateRevert() {
+  requireProject();
+
+  const infrastructurePath = path.join(process.cwd(), 'infrastructure');
+
+  if (!fs.existsSync(infrastructurePath)) {
+    console.error(chalk.red('\n❌ Error: infrastructure/ directory not found'));
+    console.log(chalk.gray('Make sure you are in the root of your LaunchFrame project.\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue.bold('\n🗄️  Reverting last database migration\n'));
+
+  try {
+    execSync('docker compose -f docker-compose.yml -f docker-compose.dev.yml exec backend npm run migration:revert', {
+      cwd: infrastructurePath,
+      stdio: 'inherit'
+    });
+    console.log(chalk.green.bold('\n✅ Migration reverted successfully.\n'));
+  } catch (error) {
+    console.error(chalk.red('\n❌ Error reverting migration:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { migrateRevert };

package/src/commands/migration-run.js

@@ -0,0 +1,32 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { execSync } = require('child_process');
+const { requireProject } = require('../utils/project-helpers');
+
+async function migrateRun() {
+  requireProject();
+
+  const infrastructurePath = path.join(process.cwd(), 'infrastructure');
+
+  if (!fs.existsSync(infrastructurePath)) {
+    console.error(chalk.red('\n❌ Error: infrastructure/ directory not found'));
+    console.log(chalk.gray('Make sure you are in the root of your LaunchFrame project.\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue.bold('\n🗄️  Running database migrations\n'));
+
+  try {
+    execSync('docker compose -f docker-compose.yml -f docker-compose.dev.yml exec backend npm run migration:run', {
+      cwd: infrastructurePath,
+      stdio: 'inherit'
+    });
+    console.log(chalk.green.bold('\n✅ Migrations completed successfully.\n'));
+  } catch (error) {
+    console.error(chalk.red('\n❌ Error running migrations:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { migrateRun };

package/src/commands/module.js

@@ -0,0 +1,146 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { MODULE_REGISTRY } = require('../services/module-registry');
+const { MODULE_CONFIG } = require('../services/module-config');
+const { installModule } = require('../utils/module-installer');
+const { dockerBuild } = require('./docker-build');
+const { dockerDown } = require('./docker-down');
+const { dockerUp } = require('./docker-up');
+const {
+  requireProject,
+  getProjectConfig,
+  getInstalledModules,
+  isModuleInstalled,
+  addInstalledModule
+} = require('../utils/project-helpers');
+
+// Core services that can't be added via service:add
+const CORE_SERVICES = ['backend', 'admin-portal', 'infrastructure', 'website'];
+
+async function moduleList() {
+  requireProject();
+
+  const installedModules = getInstalledModules();
+  const modules = Object.values(MODULE_REGISTRY);
+
+  console.log(chalk.blue('\nAvailable Modules:\n'));
+
+  modules.forEach(mod => {
+    const installed = installedModules.includes(mod.name);
+    const status = installed ? chalk.green(' [installed]') : '';
+    console.log(chalk.green(`  ${mod.name}`) + status);
+    console.log(`    ${mod.description}`);
+    console.log(`    Affects services: ${mod.services.join(', ')}`);
+    console.log('');
+  });
+
+  console.log('To install a module:');
+  console.log('  launchframe module:add <module-name>');
+}
+
+async function moduleAdd(moduleName) {
+  requireProject();
+
+  // Validate module exists in registry
+  const mod = MODULE_REGISTRY[moduleName];
+  if (!mod) {
+    console.error(chalk.red(`Error: Module "${moduleName}" not found`));
+    console.log('\nAvailable modules:');
+    Object.keys(MODULE_REGISTRY).forEach(key => {
+      console.log(`  - ${key}`);
+    });
+    process.exit(1);
+  }
+
+  // Check not already installed
+  if (isModuleInstalled(moduleName)) {
+    console.error(chalk.red(`Error: Module "${moduleName}" is already installed`));
+    process.exit(1);
+  }
+
+  // Validate required services
+  const config = getProjectConfig();
+  const installedServices = config.installedServices || [];
+  const errors = [];
+
+  for (const service of mod.services) {
+    // Check if service is in installedServices
+    if (!installedServices.includes(service)) {
+      if (CORE_SERVICES.includes(service)) {
+        errors.push(`Core service '${service}' is missing from your project`);
+      } else {
+        errors.push(`Service '${service}' is not installed. Install it first with: launchframe service:add ${service}`);
+      }
+      continue;
+    }
+
+    // Check if service directory exists on disk
+    const serviceDir = path.join(process.cwd(), service);
+    if (!fs.existsSync(serviceDir)) {
+      errors.push(`Service '${service}' directory not found. Your project structure may be corrupted.`);
+    }
+  }
+
+  if (errors.length > 0) {
+    console.error(chalk.red(`\nCannot install module "${moduleName}":\n`));
+    errors.forEach(err => {
+      console.error(chalk.red(`  - ${err}`));
+    });
+    process.exit(1);
+  }
+
+  // Display module info and confirm
+  console.log(chalk.green(`\n${mod.displayName}`));
+  console.log(mod.description);
+  console.log(`Affects services: ${mod.services.join(', ')}`);
+
+  const { confirmed } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirmed',
+    message: `Add module "${mod.displayName}" to your project?`,
+    default: true
+  }]);
+
+  if (!confirmed) {
+    console.log('Installation cancelled');
+    process.exit(0);
+  }
+
+  const affectedServices = [...new Set(Object.keys(MODULE_CONFIG[moduleName] || {}))].filter(s => s !== 'infrastructure');
+  const infrastructurePath = path.join(process.cwd(), 'infrastructure');
+  const composeCmd = 'docker-compose -f docker-compose.yml -f docker-compose.dev.yml';
+
+  // Bring the stack down and remove affected containers before touching files
+  await dockerDown();
+  for (const service of affectedServices) {
+    try {
+      execSync(`${composeCmd} rm -f ${service}`, { cwd: infrastructurePath, stdio: 'inherit' });
+    } catch (_) {
+      // Container may already be gone — that's fine
+    }
+  }
+
+  // Register module in .launchframe
+  addInstalledModule(moduleName);
+
+  // Install module files, sections, and dependencies
+  const moduleServiceConfig = MODULE_CONFIG[moduleName];
+  if (moduleServiceConfig) {
+    await installModule(moduleName, moduleServiceConfig);
+  }
+
+  console.log(chalk.green(`\n✓ Module "${moduleName}" installed successfully!`));
+
+  // Rebuild affected containers
+  for (const service of affectedServices) {
+    await dockerBuild(service);
+  }
+
+  // Restart the full stack in watch mode
+  await dockerUp();
+}
+
+module.exports = { moduleAdd, moduleList };

package/src/commands/waitlist-deploy.js

@@ -205,6 +205,7 @@ async function waitlistDeploy() {
     verifySpinner.succeed('Services verified');
     console.log(chalk.gray('\n' + psOutput));
   } catch (error) {
+    console.error(chalk.yellow(`\n⚠️  Error: ${error.message}\n`));
     verifySpinner.warn('Could not verify services');
   }