@launchframe/cli 0.1.6

package/src/commands/waitlist-deploy.js

@@ -0,0 +1,231 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const ora = require('ora');
+const { requireProject, getProjectConfig, getPrimaryDomain, isWaitlistInstalled } = require('../utils/project-helpers');
+const {
+  testSSHConnection,
+  checkSSHKeys,
+  executeSSH,
+  copyFileToVPS
+} = require('../utils/ssh-helper');
+const {
+  checkDockerRunning,
+  loginToGHCR,
+  buildWaitlistImage
+} = require('../utils/docker-helper');
+
+/**
+ * Deploy waitlist service to VPS
+ * - Builds waitlist Docker image
+ * - Copies docker-compose and .env.prod to VPS
+ * - Does NOT clone full repo (standalone deployment)
+ */
+async function waitlistDeploy() {
+  requireProject();
+
+  console.log(chalk.blue.bold('\n🚀 Waitlist Service Deployment\n'));
+
+  const config = getProjectConfig();
+
+  // STEP 1: Validate waitlist is installed
+  if (!isWaitlistInstalled(config)) {
+    console.log(chalk.red('❌ Error: Waitlist service not installed\n'));
+    console.log(chalk.gray('Run this command first:'));
+    console.log(chalk.white('  launchframe service:add waitlist\n'));
+    process.exit(1);
+  }
+
+  // STEP 2: 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, ghcrToken, adminEmail } = config.deployment;
+  const { projectName, githubOrg, vpsAppFolder } = config;
+  const projectRoot = process.cwd();
+  const waitlistPath = path.join(projectRoot, 'waitlist');
+
+  // STEP 3: Validate waitlist .env.prod exists
+  console.log(chalk.yellow('📋 Step 1: Validating waitlist environment...\n'));
+
+  const envProdPath = path.join(waitlistPath, '.env.prod');
+  if (!await fs.pathExists(envProdPath)) {
+    console.log(chalk.red('❌ Error: waitlist/.env.prod not found\n'));
+    console.log(chalk.gray('The .env.prod file should be created during service installation.'));
+    console.log(chalk.gray('You can create it manually by copying waitlist/.env and updating values.\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.green('✓ Waitlist environment validated\n'));
+
+  // STEP 4: Check SSH keys and test connection
+  console.log(chalk.yellow('🔑 Step 2: Checking SSH configuration...\n'));
+
+  const { hasKeys } = await checkSSHKeys();
+  if (!hasKeys) {
+    console.log(chalk.yellow('⚠️  Warning: No SSH keys found in ~/.ssh/\n'));
+  }
+
+  const spinner = ora('Connecting to VPS...').start();
+  const connectionTest = await testSSHConnection(vpsUser, vpsHost);
+
+  if (!connectionTest.success) {
+    spinner.fail('Failed to connect to VPS');
+    console.log(chalk.red(`\n❌ SSH connection failed: ${connectionTest.error}\n`));
+    process.exit(1);
+  }
+
+  spinner.succeed('Connected to VPS successfully');
+  console.log();
+
+  // STEP 5: Build and push Docker image
+  console.log(chalk.yellow('🐳 Step 3: Building waitlist Docker image...\n'));
+
+  const dockerRunning = await checkDockerRunning();
+  if (!dockerRunning) {
+    console.log(chalk.red('❌ Docker is not running\n'));
+    console.log(chalk.gray('Please start Docker Desktop and try again.\n'));
+    process.exit(1);
+  }
+
+  if (!ghcrToken) {
+    console.log(chalk.red('❌ GHCR token not configured\n'));
+    console.log(chalk.gray('Run: launchframe deploy:configure\n'));
+    process.exit(1);
+  }
+
+  try {
+    await loginToGHCR(githubOrg, ghcrToken);
+    await buildWaitlistImage(projectRoot, projectName, githubOrg);
+    console.log(chalk.green.bold('\n✅ Waitlist image built and pushed!\n'));
+  } catch (error) {
+    console.log(chalk.red('\n❌ Failed to build Docker image\n'));
+    console.log(chalk.gray('Error:'), error.message, '\n');
+    process.exit(1);
+  }
+
+  // STEP 6: Copy deployment files to VPS
+  console.log(chalk.yellow('📦 Step 4: Copying deployment files to VPS...\n'));
+
+  const deploySpinner = ora('Creating app directory...').start();
+
+  try {
+    // Create waitlist directory on VPS
+    await executeSSH(vpsUser, vpsHost, `mkdir -p ${vpsAppFolder}/waitlist`);
+
+    // Copy docker-compose file
+    deploySpinner.text = 'Copying docker-compose file...';
+    const composeFile = path.join(waitlistPath, 'docker-compose.waitlist.yml');
+    await copyFileToVPS(composeFile, vpsUser, vpsHost, `${vpsAppFolder}/waitlist/docker-compose.waitlist.yml`);
+
+    // Copy .env.prod file (ensure ADMIN_EMAIL is included)
+    deploySpinner.text = 'Copying .env.prod file...';
+
+    // Read .env.prod and add ADMIN_EMAIL if missing
+    let envProdContent = await fs.readFile(envProdPath, 'utf8');
+    if (!envProdContent.includes('ADMIN_EMAIL=') && adminEmail) {
+      envProdContent += `ADMIN_EMAIL=${adminEmail}\n`;
+      await fs.writeFile(envProdPath, envProdContent, 'utf8');
+    }
+
+    await copyFileToVPS(envProdPath, vpsUser, vpsHost, `${vpsAppFolder}/waitlist/.env`);
+
+    deploySpinner.succeed('Deployment files copied to VPS');
+  } catch (error) {
+    deploySpinner.fail('Failed to copy files');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+
+  // STEP 7: Pull Docker image on VPS
+  console.log(chalk.yellow('\n🐳 Step 5: Pulling waitlist Docker image on VPS...\n'));
+
+  const pullSpinner = ora('Pulling Docker image...').start();
+
+  try {
+    await executeSSH(
+      vpsUser,
+      vpsHost,
+      `cd ${vpsAppFolder}/waitlist && docker-compose -f docker-compose.waitlist.yml pull`,
+      { timeout: 300000 } // 5 minutes
+    );
+    pullSpinner.succeed('Docker image pulled successfully');
+  } catch (error) {
+    pullSpinner.fail('Failed to pull Docker image');
+    console.log(chalk.yellow(`\n⚠️  Warning: ${error.message}\n`));
+    console.log(chalk.gray('You can try pulling the image manually on the VPS.\n'));
+  }
+
+  // Success!
+  console.log(chalk.green.bold('\n✅ Waitlist deployment initialized!\n'));
+
+  console.log(chalk.white('Summary:'));
+  console.log(chalk.gray(`  - Deployment files copied to: ${vpsAppFolder}/waitlist`));
+  console.log(chalk.gray('  - Docker image pulled from GHCR'));
+  console.log(chalk.gray('  - Production .env configured\n'));
+
+  // STEP 8: Automatically start the waitlist
+  console.log(chalk.yellow('🚀 Step 6: Starting waitlist containers...\n'));
+
+  const startSpinner = ora('Starting waitlist on VPS...').start();
+
+  try {
+    await executeSSH(
+      vpsUser,
+      vpsHost,
+      `cd ${vpsAppFolder}/waitlist && docker-compose -f docker-compose.waitlist.yml up -d`,
+      { timeout: 180000 } // 3 minutes
+    );
+
+    startSpinner.succeed('Waitlist started successfully');
+  } catch (error) {
+    startSpinner.fail('Failed to start waitlist');
+    console.log(chalk.yellow(`\n⚠️  Warning: ${error.message}\n`));
+    console.log(chalk.gray('You can start it manually with: launchframe waitlist:up\n'));
+    process.exit(1);
+  }
+
+  // Verify services are running
+  console.log(chalk.yellow('\n🔍 Step 7: Verifying deployment...\n'));
+
+  const verifySpinner = ora('Checking service status...').start();
+
+  try {
+    const { stdout: psOutput } = await executeSSH(
+      vpsUser,
+      vpsHost,
+      `cd ${vpsAppFolder}/waitlist && docker-compose -f docker-compose.waitlist.yml ps`,
+      { timeout: 30000 }
+    );
+
+    verifySpinner.succeed('Services verified');
+    console.log(chalk.gray('\n' + psOutput));
+  } catch (error) {
+    verifySpinner.warn('Could not verify services');
+  }
+
+  // Final success message
+  const primaryDomain = getPrimaryDomain(config);
+
+  console.log(chalk.green.bold('\n✅ Waitlist is now live!\n'));
+
+  console.log(chalk.white('Your waitlist landing page is available at:\n'));
+  console.log(chalk.cyan(`  🌍 Waitlist: https://${primaryDomain || 'your-domain.com'}`));
+  console.log(chalk.gray(`  ✓ Standalone Traefik instance (SSL + reverse proxy)`));
+  console.log(chalk.gray(`  ✓ Automatic Let's Encrypt SSL certificates`));
+  console.log(chalk.gray(`  ✓ Fully isolated from full-app deployment\n`));
+
+  console.log(chalk.white('⏰ Note: SSL certificates may take a few minutes to provision.\n'));
+
+  console.log(chalk.white('Monitor waitlist:'));
+  console.log(chalk.gray(`  launchframe waitlist:logs\n`));
+
+  console.log(chalk.white('Stop waitlist:'));
+  console.log(chalk.gray(`  launchframe waitlist:down\n`));
+}
+
+module.exports = { waitlistDeploy };

package/src/commands/waitlist-down.js

@@ -0,0 +1,50 @@
+const chalk = require('chalk');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+const ora = require('ora');
+const { requireProject, getProjectConfig, isWaitlistInstalled } = require('../utils/project-helpers');
+
+const execAsync = promisify(exec);
+
+/**
+ * Stop waitlist service locally
+ */
+async function waitlistDown() {
+  requireProject();
+
+  console.log(chalk.blue.bold('\n🛑 Stopping Waitlist Service (Local)\n'));
+
+  const config = getProjectConfig();
+
+  // Validate waitlist is installed
+  if (!isWaitlistInstalled(config)) {
+    console.log(chalk.red('❌ Error: Waitlist service not installed\n'));
+    console.log(chalk.gray('Run: launchframe service:add waitlist\n'));
+    process.exit(1);
+  }
+
+  const projectRoot = process.cwd();
+  const waitlistPath = path.join(projectRoot, 'waitlist');
+
+  // Stop waitlist containers
+  const spinner = ora('Stopping waitlist containers...').start();
+
+  try {
+    await execAsync(
+      `cd ${waitlistPath} && docker-compose -f docker-compose.waitlist.yml -f docker-compose.waitlist.dev.yml down`,
+      { timeout: 60000 } // 1 minute
+    );
+
+    spinner.succeed('Waitlist stopped successfully');
+  } catch (error) {
+    spinner.fail('Failed to stop waitlist');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+
+  console.log(chalk.green.bold('\n✅ Waitlist service stopped!\n'));
+  console.log(chalk.gray('To start again: launchframe waitlist:up\n'));
+}
+
+module.exports = { waitlistDown };

package/src/commands/waitlist-logs.js

@@ -0,0 +1,55 @@
+const chalk = require('chalk');
+const { spawn } = require('child_process');
+const { requireProject, getProjectConfig, isWaitlistInstalled } = require('../utils/project-helpers');
+
+/**
+ * View waitlist logs from VPS (streaming)
+ */
+async function waitlistLogs() {
+  requireProject();
+
+  console.log(chalk.blue.bold('\n📋 Waitlist Logs\n'));
+
+  const config = getProjectConfig();
+
+  // Validate waitlist is installed
+  if (!isWaitlistInstalled(config)) {
+    console.log(chalk.red('❌ Error: Waitlist service not installed\n'));
+    console.log(chalk.gray('Run: launchframe service:add waitlist\n'));
+    process.exit(1);
+  }
+
+  // Validate deployment is configured
+  if (!config.deployConfigured || !config.deployment) {
+    console.log(chalk.red('❌ Error: Deployment not configured yet\n'));
+    console.log(chalk.gray('Run: launchframe deploy:configure\n'));
+    process.exit(1);
+  }
+
+  const { vpsHost, vpsUser } = config.deployment;
+  const { vpsAppFolder } = config;
+
+  console.log(chalk.gray('Connecting to VPS and streaming logs...\n'));
+  console.log(chalk.gray('Press Ctrl+C to exit\n'));
+
+  // Use spawn instead of exec for streaming logs
+  const logsProcess = spawn('ssh', [
+    `${vpsUser}@${vpsHost}`,
+    `cd ${vpsAppFolder}/waitlist && docker-compose -f docker-compose.waitlist.yml logs -f --tail=100`
+  ], {
+    stdio: 'inherit' // Stream output directly to terminal
+  });
+
+  logsProcess.on('error', (error) => {
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  });
+
+  logsProcess.on('exit', (code) => {
+    if (code !== 0 && code !== null) {
+      console.log(chalk.yellow(`\n⚠️  Process exited with code ${code}\n`));
+    }
+  });
+}
+
+module.exports = { waitlistLogs };

package/src/commands/waitlist-up.js

@@ -0,0 +1,95 @@
+const chalk = require('chalk');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+const ora = require('ora');
+const { requireProject, getProjectConfig, isWaitlistInstalled } = require('../utils/project-helpers');
+
+const execAsync = promisify(exec);
+
+/**
+ * Start waitlist service locally
+ */
+async function waitlistUp() {
+  requireProject();
+
+  console.log(chalk.blue.bold('\n🚀 Starting Waitlist Service (Local)\n'));
+
+  const config = getProjectConfig();
+
+  // Validate waitlist is installed
+  if (!isWaitlistInstalled(config)) {
+    console.log(chalk.red('❌ Error: Waitlist service not installed\n'));
+    console.log(chalk.gray('Run: launchframe service:add waitlist\n'));
+    process.exit(1);
+  }
+
+  const projectRoot = process.cwd();
+  const waitlistPath = path.join(projectRoot, 'waitlist');
+
+  // STEP 1: Check Docker version
+  console.log(chalk.yellow('🐳 Step 1: Checking Docker...\n'));
+
+  const dockerSpinner = ora('Checking Docker installation...').start();
+
+  try {
+    const { stdout: versionOutput } = await execAsync('docker version --format "{{.Client.Version}}"');
+    const version = versionOutput.trim();
+    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'));
+    process.exit(1);
+  }
+
+  // STEP 2: Start waitlist locally
+  console.log(chalk.yellow('\n🚀 Step 2: Starting waitlist containers...\n'));
+
+  const deploySpinner = ora('Starting waitlist containers...').start();
+
+  try {
+    await execAsync(
+      `cd ${waitlistPath} && docker-compose -f docker-compose.waitlist.yml -f docker-compose.waitlist.dev.yml up -d`,
+      { timeout: 180000 } // 3 minutes
+    );
+
+    deploySpinner.succeed('Waitlist started successfully');
+  } catch (error) {
+    deploySpinner.fail('Failed to start waitlist');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+
+  // STEP 3: Verify services are running
+  console.log(chalk.yellow('\n🔍 Step 3: Verifying containers...\n'));
+
+  const verifySpinner = ora('Checking service status...').start();
+
+  try {
+    const { stdout: psOutput } = await execAsync(
+      `cd ${waitlistPath} && docker-compose -f docker-compose.waitlist.yml -f docker-compose.waitlist.dev.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✅ Waitlist is now running locally!\n'));
+
+  console.log(chalk.white('Your waitlist landing page is available at:\n'));
+  console.log(chalk.cyan(`  🌍 Waitlist: http://localhost:3002`));
+  console.log(chalk.gray(`  ✓ Running in development mode with hot reload`));
+  console.log(chalk.gray(`  ✓ Source code mounted from ./waitlist/src\n`));
+
+  console.log(chalk.white('Monitor waitlist:'));
+  console.log(chalk.gray(`  launchframe waitlist:logs\n`));
+
+  console.log(chalk.white('Stop waitlist:'));
+  console.log(chalk.gray(`  launchframe waitlist:down\n`));
+}
+
+module.exports = { waitlistUp };

package/src/generator.js

@@ -0,0 +1,190 @@
+const path = require('path');
+const fs = require('fs-extra');
+const { execSync } = require('child_process');
+const { replaceVariables } = require('./utils/variable-replacer');
+const { copyDirectory } = require('./utils/file-ops');
+const { generateEnvFile } = require('./utils/env-generator');
+const { processServiceVariant } = require('./utils/variant-processor');
+const { resolveVariantChoices } = require('./services/variant-config');
+
+/**
+ * Initialize git repository in a service directory
+ * @param {string} servicePath - Path to service directory
+ * @param {string} serviceName - Name of the service (for logging)
+ */
+function initGitRepo(servicePath, serviceName) {
+  try {
+    console.log(`🔧 Initializing git repository for ${serviceName}...`);
+    execSync('git init', { cwd: servicePath, stdio: 'ignore' });
+    execSync('git add .', { cwd: servicePath, stdio: 'ignore' });
+    execSync('git commit -m "Initial commit"', { cwd: servicePath, stdio: 'ignore' });
+    console.log(`✅ Git repository initialized for ${serviceName}`);
+  } catch (error) {
+    console.warn(`⚠️  Could not initialize git repository for ${serviceName}: ${error.message}`);
+  }
+}
+
+/**
+ * Main project generation function
+ * @param {Object} answers - User answers from prompts
+ * @param {Object} variantChoices - User's variant selections (tenancy, userModel)
+ */
+async function generateProject(answers, variantChoices) {
+  const { projectName } = answers;
+
+  // Define source (template) and destination paths
+  const templateRoot = path.resolve(__dirname, '../../modules');
+  const projectRoot = path.resolve(__dirname, '../..'); // For root-level files like .github, CLAUDE.md
+  const destinationRoot = path.resolve(process.cwd(), projectName);
+
+  console.log(`📁 Template source: ${templateRoot}`);
+  console.log(`📁 Destination: ${destinationRoot}\n`);
+
+  // Ensure destination directory exists
+  await fs.ensureDir(destinationRoot);
+
+  // Template variable replacements
+  const variables = {
+    '{{PROJECT_NAME}}': answers.projectName,
+    '{{PROJECT_NAME_UPPER}}': answers.projectNameUpper,
+    '{{PROJECT_DISPLAY_NAME}}': answers.projectDisplayName,
+    // Leave these as template variables for deploy:configure to replace
+    '{{GITHUB_ORG}}': '{{GITHUB_ORG}}',
+    '{{PRIMARY_DOMAIN}}': '{{PRIMARY_DOMAIN}}',
+    '{{ADMIN_EMAIL}}': '{{ADMIN_EMAIL}}',
+    '{{VPS_HOST}}': '{{VPS_HOST}}'
+  };
+
+  // Resolve variant choices for all services
+  const allServiceVariants = resolveVariantChoices(variantChoices);
+
+  // Step 1: Process backend service with variants
+  console.log('🔧 Processing backend service...');
+  await processServiceVariant(
+    'backend',
+    allServiceVariants.backend,
+    path.join(destinationRoot, 'backend'),
+    variables,
+    templateRoot
+  );
+  initGitRepo(path.join(destinationRoot, 'backend'), 'backend');
+
+  // Step 2: Process admin-portal service with variants
+  // Note: admin-portal folder might not exist yet in templates, skip if missing
+  const adminPortalTemplatePath = path.join(templateRoot, 'admin-portal/templates/base');
+  if (await fs.pathExists(adminPortalTemplatePath)) {
+    console.log('🔧 Processing admin-portal service...');
+    await processServiceVariant(
+      'admin-portal',
+      allServiceVariants['admin-portal'],
+      path.join(destinationRoot, 'admin-portal'),
+      variables,
+      templateRoot
+    );
+    initGitRepo(path.join(destinationRoot, 'admin-portal'), 'admin-portal');
+  } else {
+    // Fallback: Copy admin-portal directly without variants (for now)
+    console.log('📋 Copying admin-portal service (no variants yet)...');
+    const adminPortalSource = path.join(templateRoot, 'admin-portal');
+    if (await fs.pathExists(adminPortalSource)) {
+      await copyDirectory(adminPortalSource, path.join(destinationRoot, 'admin-portal'));
+      await replaceVariables(path.join(destinationRoot, 'admin-portal'), variables);
+      initGitRepo(path.join(destinationRoot, 'admin-portal'), 'admin-portal');
+    }
+  }
+
+  // Step 3: Process customers-portal service (ONLY if B2B2C selected)
+  if (variantChoices.userModel === 'b2b2c') {
+    // Note: customers-portal folder might not exist yet in templates, skip if missing
+    const customersPortalTemplatePath = path.join(templateRoot, 'customers-portal/templates/base');
+    if (await fs.pathExists(customersPortalTemplatePath)) {
+      console.log('🔧 Processing customers-portal service...');
+      await processServiceVariant(
+        'customers-portal',
+        allServiceVariants['customers-portal'],
+        path.join(destinationRoot, 'customers-portal'),
+        variables,
+        templateRoot
+      );
+      initGitRepo(path.join(destinationRoot, 'customers-portal'), 'customers-portal');
+    } else {
+      // Fallback: Copy customers-portal directly without variants (for now)
+      console.log('📋 Copying customers-portal service (B2B2C mode)...');
+      const customersPortalSource = path.join(templateRoot, 'customers-portal');
+      if (await fs.pathExists(customersPortalSource)) {
+        await copyDirectory(customersPortalSource, path.join(destinationRoot, 'customers-portal'));
+        await replaceVariables(path.join(destinationRoot, 'customers-portal'), variables);
+        initGitRepo(path.join(destinationRoot, 'customers-portal'), 'customers-portal');
+      }
+    }
+  } else {
+    console.log('📋 Skipping customers-portal (B2B mode - admin users only)');
+  }
+
+  // Step 4: Process infrastructure with variants (docker-compose files conditionally include customers-portal)
+  console.log('🔧 Processing infrastructure...');
+  await processServiceVariant(
+    'infrastructure',
+    allServiceVariants.infrastructure,
+    path.join(destinationRoot, 'infrastructure'),
+    variables,
+    templateRoot
+  );
+  initGitRepo(path.join(destinationRoot, 'infrastructure'), 'infrastructure');
+
+  console.log('📋 Copying website...');
+  await copyDirectory(
+    path.join(templateRoot, 'website'),
+    path.join(destinationRoot, 'website')
+  );
+  await replaceVariables(path.join(destinationRoot, 'website'), variables);
+  initGitRepo(path.join(destinationRoot, 'website'), 'website');
+
+  // Step 5: Copy additional files (from project root, not modules/)
+  console.log('📋 Copying additional files...');
+  const additionalFiles = [
+    '.github',
+    'CLAUDE.md',
+    'README.md',
+    '.gitignore',
+    'LICENSE'
+  ];
+
+  for (const file of additionalFiles) {
+    const sourcePath = path.join(projectRoot, file);
+    const destPath = path.join(destinationRoot, file);
+
+    if (await fs.pathExists(sourcePath)) {
+      const stats = await fs.stat(sourcePath);
+      if (stats.isDirectory()) {
+        await copyDirectory(sourcePath, destPath);
+      } else {
+        await fs.copy(sourcePath, destPath);
+      }
+      await replaceVariables(destPath, variables);
+    }
+  }
+
+  // Step 6: Generate .env file with localhost defaults
+  console.log('\n🔐 Generating .env file with secure secrets...');
+  const { envPath } = await generateEnvFile(destinationRoot, answers);
+  console.log(`✅ Environment file created: ${envPath}`);
+
+  // Step 7: Create .launchframe marker file with variant metadata
+  console.log('📝 Creating LaunchFrame marker file...');
+  const markerPath = path.join(destinationRoot, '.launchframe');
+  const markerContent = {
+    version: '0.1.0',
+    createdAt: new Date().toISOString(),
+    projectName: answers.projectName,
+    projectDisplayName: answers.projectDisplayName,
+    deployConfigured: false,
+    // Store variant choices for future reference
+    variants: variantChoices
+  };
+  await fs.writeJson(markerPath, markerContent, { spaces: 2 });
+
+  console.log('✅ Base project generated with variants applied');
+}
+
+module.exports = { generateProject };