@launchframe/cli 1.0.0-beta.2 → 1.0.0-beta.21

package/src/commands/init.js

@@ -4,15 +4,9 @@ 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');
 
 /**
  * Check if running in development mode (local) vs production (npm install)
@@ -30,28 +24,28 @@ 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
+      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 +55,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 +74,74 @@ 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'));
+    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/service.js

@@ -8,7 +8,7 @@ const { isLaunchFrameProject, getProjectConfig, updateProjectConfig, getPrimaryD
 const { replaceVariables } = require('../utils/variable-replacer');
 const { updateEnvFile } = require('../utils/env-generator');
 const { checkGitHubAccess, showAccessDeniedMessage } = require('../utils/github-access');
-const { ensureCacheReady, getModulePath } = require('../utils/module-cache');
+const { ensureCacheReady, getServicePath } = require('../utils/service-cache');
 
 async function serviceAdd(serviceName) {
   // STEP 1: Validation
@@ -75,13 +75,13 @@ async function serviceAdd(serviceName) {
   let sourceDir;
 
   if (isDevMode) {
-    // Local development: copy from launchframe-dev/modules directory
+    // Local development: copy from launchframe-dev/services directory
     console.log(chalk.blue('\n[DEV MODE] Copying service from local directory...'));
-    sourceDir = path.resolve(__dirname, '../../../modules', serviceName);
+    sourceDir = path.resolve(__dirname, '../../../services', serviceName);
 
     if (!fs.existsSync(sourceDir)) {
       console.error(chalk.red(`Error: Local service directory not found: ${sourceDir}`));
-      console.log('Make sure the service exists in the modules directory');
+      console.log('Make sure the service exists in the services directory');
       process.exit(1);
     }
   } else {
@@ -98,9 +98,9 @@ async function serviceAdd(serviceName) {
     console.log(chalk.green('✓ Repository access confirmed'));
     
     try {
-      // Ensure cache has this service module
+      // Ensure cache has this service
       await ensureCacheReady([serviceName]);
-      sourceDir = getModulePath(serviceName);
+      sourceDir = getServicePath(serviceName);
     } catch (error) {
       console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
       process.exit(1);
@@ -464,6 +464,12 @@ function getDockerComposeDefinitions(serviceName, service, projectName, projectC
   ${serviceName}:
     image: ghcr.io/${githubOrg}/${projectName}-${serviceName}:latest
     restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:3000/"]
+      interval: 30s
+      timeout: 10s
+      start_period: 40s
+      retries: 3
     labels:
       - "traefik.enable=true"
       - "traefik.http.routers.${serviceName}.rule=Host(\`${serviceName}.\${PRIMARY_DOMAIN}\`)"

package/src/commands/waitlist-deploy.js

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

package/src/generator.js

@@ -1,11 +1,13 @@
 const path = require('path');
 const fs = require('fs-extra');
 const { execSync } = require('child_process');
+const chalk = require('chalk');
 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');
+const logger = require('./utils/logger');
 
 /**
  * Initialize git repository in a service directory
@@ -14,13 +16,13 @@ const { resolveVariantChoices } = require('./services/variant-config');
  */
 function initGitRepo(servicePath, serviceName) {
   try {
-    console.log(`🔧 Initializing git repository for ${serviceName}...`);
+    logger.detail(`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}`);
+    logger.detail(`Git initialized: ${serviceName}`);
   } catch (error) {
-    console.warn(`⚠️  Could not initialize git repository for ${serviceName}: ${error.message}`);
+    logger.warn(`Could not initialize git for ${serviceName}: ${error.message}`);
   }
 }
 
@@ -34,12 +36,11 @@ async function generateProject(answers, variantChoices, templateRoot) {
   const { projectName } = answers;
 
   // Define source (template) and destination paths
-  // templateRoot is now passed as parameter (cache or local dev path)
-  const projectRoot = path.resolve(__dirname, '../..'); // For root-level files like .github, README.md
+  const projectRoot = path.resolve(__dirname, '../..'); // For root-level files
   const destinationRoot = path.resolve(process.cwd(), projectName);
 
-  console.log(`📁 Template source: ${templateRoot}`);
-  console.log(`📁 Destination: ${destinationRoot}\n`);
+  logger.detail(`Template source: ${templateRoot}`);
+  logger.detail(`Destination: ${destinationRoot}`);
 
   // Ensure destination directory exists
   await fs.ensureDir(destinationRoot);
@@ -60,8 +61,8 @@ async function generateProject(answers, variantChoices, templateRoot) {
   // Resolve variant choices for all services
   const allServiceVariants = resolveVariantChoices(variantChoices);
 
-  // Step 1: Process backend service with variants
-  console.log('🔧 Processing backend service...');
+  // Process backend
+  console.log(chalk.gray('  Processing backend...'));
   await processServiceVariant(
     'backend',
     allServiceVariants.backend,
@@ -71,11 +72,10 @@ async function generateProject(answers, variantChoices, 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');
+  // Process admin-portal
+  const adminPortalTemplatePath = path.join(templateRoot, 'admin-portal/base');
   if (await fs.pathExists(adminPortalTemplatePath)) {
-    console.log('🔧 Processing admin-portal service...');
+    console.log(chalk.gray('  Processing admin-portal...'));
     await processServiceVariant(
       'admin-portal',
       allServiceVariants['admin-portal'],
@@ -85,8 +85,8 @@ async function generateProject(answers, variantChoices, 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)...');
+    // Fallback: Copy admin-portal directly without variants
+    console.log(chalk.gray('  Copying admin-portal...'));
     const adminPortalSource = path.join(templateRoot, 'admin-portal');
     if (await fs.pathExists(adminPortalSource)) {
       await copyDirectory(adminPortalSource, path.join(destinationRoot, 'admin-portal'));
@@ -95,12 +95,11 @@ async function generateProject(answers, variantChoices, templateRoot) {
     }
   }
 
-  // Step 3: Process customers-portal service (ONLY if B2B2C selected)
+  // Process customers-portal (only if B2B2C)
   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');
+    const customersPortalTemplatePath = path.join(templateRoot, 'customers-portal/base');
     if (await fs.pathExists(customersPortalTemplatePath)) {
-      console.log('🔧 Processing customers-portal service...');
+      console.log(chalk.gray('  Processing customers-portal...'));
       await processServiceVariant(
         'customers-portal',
         allServiceVariants['customers-portal'],
@@ -110,8 +109,7 @@ async function generateProject(answers, variantChoices, 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)...');
+      console.log(chalk.gray('  Copying customers-portal...'));
       const customersPortalSource = path.join(templateRoot, 'customers-portal');
       if (await fs.pathExists(customersPortalSource)) {
         await copyDirectory(customersPortalSource, path.join(destinationRoot, 'customers-portal'));
@@ -120,11 +118,11 @@ async function generateProject(answers, variantChoices, templateRoot) {
       }
     }
   } else {
-    console.log('📋 Skipping customers-portal (B2B mode - admin users only)');
+    logger.detail('Skipping customers-portal (B2B mode)');
   }
 
-  // Step 4: Process infrastructure with variants (docker-compose files conditionally include customers-portal)
-  console.log('🔧 Processing infrastructure...');
+  // Process infrastructure
+  console.log(chalk.gray('  Processing infrastructure...'));
   await processServiceVariant(
     'infrastructure',
     allServiceVariants.infrastructure,
@@ -134,7 +132,8 @@ async function generateProject(answers, variantChoices, templateRoot) {
   );
   initGitRepo(path.join(destinationRoot, 'infrastructure'), 'infrastructure');
 
-  console.log('📋 Copying website...');
+  // Process website
+  console.log(chalk.gray('  Processing website...'));
   await copyDirectory(
     path.join(templateRoot, 'website'),
     path.join(destinationRoot, 'website')
@@ -142,14 +141,9 @@ async function generateProject(answers, variantChoices, templateRoot) {
   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',
-    'README.md',
-    '.gitignore',
-    'LICENSE'
-  ];
+  // Copy additional files
+  logger.detail('Copying additional files...');
+  const additionalFiles = ['.github', 'README.md', '.gitignore', 'LICENSE'];
 
   for (const file of additionalFiles) {
     const sourcePath = path.join(projectRoot, file);
@@ -166,21 +160,20 @@ async function generateProject(answers, variantChoices, templateRoot) {
     }
   }
 
-  // Step 6: Generate .env file with localhost defaults
-  console.log('\n🔐 Generating .env file with secure secrets...');
+  // Generate .env file
+  console.log(chalk.gray('  Generating environment file...'));
   const { envPath } = await generateEnvFile(destinationRoot, answers);
-  console.log(`✅ Environment file created: ${envPath}`);
+  logger.detail(`Environment file: ${envPath}`);
 
-  // Step 7: Create .launchframe marker file with variant metadata
-  console.log('📝 Creating LaunchFrame marker file...');
+  // Create .launchframe marker file
+  logger.detail('Creating project marker file...');
   const markerPath = path.join(destinationRoot, '.launchframe');
-  
-  // Determine which services were installed
+
   const installedServices = ['backend', 'admin-portal', 'infrastructure', 'website'];
   if (variantChoices.userModel === 'b2b2c') {
     installedServices.push('customers-portal');
   }
-  
+
   const markerContent = {
     version: '0.1.0',
     createdAt: new Date().toISOString(),
@@ -188,12 +181,9 @@ async function generateProject(answers, variantChoices, templateRoot) {
     projectDisplayName: answers.projectDisplayName,
     deployConfigured: false,
     installedServices: installedServices,
-    // 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 };

package/src/index.js

@@ -2,6 +2,7 @@
 
 const chalk = require('chalk');
 const { isLaunchFrameProject } = require('./utils/project-helpers');
+const logger = require('./utils/logger');
 
 // Import commands
 const { init } = require('./commands/init');
@@ -9,6 +10,7 @@ const { deployConfigure } = require('./commands/deploy-configure');
 const { deploySetEnv } = require('./commands/deploy-set-env');
 const { deployInit } = require('./commands/deploy-init');
 const { deployUp } = require('./commands/deploy-up');
+const { deployBuild } = require('./commands/deploy-build');
 const { waitlistDeploy } = require('./commands/waitlist-deploy');
 const { waitlistUp } = require('./commands/waitlist-up');
 const { waitlistDown } = require('./commands/waitlist-down');
@@ -65,17 +67,22 @@ async function main() {
   const inProject = isLaunchFrameProject();
   const flags = parseFlags(args);
 
+  // Handle version flag (only as standalone command)
+  if (command === '--version') {
+    const packageJson = require('../package.json');
+    console.log(packageJson.version);
+    process.exit(0);
+  }
+
+  // Set verbose mode globally
+  if (flags.verbose || flags.v) {
+    logger.setVerbose(true);
+  }
+
   // No command provided
   if (!command) {
-    if (inProject) {
-      console.error(chalk.red('\n❌ Error: No command specified'));
-      help();
-      process.exit(1);
-    } else {
-      // Outside project, default to init
-      await init(flags);
-      return;
-    }
+    help();
+    process.exit(inProject ? 1 : 0);
   }
 
   // Route commands
@@ -99,6 +106,9 @@ async function main() {
     case 'deploy:up':
       await deployUp();
       break;
+    case 'deploy:build':
+      await deployBuild(args[1]); // Optional service name
+      break;
     case 'waitlist:deploy':
       await waitlistDeploy();
       break;
@@ -163,7 +173,7 @@ async function main() {
       help();
       break;
     default:
-      console.error(chalk.red(`\n❌ Unknown command: ${command}\n`));
+      console.error(chalk.red(`\nUnknown command: ${command}\n`));
       help();
       process.exit(1);
   }

package/src/services/variant-config.js

@@ -11,9 +11,9 @@
 
 const VARIANT_CONFIG = {
   backend: {
-    base: 'backend/templates/base',
-    sectionsDir: 'backend/templates/sections',
-    filesDir: 'backend/templates/files',
+    base: 'backend/base',
+    sectionsDir: 'backend/variants/sections',
+    filesDir: 'backend/variants/files',
 
     variants: {
       // Multi-tenant variant: Adds project/workspace support
@@ -21,24 +21,16 @@ const VARIANT_CONFIG = {
         // Complete files/folders to copy
         files: [
           'src/modules/domain/projects',           // Entire projects module
-          'src/modules/domain/ai/services/project-config.service.ts', // Project config service
           'src/guards/project-ownership.guard.ts', // Project ownership guard (header-based)
           'src/guards/project-param.guard.ts',     // Project param guard (route-based)
-          'src/modules/auth/auth.service.ts',      // Auth service with multi-tenant support
-          'src/modules/auth/auth.controller.ts',   // Auth controller with multi-tenant support
           'src/modules/users/users.service.ts',    // Users service with multi-tenant support
           'src/modules/users/users.controller.ts', // Users controller with multi-tenant support
           'src/modules/users/create-user.dto.ts'   // CreateUserDto with businessId
         ],
 
         // Code sections to insert into base template files
+        // Note: main.ts uses PRIMARY_DOMAIN env var for dynamic CORS - no sections needed
         sections: {
-          'src/main.ts': [
-            'PROJECT_IMPORTS',              // Add project-related imports
-            'PROJECT_CUSTOM_DOMAINS',       // Add custom domains query
-            'PROJECT_CUSTOM_DOMAINS_CORS',  // Add custom domains to CORS
-            'PROJECT_GUARD'                 // Add ProjectOwnershipGuard registration
-          ],
           'src/modules/app/app.module.ts': [
             'PROJECTS_MODULE_IMPORT',       // Add ProjectsModule import
             'PROJECTS_MODULE'               // Add ProjectsModule to imports array
@@ -60,11 +52,15 @@ const VARIANT_CONFIG = {
         }
       },
 
-      // B2B2C variant: Adds regular_user support (for single-tenant only)
+      // B2B2C variant: Adds regular_user support with separate customer auth
       'b2b2c': {
         // Complete files to copy
         files: [
-          'src/modules/users/user-business.entity.ts',  // Business-to-user linking entity
+          'src/modules/users/user-business.entity.ts',           // Business-to-user linking entity
+          'src/modules/auth/auth-customer.ts',                   // Customer auth config (regular_user, customer_ cookie)
+          'src/modules/auth/better-auth-customer.controller.ts', // Customer auth controller (/api/auth/customer)
+          'src/modules/auth/auth.module.ts',                     // Auth module with customer controller
+          'src/modules/auth/better-auth.guard.ts',               // Guard handling both auth instances
         ],
 
         // Code sections to insert
@@ -77,6 +73,9 @@ const VARIANT_CONFIG = {
           'src/modules/users/users.module.ts': [
             'B2B2C_IMPORTS',           // Add UserBusiness import
             'B2B2C_ENTITIES'           // Add UserBusiness to TypeORM
+          ],
+          'src/database/migrations/1764300000001-CreateSessionsTable.ts': [
+            'B2B2C_TENANT_COLUMN'      // Add tenant_id column for session scoping
           ]
         }
       },
@@ -126,8 +125,7 @@ const VARIANT_CONFIG = {
         // Complete files to copy (has both multi-tenant and B2B2C features)
         files: [
           'src/modules/users/user-business.entity.ts',         // Business-to-user linking entity
-          'src/modules/auth/auth.service.ts',                  // Combined auth service
-          'src/modules/auth/auth.controller.ts',               // Combined auth controller
+          'src/modules/auth/auth.ts',                          // Combined Better Auth config
           'src/modules/users/users.service.ts',                // Combined users service
           'src/modules/users/users.controller.ts',             // Combined users controller
           'src/modules/domain/projects/projects.module.ts'     // Projects module with UserBusiness
@@ -180,9 +178,9 @@ const VARIANT_CONFIG = {
 
   // Admin portal inherits tenancy choice from backend
   'admin-portal': {
-    base: 'admin-portal/templates/base',
-    sectionsDir: 'admin-portal/templates/sections',
-    filesDir: 'admin-portal/templates/files',
+    base: 'admin-portal/base',
+    sectionsDir: 'admin-portal/variants/sections',
+    filesDir: 'admin-portal/variants/files',
 
     variants: {
       'multi-tenant': {
@@ -284,9 +282,9 @@ const VARIANT_CONFIG = {
 
   // Customers portal (B2B2C only - no pure B2B use case)
   'customers-portal': {
-    base: 'customers-portal/templates/base',  // B2B2C + Single-tenant base
-    sectionsDir: 'customers-portal/templates/sections',
-    filesDir: 'customers-portal/templates/files',
+    base: 'customers-portal/base',  // B2B2C + Single-tenant base
+    sectionsDir: 'customers-portal/variants/sections',
+    filesDir: 'customers-portal/variants/files',
 
     variants: {
       'single-tenant': {
@@ -310,6 +308,14 @@ const VARIANT_CONFIG = {
           'src/store/useProjectStore.ts'          // Project state
         ],
         sections: {}
+      },
+
+      'b2b2c': {
+        // B2B2C uses separate auth endpoint for customer sessions
+        files: [
+          'src/lib/auth-client.ts'                // Auth client with /api/auth/customer basePath
+        ],
+        sections: {}
       }
     },
 
@@ -321,9 +327,9 @@ const VARIANT_CONFIG = {
 
   // Infrastructure (Docker Compose orchestration)
   infrastructure: {
-    base: 'infrastructure',
-    sectionsDir: 'infrastructure/templates/sections',
-    filesDir: 'infrastructure/templates/files',
+    base: 'infrastructure/base',
+    sectionsDir: 'infrastructure/variants/sections',
+    filesDir: 'infrastructure/variants/files',
 
     variants: {
       // B2B2C variant: Adds customers-portal service to docker-compose files
@@ -395,6 +401,11 @@ function resolveVariantChoices(backendChoices) {
     choices['admin-portal'].userModel = backendChoices.userModel;
   }
 
+  // Special case: customers-portal inherits BOTH tenancy and userModel
+  if (choices['customers-portal']) {
+    choices['customers-portal'].userModel = backendChoices.userModel;
+  }
+
   // Special case: infrastructure needs BOTH tenancy and userModel for proper variant resolution
   if (choices['infrastructure']) {
     choices['infrastructure'].tenancy = backendChoices.tenancy;