@launchframe/cli 1.0.0-beta.9 → 1.0.1

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/docker-logs.js

@@ -1,13 +1,17 @@
 const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
 const { requireProject } = require('../utils/project-helpers');
 
 /**
  * View logs from Docker services
+ * @param {string} service - Optional service name to filter logs
+ * @param {Object} flags - Optional flags
+ * @param {boolean} flags['no-follow'] - Snapshot mode: print lines and exit (non-interactive)
+ * @param {number} flags.tail - Number of lines to show (default 100, only used with --no-follow)
  */
-async function dockerLogs() {
+async function dockerLogs(service, flags = {}) {
   requireProject();
 
   const infrastructurePath = path.join(process.cwd(), 'infrastructure');
@@ -18,9 +22,24 @@ async function dockerLogs() {
     process.exit(1);
   }
 
-  // Get optional service name from args (e.g., launchframe docker:logs backend)
-  const service = process.argv[3];
+  const noFollow = flags['no-follow'];
 
+  if (noFollow) {
+    // Snapshot mode — print tail and exit (non-interactive, suitable for MCP)
+    const tail = flags.tail || 100;
+    const args = ['-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml', 'logs', '--no-follow', '--tail', String(tail)];
+    if (service) args.push(service);
+
+    try {
+      execSync(`docker-compose ${args.join(' ')}`, { cwd: infrastructurePath, stdio: 'inherit' });
+    } catch (error) {
+      console.error(chalk.red('\n❌ Error viewing logs:'), error.message);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Streaming mode (interactive)
   console.log(chalk.blue.bold('\n📋 Docker Service Logs\n'));
 
   if (service) {
@@ -34,14 +53,14 @@ async function dockerLogs() {
 
   try {
     const logsCommand = 'docker-compose';
-    const args = ['-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml', 'logs', '-f'];
+    const spawnArgs = ['-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml', 'logs', '-f'];
 
     if (service) {
-      args.push(service);
+      spawnArgs.push(service);
     }
 
     // Use spawn to stream output in real-time
-    const child = spawn(logsCommand, args, {
+    const child = spawn(logsCommand, spawnArgs, {
       cwd: infrastructurePath,
       stdio: 'inherit',
       shell: true

package/src/commands/docker-up.js

@@ -7,8 +7,10 @@ const { requireProject, getProjectConfig } = require('../utils/project-helpers')
 /**
  * Start Docker services (all or specific service)
  * @param {string} serviceName - Optional service name to start (e.g., 'docs', 'backend')
+ * @param {Object} flags - Optional flags
+ * @param {boolean} flags.detach - Run detached (docker-compose up -d) instead of watch mode
  */
-async function dockerUp(serviceName) {
+async function dockerUp(serviceName, flags = {}) {
   requireProject();
 
   const infrastructurePath = path.join(process.cwd(), 'infrastructure');
@@ -19,14 +21,26 @@ async function dockerUp(serviceName) {
     process.exit(1);
   }
 
+  if (flags.detach) {
+    // Detached mode — start services in background (no watch, no blocking)
+    const upCommand = serviceName
+      ? `docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d ${serviceName}`
+      : 'docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d';
+
+    console.log(chalk.gray(`Running: ${upCommand}\n`));
+    execSync(upCommand, { cwd: infrastructurePath, stdio: 'inherit' });
+    console.log(chalk.green.bold('\n✅ Services started in detached mode.\n'));
+    return;
+  }
+
   // Check Docker Compose version for watch support
   try {
     const composeVersion = execSync('docker compose version', { encoding: 'utf8' });
     const versionMatch = composeVersion.match(/v?(\d+)\.(\d+)\.(\d+)/);
-    
+
     if (versionMatch) {
       const [, major, minor] = versionMatch.map(Number);
-      
+
       if (major < 2 || (major === 2 && minor < 22)) {
         console.error(chalk.red('\n❌ Error: Docker Compose v2.22+ is required for watch support'));
         console.log(chalk.yellow(`Current version: Docker Compose v${major}.${minor}`));

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,38 @@
+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(migrationName) {
+  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);
+  }
+
+  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 };