@launchframe/cli 1.0.0-beta.3 → 1.0.0-beta.30

package/src/commands/dev-add-user.js

@@ -0,0 +1,165 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const chalk = require('chalk');
+const bcrypt = require('bcryptjs');
+const { spawnSync } = require('child_process');
+const { requireProject, getProjectConfig } = require('../utils/project-helpers');
+
+const FIRST_NAMES = [
+  'Alice', 'Bob', 'Carol', 'David', 'Eve', 'Frank', 'Grace', 'Henry',
+  'Iris', 'Jack', 'Karen', 'Leo', 'Mia', 'Nathan', 'Olivia'
+];
+
+const LAST_NAMES = [
+  'Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller',
+  'Davis', 'Wilson', 'Moore', 'Taylor', 'Anderson', 'Thomas', 'Jackson', 'White'
+];
+
+function randomElement(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function generateDummyUser() {
+  const firstName = randomElement(FIRST_NAMES);
+  const lastName = randomElement(LAST_NAMES);
+  const suffix = String(Math.floor(1000 + Math.random() * 9000));
+  const email = `${firstName.toLowerCase()}.${lastName.toLowerCase()}${suffix}@gmail.com`;
+  return { firstName, lastName, name: `${firstName} ${lastName}`, email, suffix };
+}
+
+function checkEmailExists(infrastructurePath, email) {
+  const composeArgs = [
+    'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+    'exec', '-T', 'database', 'sh', '-c', 'psql -U $POSTGRES_USER $POSTGRES_DB -t -c "SELECT COUNT(*) FROM users WHERE email = \'__EMAIL__\'"'
+      .replace('__EMAIL__', email.replace(/'/g, "''"))
+  ];
+
+  const result = spawnSync('docker', composeArgs, { cwd: infrastructurePath, encoding: 'utf8' });
+  if (result.status !== 0) return false;
+  const count = parseInt((result.stdout || '').trim(), 10);
+  return count > 0;
+}
+
+async function devAddUser() {
+  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 database container is running
+  const psResult = spawnSync(
+    'docker',
+    [
+      'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+      'ps', '--status', 'running', '-q', 'database'
+    ],
+    { cwd: infrastructurePath, encoding: 'utf8' }
+  );
+
+  if (!psResult.stdout || psResult.stdout.trim() === '') {
+    console.error(chalk.red('\n❌ Database container is not running.'));
+    console.log(chalk.gray('Start local services first:'));
+    console.log(chalk.white('  launchframe docker:up\n'));
+    process.exit(1);
+  }
+
+  // Generate user with unique email (up to 5 attempts)
+  let user = null;
+  for (let attempt = 0; attempt < 5; attempt++) {
+    const candidate = generateDummyUser();
+    if (!checkEmailExists(infrastructurePath, candidate.email)) {
+      user = candidate;
+      break;
+    }
+  }
+
+  if (!user) {
+    console.error(chalk.red('\n❌ Could not generate a unique email after 5 attempts.'));
+    process.exit(1);
+  }
+
+  const config = getProjectConfig();
+  const isMultiTenant = config.variants?.tenancy === 'multi-tenant';
+
+  const passwordHash = await bcrypt.hash('test123', 10);
+  const accountId = crypto.randomUUID();
+
+  const projectTitle = `Demo Project`;
+  const projectSlug = `demo-project-${user.suffix}`;
+
+  const projectInsert = isMultiTenant ? `
+  INSERT INTO projects (user_id, title, slug, description, created_at, updated_at)
+  VALUES (
+    new_user_id,
+    '${projectTitle}',
+    '${projectSlug}',
+    'Auto-generated demo project',
+    NOW(),
+    NOW()
+  );` : '';
+
+  const sqlScript = `
+DO $$
+DECLARE
+  new_user_id INT;
+BEGIN
+  INSERT INTO users (email, name, role, email_verified, is_active, created_at, updated_at)
+  VALUES (
+    '${user.email.replace(/'/g, "''")}',
+    '${user.name.replace(/'/g, "''")}',
+    'business_user',
+    true,
+    true,
+    NOW(),
+    NOW()
+  )
+  RETURNING id INTO new_user_id;
+
+  INSERT INTO accounts (id, user_id, account_id, provider_id, password, created_at, updated_at)
+  VALUES (
+    '${accountId}',
+    new_user_id,
+    new_user_id::text,
+    'credential',
+    '${passwordHash.replace(/'/g, "''")}',
+    NOW(),
+    NOW()
+  );
+${projectInsert}
+END $$;
+`;
+
+  const execResult = spawnSync(
+    'docker',
+    [
+      'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+      'exec', '-T', 'database', 'sh', '-c', 'psql -v ON_ERROR_STOP=1 -U $POSTGRES_USER $POSTGRES_DB'
+    ],
+    { cwd: infrastructurePath, input: sqlScript, encoding: 'utf8' }
+  );
+
+  if (execResult.status !== 0) {
+    console.error(chalk.red('\n❌ Failed to insert user into database.'));
+    if (execResult.stderr) {
+      console.error(chalk.gray(execResult.stderr));
+    }
+    process.exit(1);
+  }
+
+  console.log(chalk.green('\n✅ User created!'));
+  console.log(chalk.gray(`   Name:     ${user.name}`));
+  console.log(chalk.gray(`   Email:    ${user.email}`));
+  console.log(chalk.gray(`   Password: test123`));
+  if (isMultiTenant) {
+    console.log(chalk.gray(`   Project:  ${projectTitle} (${projectSlug})`));
+  }
+  console.log();
+}
+
+module.exports = { devAddUser };

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/help.js

@@ -7,16 +7,20 @@ 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)\n'));
 
     // Conditionally show waitlist commands
     if (isWaitlistInstalled()) {
@@ -33,6 +37,14 @@ 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'));
@@ -40,11 +52,17 @@ function help() {
     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 modules'));
+    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\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 +88,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 modules'));
+    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

@@ -4,15 +4,10 @@ const chalk = require('chalk');
 const { runInitPrompts, runVariantPrompts } = require('../prompts');
 const { generateProject } = require('../generator');
 const { checkGitHubAccess, showAccessDeniedMessage } = require('../utils/github-access');
-const { ensureCacheReady } = require('../utils/module-cache');
-
-/**
- * Check if current directory is a LaunchFrame project
- */
-function isLaunchFrameProject() {
-  const markerPath = path.join(process.cwd(), '.launchframe');
-  return fs.existsSync(markerPath);
-}
+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)
@@ -30,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);
   }
@@ -61,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))
@@ -82,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 modules are needed based on variant choices
-    const requiredModules = [
-      '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') {
-      requiredModules.push('customers-portal');
+      requiredServices.push('customers-portal');
     }
 
-    // Determine template source (dev mode = local, production = cache)
+    // Determine template source
     let templateRoot;
-    
+
     if (devMode) {
-      // Dev mode: Use local modules directory
-      templateRoot = path.resolve(__dirname, '../../../modules');
-      console.log(chalk.gray(`[DEV MODE] Using local modules: ${templateRoot}\n`));
+      templateRoot = path.resolve(__dirname, '../../../services');
+      logger.detail(`[DEV MODE] Using local services: ${templateRoot}`);
     } else {
-      // Production mode: Use cache
       try {
-        templateRoot = await ensureCacheReady(requiredModules);
+        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 };