@launchframe/cli 0.1.6

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

@@ -0,0 +1,232 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const path = require('path');
+const fs = require('fs-extra');
+const { requireProject, getProjectConfig } = require('../utils/project-helpers');
+const { generateSecret, checkForPlaceholders } = require('../utils/env-validator');
+
+/**
+ * Configure production environment variables
+ */
+async function deploySetEnv() {
+  requireProject();
+
+  console.log(chalk.blue.bold('\n🔐 LaunchFrame Production Environment Configuration\n'));
+
+  const config = getProjectConfig();
+  if (!config.deployConfigured) {
+    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 projectRoot = process.cwd();
+  const envPath = path.join(projectRoot, 'infrastructure', '.env');
+  const envProdPath = path.join(projectRoot, 'infrastructure', '.env.prod');
+
+  // Check if .env.prod already exists
+  const envProdExists = await fs.pathExists(envProdPath);
+
+  if (envProdExists) {
+    console.log(chalk.yellow('⚠️  .env.prod already exists.\n'));
+
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: 'Update existing values', value: 'update' },
+          { name: 'Start fresh (overwrite)', value: 'overwrite' },
+          { name: 'Cancel', value: 'cancel' }
+        ]
+      }
+    ]);
+
+    if (action === 'cancel') {
+      console.log(chalk.yellow('\n❌ Configuration cancelled\n'));
+      return;
+    }
+
+    if (action === 'overwrite') {
+      await fs.remove(envProdPath);
+    }
+  }
+
+  // Copy .env as template if .env.prod doesn't exist
+  if (!await fs.pathExists(envProdPath)) {
+    if (!await fs.pathExists(envPath)) {
+      console.log(chalk.red('❌ Error: infrastructure/.env file not found\n'));
+      process.exit(1);
+    }
+
+    await fs.copy(envPath, envProdPath);
+    console.log(chalk.green('✓ Created .env.prod from .env template\n'));
+  }
+
+  console.log(chalk.yellow('Configure production environment variables.\n'));
+  console.log(chalk.gray('Leave blank to keep existing values or generate secure defaults.\n'));
+
+  // Generate secure defaults
+  const dbPassword = generateSecret(24);
+  const redisPassword = generateSecret(24);
+  const jwtSecret = generateSecret(32);
+  const bullAdminToken = generateSecret(32);
+
+  const answers = await inquirer.prompt([
+      {
+        type: 'password',
+        name: 'dbPassword',
+        message: 'Database password:',
+        default: dbPassword,
+        mask: '*'
+      },
+      {
+        type: 'password',
+        name: 'redisPassword',
+        message: 'Redis password:',
+        default: redisPassword,
+        mask: '*'
+      },
+      {
+        type: 'password',
+        name: 'jwtSecret',
+        message: 'JWT secret:',
+        default: jwtSecret,
+        mask: '*'
+      },
+      {
+        type: 'password',
+        name: 'bullAdminToken',
+        message: 'Bull Admin token:',
+        default: bullAdminToken,
+        mask: '*'
+      },
+      {
+        type: 'input',
+        name: 'resendApiKey',
+        message: 'Resend API key (email):',
+        default: ''
+      },
+      {
+        type: 'input',
+        name: 'openaiApiKey',
+        message: 'OpenAI API key:',
+        default: ''
+      },
+      {
+        type: 'input',
+        name: 'claudeApiKey',
+        message: 'Claude API key:',
+        default: ''
+      },
+      {
+        type: 'input',
+        name: 'polarAccessToken',
+        message: 'Polar Access Token:',
+        default: ''
+      },
+      {
+        type: 'input',
+        name: 'polarWebhookSecret',
+        message: 'Polar Webhook Secret:',
+        default: ''
+      },
+      {
+        type: 'input',
+        name: 'googleClientId',
+        message: 'Google OAuth Client ID:',
+        default: ''
+      },
+      {
+        type: 'input',
+        name: 'googleClientSecret',
+        message: 'Google OAuth Client Secret:',
+        default: ''
+      }
+    ]);
+
+  // Read current .env.prod content
+  let envContent = await fs.readFile(envProdPath, 'utf8');
+
+  // Replace values based on deployment mode
+  const replacements = {};
+
+  if (isWaitlistMode) {
+    // Waitlist mode: only update Resend API key if provided
+    // Airtable credentials should already be in .env from component:add
+    if (answers.resendApiKey) {
+      replacements['RESEND_API_KEY'] = answers.resendApiKey;
+    }
+  } else {
+    // Full-app mode: update all configuration
+    replacements['DB_PASSWORD'] = answers.dbPassword;
+    replacements['REDIS_PASSWORD'] = answers.redisPassword;
+    replacements['JWT_SECRET'] = answers.jwtSecret;
+    replacements['BULL_ADMIN_TOKEN'] = answers.bullAdminToken;
+    replacements['RESEND_API_KEY'] = answers.resendApiKey || 're_your_resend_api_key';
+    replacements['OPENAI_API_KEY'] = answers.openaiApiKey || 'sk-your_openai_api_key';
+    replacements['CLAUDE_API_KEY'] = answers.claudeApiKey || 'sk-ant-your_claude_api_key';
+    replacements['POLAR_ACCESS_TOKEN'] = answers.polarAccessToken || 'polar_oat_your_token';
+    replacements['POLAR_WEBHOOK_SECRET'] = answers.polarWebhookSecret || 'polar_whs_your_secret';
+    replacements['GOOGLE_CLIENT_ID'] = answers.googleClientId || 'YOUR_GOOGLE_CLIENT_ID';
+    replacements['GOOGLE_CLIENT_SECRET'] = answers.googleClientSecret || 'YOUR_GOOGLE_CLIENT_SECRET';
+  }
+
+  // Update environment variables
+  for (const [key, value] of Object.entries(replacements)) {
+    // Match KEY=old_value and replace with KEY=new_value
+    const regex = new RegExp(`^${key}=.*$`, 'gm');
+    if (regex.test(envContent)) {
+      envContent = envContent.replace(regex, `${key}=${value}`);
+    }
+  }
+
+  // Update production URLs based on deployment config
+  if (config.deployment?.primaryDomain) {
+    const domain = config.deployment.primaryDomain;
+    const urlReplacements = {
+      'API_BASE_URL': `https://api.${domain}`,
+      'ADMIN_BASE_URL': `https://admin.${domain}`,
+      'FRONTEND_BASE_URL': `https://app.${domain}`,
+      'WEBSITE_BASE_URL': `https://${domain}`
+    };
+
+    for (const [key, value] of Object.entries(urlReplacements)) {
+      const regex = new RegExp(`^${key}=.*$`, 'gm');
+      if (regex.test(envContent)) {
+        envContent = envContent.replace(regex, `${key}=${value}`);
+      }
+    }
+  }
+
+  // Write updated content
+  await fs.writeFile(envProdPath, envContent, 'utf8');
+
+  console.log(chalk.yellow('\n⚙️  Validating configuration...\n'));
+
+  // Check for remaining placeholders
+  const { hasPlaceholders, placeholders } = await checkForPlaceholders(envProdPath);
+
+  if (hasPlaceholders) {
+    console.log(chalk.yellow('⚠️  Warning: Some placeholder variables remain:\n'));
+    placeholders.forEach(p => console.log(chalk.gray(`  - ${p}`)));
+    console.log(chalk.gray('\nYou can edit .env.prod manually to set these values.\n'));
+  } else {
+    console.log(chalk.green('✓ No placeholder variables found\n'));
+  }
+
+  console.log(chalk.green.bold('✅ Production environment configured!\n'));
+  console.log(chalk.white('Configuration saved to:'));
+  console.log(chalk.gray('  - infrastructure/.env.prod\n'));
+
+  console.log(chalk.yellow('⚠️  Important:'));
+  console.log(chalk.gray('  - .env.prod is gitignored (will not be committed)'));
+  console.log(chalk.gray('  - Keep this file secure - it contains production secrets\n'));
+
+  console.log(chalk.white('Next step:'));
+  console.log(chalk.gray('  Run: launchframe deploy:init\n'));
+}
+
+module.exports = { deploySetEnv };

package/src/commands/deploy-up.js

@@ -0,0 +1,144 @@
+const chalk = require('chalk');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const ora = require('ora');
+const { requireProject, getProjectConfig } = require('../utils/project-helpers');
+
+const execAsync = promisify(exec);
+
+/**
+ * Start services on VPS using Docker context
+ */
+async function deployUp() {
+  requireProject();
+
+  console.log(chalk.blue.bold('\n🚀 LaunchFrame Service Deployment\n'));
+
+  const config = getProjectConfig();
+
+  // 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, primaryDomain } = config.deployment;
+  const { projectName } = config;
+
+  // Step 1: Check Docker version
+  console.log(chalk.yellow('🐳 Step 1: Checking Docker version...\n'));
+
+  const dockerSpinner = ora('Checking Docker installation...').start();
+
+  try {
+    const { stdout: versionOutput } = await execAsync('docker version --format "{{.Client.Version}}"');
+    const version = versionOutput.trim();
+    const [major, minor] = version.split('.').map(Number);
+
+    if (major < 19 || (major === 19 && minor < 3)) {
+      dockerSpinner.fail(`Docker version ${version} is too old`);
+      console.log(chalk.red('\n❌ Docker 19.03+ is required for context support\n'));
+      console.log(chalk.gray('Please upgrade Docker:'));
+      console.log(chalk.white('  https://docs.docker.com/engine/install/\n'));
+      process.exit(1);
+    }
+
+    dockerSpinner.succeed(`Docker ${version} (compatible)`);
+  } catch (error) {
+    dockerSpinner.fail('Docker not found');
+    console.log(chalk.red('\n❌ Docker is not installed or not in PATH\n'));
+    console.log(chalk.gray('Please install Docker:'));
+    console.log(chalk.white('  https://docs.docker.com/engine/install/\n'));
+    process.exit(1);
+  }
+
+  // Step 2: Verify SSH connection
+  console.log(chalk.yellow('\n🔗 Step 2: Verifying SSH connection...\n'));
+
+  const sshSpinner = ora('Testing SSH connection...').start();
+
+  try {
+    await execAsync(`ssh -o ConnectTimeout=10 ${vpsUser}@${vpsHost} "echo 'Connected'"`, {
+      timeout: 15000
+    });
+
+    sshSpinner.succeed('SSH connection verified');
+  } catch (error) {
+    sshSpinner.fail('Failed to connect via SSH');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    console.log(chalk.gray('Make sure you can SSH to the VPS without password (key-based auth).\n'));
+    console.log(chalk.gray(`Test manually: ssh ${vpsUser}@${vpsHost}\n`));
+    process.exit(1);
+  }
+
+  // Step 3: Start services on VPS via SSH
+  console.log(chalk.yellow('\n🚀 Step 3: Starting services on VPS...\n'));
+  console.log(chalk.gray('This will start all Docker containers in production mode.\n'));
+
+  const deploySpinner = ora('Connecting to VPS...').start();
+
+  try {
+    deploySpinner.text = 'Starting full application stack...';
+
+    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
+    );
+
+    deploySpinner.succeed('Full application started successfully');
+  } catch (error) {
+    deploySpinner.fail('Failed to start services');
+
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    console.log(chalk.gray('Common issues:'));
+    console.log(chalk.gray('  - Docker not running on VPS'));
+    console.log(chalk.gray('  - Docker Compose not installed on VPS'));
+    console.log(chalk.gray('  - Insufficient permissions\n'));
+    process.exit(1);
+  }
+
+  // Step 4: Verify services are running
+  console.log(chalk.yellow('\n🔍 Step 4: Verifying deployment...\n'));
+
+  const verifySpinner = ora('Checking service status...').start();
+
+  try {
+    const { stdout: psOutput} = await execAsync(
+      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml ps"`,
+      { timeout: 30000 }
+    );
+
+    verifySpinner.succeed('Services verified');
+
+    console.log(chalk.gray('\n' + psOutput));
+  } catch (error) {
+    verifySpinner.warn('Could not verify services');
+  }
+
+  // Success!
+  console.log(chalk.green.bold('\n✅ Deployment complete!\n'));
+
+  console.log(chalk.white('Your application is now running at:\n'));
+  console.log(chalk.cyan(`  🌍 User Frontend:  https://${primaryDomain}`));
+  console.log(chalk.cyan(`  ⚙️  Admin Panel:    https://admin.${primaryDomain}`));
+  console.log(chalk.cyan(`  🔌 API:            https://api.${primaryDomain}`));
+  console.log(chalk.cyan(`  📄 Website:        https://www.${primaryDomain || primaryDomain}`));
+
+  console.log(chalk.white('\n⏰ Note: SSL certificates from Let\'s Encrypt may take a few minutes to provision.\n'));
+
+  console.log(chalk.white('Next steps:\n'));
+  console.log(chalk.white('1. Configure GitHub Secrets for automated deployments:'));
+  console.log(chalk.gray(`   Repository: https://github.com/${config.deployment.githubOrg}/${projectName}/settings/secrets/actions`));
+  console.log(chalk.gray('   Required secrets:'));
+  console.log(chalk.gray('     - VPS_HOST, VPS_USER, VPS_SSH_KEY, GHCR_TOKEN\n'));
+
+  console.log(chalk.white('2. Future deployments:'));
+  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`));
+}
+
+module.exports = { deployUp };

package/src/commands/docker-build.js

@@ -0,0 +1,44 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { execSync } = require('child_process');
+const { requireProject } = require('../utils/project-helpers');
+
+/**
+ * Build Docker images for the project
+ */
+async function dockerBuild() {
+  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🔨 Building Docker Images\n'));
+  console.log(chalk.gray('This will build all service images for local development...\n'));
+
+  try {
+    const buildCommand = 'docker-compose -f docker-compose.yml -f docker-compose.dev.yml build';
+
+    console.log(chalk.gray(`Running: ${buildCommand}\n`));
+
+    execSync(buildCommand, {
+      cwd: infrastructurePath,
+      stdio: 'inherit'
+    });
+
+    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'));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Error during build:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { dockerBuild };

package/src/commands/docker-destroy.js

@@ -0,0 +1,93 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { execSync } = require('child_process');
+const { requireProject } = require('../utils/project-helpers');
+
+/**
+ * Destroy all Docker resources for this project
+ * @param {Object} options - Command options
+ * @param {boolean} options.force - Skip confirmation prompt
+ */
+async function dockerDestroy(options = {}) {
+  requireProject();
+
+  console.log(chalk.yellow.bold('\n⚠️  WARNING: Docker Resource Destruction\n'));
+  console.log(chalk.white('This will remove ALL Docker resources for this project:'));
+  console.log(chalk.gray('  • All containers (running and stopped)'));
+  console.log(chalk.gray('  • All volumes (including databases)'));
+  console.log(chalk.gray('  • All images'));
+  console.log(chalk.gray('  • Project network\n'));
+  console.log(chalk.red('⚠️  This action is IRREVERSIBLE. All data will be lost.\n'));
+
+  // Skip confirmation if --force flag is provided
+  if (!options.force) {
+    const { confirmed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message: 'Are you sure you want to destroy all Docker resources?',
+        default: false
+      }
+    ]);
+
+    if (!confirmed) {
+      console.log(chalk.gray('\n✓ Cancelled. No changes made.\n'));
+      return;
+    }
+  } else {
+    console.log(chalk.yellow('--force flag detected, skipping confirmation...\n'));
+  }
+
+  try {
+    const markerPath = path.join(process.cwd(), '.launchframe');
+    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+    const projectName = marker.projectName;
+
+    console.log(chalk.yellow('\n🗑️  Destroying Docker resources...\n'));
+
+    // Step 1: Stop and remove all containers
+    console.log(chalk.gray('Stopping and removing containers...'));
+    try {
+      execSync(`docker ps -a --filter "name=${projectName}" -q | xargs -r docker rm -f`, { stdio: 'inherit' });
+    } catch (error) {
+      // Ignore errors if no containers found
+    }
+
+    // Step 2: Remove all volumes
+    console.log(chalk.gray('Removing volumes...'));
+    try {
+      execSync(`docker volume ls --filter "name=${projectName}" -q | xargs -r docker volume rm`, { stdio: 'inherit' });
+    } catch (error) {
+      // Ignore errors if no volumes found
+    }
+
+    // Step 3: Remove all images
+    console.log(chalk.gray('Removing images...'));
+    try {
+      execSync(`docker images --filter "reference=${projectName}*" -q | xargs -r docker rmi -f`, { stdio: 'inherit' });
+    } catch (error) {
+      // Ignore errors if no images found
+    }
+
+    // Step 4: Remove network
+    console.log(chalk.gray('Removing network...'));
+    try {
+      execSync(`docker network rm ${projectName}-network`, { stdio: 'inherit' });
+    } catch (error) {
+      // Ignore errors if network doesn't exist
+    }
+
+    console.log(chalk.green.bold('\n✅ All Docker resources destroyed successfully!\n'));
+    console.log(chalk.white('To rebuild your project:'));
+    console.log(chalk.gray('  cd infrastructure'));
+    console.log(chalk.gray('  docker-compose -f docker-compose.yml -f docker-compose.dev.yml up --build\n'));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Error during cleanup:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { dockerDestroy };

package/src/commands/docker-down.js

@@ -0,0 +1,44 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { execSync } = require('child_process');
+const { requireProject } = require('../utils/project-helpers');
+
+/**
+ * Stop all Docker services (keeps volumes/data)
+ */
+async function dockerDown() {
+  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🛑 Stopping Docker Services\n'));
+  console.log(chalk.gray('Stopping all services (data will be preserved)...\n'));
+
+  try {
+    const downCommand = 'docker-compose -f docker-compose.yml -f docker-compose.dev.yml down';
+
+    console.log(chalk.gray(`Running: ${downCommand}\n`));
+
+    execSync(downCommand, {
+      cwd: infrastructurePath,
+      stdio: 'inherit'
+    });
+
+    console.log(chalk.green.bold('\n✅ All services stopped successfully!\n'));
+    console.log(chalk.white('Your data (database, volumes) has been preserved.'));
+    console.log(chalk.gray('Run `launchframe docker:up` to start services again.\n'));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Error stopping services:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { dockerDown };

package/src/commands/docker-logs.js

@@ -0,0 +1,69 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { spawn } = require('child_process');
+const { requireProject } = require('../utils/project-helpers');
+
+/**
+ * View logs from Docker services
+ */
+async function dockerLogs() {
+  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);
+  }
+
+  // Get optional service name from args (e.g., launchframe docker:logs backend)
+  const service = process.argv[3];
+
+  console.log(chalk.blue.bold('\n📋 Docker Service Logs\n'));
+
+  if (service) {
+    console.log(chalk.gray(`Streaming logs for: ${service}\n`));
+  } else {
+    console.log(chalk.gray('Streaming logs for all services\n'));
+  }
+
+  console.log(chalk.yellow('Press Ctrl+C to stop\n'));
+  console.log(chalk.gray('─'.repeat(80) + '\n'));
+
+  try {
+    const logsCommand = 'docker-compose';
+    const args = ['-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml', 'logs', '-f'];
+
+    if (service) {
+      args.push(service);
+    }
+
+    // Use spawn to stream output in real-time
+    const child = spawn(logsCommand, args, {
+      cwd: infrastructurePath,
+      stdio: 'inherit',
+      shell: true
+    });
+
+    // Handle Ctrl+C gracefully
+    process.on('SIGINT', () => {
+      console.log(chalk.yellow('\n\n✓ Stopped viewing logs\n'));
+      child.kill('SIGINT');
+      process.exit(0);
+    });
+
+    child.on('exit', (code) => {
+      if (code !== 0 && code !== null) {
+        console.log(chalk.yellow(`\n⚠️  Process exited with code ${code}\n`));
+      }
+    });
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Error viewing logs:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { dockerLogs };