@launchframe/cli 0.1.6

package/src/services/variant-config.js

@@ -0,0 +1,349 @@
+/**
+ * Variant Configuration
+ *
+ * Defines how to ADD functionality to the base template via variants.
+ * Follows open-closed principle: base is minimal, variants ADD features.
+ *
+ * Two types of additions:
+ * - SECTIONS: Code snippets inserted into base template files (via {{MARKERS}})
+ * - FILES: Complete files/folders copied to the project
+ */
+
+const VARIANT_CONFIG = {
+  backend: {
+    base: 'backend/templates/base',
+    sectionsDir: 'backend/templates/sections',
+    filesDir: 'backend/templates/files',
+
+    variants: {
+      // Multi-tenant variant: Adds project/workspace support
+      'multi-tenant': {
+        // Complete files/folders to copy
+        files: [
+          'src/modules/domain/projects',           // Entire projects module
+          'src/modules/domain/jwt-auth',           // JWT auth module (project-specific JWT issuance)
+          'src/modules/domain/ai/services/project-config.service.ts', // Project config service
+          'src/guards/project-ownership.guard.ts', // Project ownership guard
+          '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 and recoveryCode
+        ],
+
+        // Code sections to insert into base template files
+        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
+            'JWT_AUTH_MODULE_IMPORT',       // Add JwtAuthModule import
+            'JWT_AUTH_MODULE'               // Add JwtAuthModule to imports array
+          ],
+          'src/modules/auth/auth.module.ts': [
+            'MULTI_TENANT_IMPORTS',         // Add Project entity import
+            'MULTI_TENANT_TYPEORM'          // Add Project to TypeOrmModule
+          ],
+          'src/modules/users/user.entity.ts': [
+            'PROJECTS_RELATIONSHIP_IMPORT', // Add Project entity import
+            'PROJECTS_RELATIONSHIP'         // Add projects relationship
+          ],
+          'src/modules/users/users.module.ts': [
+            'MULTI_TENANT_IMPORTS',          // Add Projects-related imports
+            'MULTI_TENANT_SERVICE_IMPORTS',  // Add JWT auth service imports
+            'MULTI_TENANT_ENTITIES',         // Add Project entities to TypeORM
+            'MULTI_TENANT_MODULE_IMPORTS',   // Add ProjectsModule to imports
+            'MULTI_TENANT_PROVIDERS'         // Add multi-tenant providers
+          ]
+        }
+      },
+
+      // B2B2C variant: Adds regular_user support
+      'b2b2c': {
+        // Complete files to copy
+        files: [
+          'src/modules/users/user-business.entity.ts'  // Business-to-user linking entity
+        ],
+
+        // Code sections to insert
+        sections: {
+          'src/modules/users/user.entity.ts': [
+            'B2B2C_IMPORTS',           // Add UserBusiness import
+            'B2B2C_USER_ROLE',         // Add REGULAR_USER enum value
+            'B2B2C_RELATIONSHIPS'      // Add userBusinesses relationship
+          ],
+          'src/modules/users/users.module.ts': [
+            'B2B2C_IMPORTS',           // Add UserBusiness import
+            'B2B2C_ENTITIES'           // Add UserBusiness to TypeORM
+          ]
+        }
+      }
+    },
+
+    // Variant selection prompts
+    prompts: {
+      tenancy: {
+        message: 'Will your application have multiple workspaces/projects per user?',
+        choices: [
+          {
+            name: 'Single-tenant (one instance per user) - Simpler data model',
+            value: 'single-tenant',
+            description: 'Each user has one instance. Simpler architecture without project isolation.',
+            isDefault: true  // Base template is single-tenant
+          },
+          {
+            name: 'Multi-tenant (workspaces/projects) - Users can create multiple projects',
+            value: 'multi-tenant',
+            description: 'Each user can create multiple isolated workspaces. Data is scoped by project context.'
+          }
+        ],
+        default: 'single-tenant'
+      },
+
+      userModel: {
+        message: 'Who will use your application?',
+        choices: [
+          {
+            name: 'B2B (Business users only) - Organization employees manage the system',
+            value: 'b2b',
+            description: 'Only business users (your customers) access the system. No end-user portal.',
+            isDefault: true  // Base template is B2B
+          },
+          {
+            name: 'B2B2C (Business + End customers) - Business users manage their customers',
+            value: 'b2b2c',
+            description: 'Business users manage their end customers (regular_user type). Adds customer relationships.'
+          }
+        ],
+        default: 'b2b'
+      }
+    }
+  },
+
+  // Admin portal inherits tenancy choice from backend
+  'admin-portal': {
+    base: 'admin-portal/templates/base',
+    sectionsDir: 'admin-portal/templates/sections',
+    filesDir: 'admin-portal/templates/files',
+
+    variants: {
+      'multi-tenant': {
+        // Complete files to copy (multi-tenant only components)
+        files: [
+          'src/components/projects/ProjectsSelect.tsx',      // Project selector dropdown
+          'src/components/projects/NewProject.tsx',          // Create project dialog
+          'src/pages/FirstProject.tsx',                      // Onboarding page
+          'src/api/projectRequests.ts',                      // Project API calls
+          'src/components/ProjectDetailsOnAuthPage.tsx',     // Recovery code flow
+          'src/components/ProjectFrontendLink.tsx',          // Project navigation link
+          'src/components/settings/CustomDomain.tsx',        // Custom domain settings (multi-tenant only)
+          'src/components/settings/ProjectSettings.tsx'      // Project settings (multi-tenant only)
+        ],
+
+        // Code sections to insert into base template files
+        sections: {
+          'src/redux/user/userSlice.ts': [
+            'TYPES_IMPORT',             // Add Project type to imports
+            'PROJECTS_STATE',           // Add projects state to interface
+            'PROJECTS_STATE_INITIAL',   // Initialize projects in initial state
+            'PROJECTS_INITIALIZATION',  // Initialize projects on profile fetch
+            'PROJECTS_REDUCERS',        // Add setSelectedProject reducer
+            'PROJECTS_EXPORTS',         // Export setSelectedProject action
+            'PROJECTS_SELECTOR'         // Export selectSelectedProject selector
+          ],
+          'src/api/client.ts': [
+            'STORE_IMPORT',             // Import Redux store
+            'PROJECT_HEADER'            // Add X-Project-Id header to requests
+          ],
+          'src/components/Layout.tsx': [
+            'PROJECT_STATE',            // Extract project state from Redux
+            'FIRST_PROJECT_CHECKS'      // Add loading state for missing project
+          ],
+          'src/components/ui/SaMenu.tsx': [
+            'PROJECTS_SELECT_IMPORT',   // Import ProjectsSelect component
+            'PROJECTS_SELECT_COMPONENT' // Render ProjectsSelect in sidebar
+          ],
+          'src/pages/auth/Login.tsx': [
+            'ROUTER_IMPORTS',           // Add useNavigate, useSearchParams to imports
+            'PROJECT_DETAILS_IMPORT',   // Import ProjectDetailsOnAuthPage
+            'PROJECT_DETAILS_HANDLER',  // Handler for project retrieval
+            'PROJECT_DETAILS_COMPONENT' // Render ProjectDetailsOnAuthPage
+          ],
+          'src/pages/auth/SignUp.tsx': [
+            'REACT_IMPORTS',               // Add useState to React imports
+            'PROJECT_DETAILS_IMPORT',      // Import ProjectDetailsOnAuthPage
+            'PROJECT_DETAILS_STATE',       // State for recovery code
+            'PROJECT_DETAILS_COMPONENT',   // Render ProjectDetailsOnAuthPage
+            'RECOVERY_CODE_PROP_GOOGLE',   // Pass recovery code to GoogleLogin
+            'RECOVERY_CODE_PROP_FORM'      // Pass recovery code to SignUpForm
+          ],
+          'src/pages/Settings.tsx': [
+            'MULTI_TENANT_SETTINGS_IMPORTS',  // Import ProjectSettings and CustomDomain
+            'MULTI_TENANT_SETTINGS_STATE',    // Set default activeTab to 'project'
+            'MULTI_TENANT_SETTINGS_TABS',     // Add Project and Custom Domain tabs
+            'MULTI_TENANT_SETTINGS_CONTENT'   // Render ProjectSettings and CustomDomain
+          ],
+          'src/App.tsx': [
+            'SET_SELECTED_PROJECT_IMPORT', // Import setSelectedProject action
+            'FIRST_PROJECT_IMPORT',        // Import FirstProject component
+            'FIRST_PROJECT_ROUTE_GUARD',   // Add FirstProjectRoute guard
+            'USER_ROUTE_VARIABLES',        // Add user and location variables for onboarding
+            'USER_ROUTE_ONBOARDING_CHECK', // Redirect to /first-project
+            'PROJECT_QUERY_PARAM_HANDLER', // Handle ?project= query param
+            'FIRST_PROJECT_ROUTE'          // Add /first-project route
+          ],
+          'src/types/index.ts': [
+            'PROJECTS_FIELD'            // Add projects field to User interface
+          ]
+        }
+      },
+
+      'b2b2c': {
+        files: [
+          'src/pages/Users.tsx'         // Users page for managing end customers
+        ],
+
+        sections: {
+          'src/components/Layout.tsx': [
+            'B2B2C_USER_ICON_IMPORT',   // Import UserIcon for Users menu
+            'B2B2C_USERS_MENU'          // Add Users menu item for customer management
+          ],
+          'src/App.tsx': [
+            'B2B2C_USERS_IMPORT',       // Import Users page component
+            'B2B2C_USERS_ROUTE'         // Add /users route
+          ]
+        }
+      }
+    },
+
+    linkedTo: 'backend.tenancy'
+  },
+
+  // Customers portal (for B2B2C regular_user access)
+  'customers-portal': {
+    base: 'customers-portal/templates/base',
+    sectionsDir: 'customers-portal/templates/sections',
+    filesDir: 'customers-portal/templates/files',
+
+    variants: {
+      'multi-tenant': {
+        files: [],
+        sections: {}
+      }
+    },
+
+    linkedTo: 'backend.tenancy'
+  },
+
+  // Infrastructure (Docker Compose orchestration)
+  infrastructure: {
+    base: 'infrastructure',
+    sectionsDir: 'infrastructure/templates/sections',
+    filesDir: 'infrastructure/templates/files',
+
+    variants: {
+      // B2B2C variant: Adds customers-portal service to docker-compose files
+      'b2b2c': {
+        files: [],
+
+        sections: {
+          'docker-compose.yml': [
+            'B2B2C_CUSTOMERS_PORTAL_SERVICE'
+          ],
+          'docker-compose.dev.yml': [
+            'B2B2C_CUSTOMERS_PORTAL_SERVICE',
+            'B2B2C_CUSTOMERS_PORTAL_VOLUMES'
+          ],
+          'docker-compose.prod.yml': [
+            'B2B2C_CUSTOMERS_PORTAL_SERVICE'
+          ]
+        }
+      }
+    },
+
+    linkedTo: 'backend.userModel'
+  }
+};
+
+/**
+ * Get variant configuration for a service
+ * @param {string} serviceName - Service name (backend, admin-portal, etc.)
+ * @returns {object|null} Service variant configuration
+ */
+function getVariantConfig(serviceName) {
+  return VARIANT_CONFIG[serviceName] || null;
+}
+
+/**
+ * Get variant prompts for user selection
+ * @returns {object} Prompts configuration
+ */
+function getVariantPrompts() {
+  return VARIANT_CONFIG.backend.prompts;
+}
+
+/**
+ * Resolve variant choices for all services
+ * @param {object} backendChoices - User's choices for backend variants
+ * @returns {object} Variant choices for all services
+ */
+function resolveVariantChoices(backendChoices) {
+  const choices = {
+    backend: backendChoices
+  };
+
+  // Resolve linked services
+  Object.keys(VARIANT_CONFIG).forEach(serviceName => {
+    if (serviceName === 'backend') return;
+
+    const serviceConfig = VARIANT_CONFIG[serviceName];
+    if (serviceConfig.linkedTo) {
+      // Parse linkedTo (e.g., "backend.tenancy")
+      const [linkedService, linkedDimension] = serviceConfig.linkedTo.split('.');
+      choices[serviceName] = {
+        [linkedDimension]: backendChoices[linkedDimension]
+      };
+    }
+  });
+
+  // Special case: admin-portal inherits BOTH tenancy and userModel
+  if (choices['admin-portal']) {
+    choices['admin-portal'].userModel = backendChoices.userModel;
+  }
+
+  return choices;
+}
+
+/**
+ * Get variants to apply (exclude defaults)
+ * @param {object} choices - User's variant selections
+ * @returns {string[]} List of variant names to apply
+ */
+function getVariantsToApply(choices) {
+  const variantsToApply = [];
+
+  // Add multi-tenant if selected
+  if (choices.tenancy === 'multi-tenant') {
+    variantsToApply.push('multi-tenant');
+  }
+
+  // Add b2b2c if selected
+  if (choices.userModel === 'b2b2c') {
+    variantsToApply.push('b2b2c');
+  }
+
+  return variantsToApply;
+}
+
+module.exports = {
+  VARIANT_CONFIG,
+  getVariantConfig,
+  getVariantPrompts,
+  resolveVariantChoices,
+  getVariantsToApply
+};

package/src/utils/docker-helper.js

@@ -0,0 +1,237 @@
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const ora = require('ora');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if Docker is running
+ * @returns {Promise<boolean>}
+ */
+async function checkDockerRunning() {
+  try {
+    await execAsync('docker info', { timeout: 5000 });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Login to GitHub Container Registry
+ * @param {string} githubOrg - GitHub organization/username
+ * @param {string} ghcrToken - GitHub Personal Access Token
+ * @returns {Promise<void>}
+ */
+async function loginToGHCR(githubOrg, ghcrToken) {
+  const spinner = ora('Logging in to GitHub Container Registry...').start();
+
+  try {
+    await execAsync(
+      `echo "${ghcrToken}" | docker login ghcr.io -u ${githubOrg} --password-stdin`,
+      { timeout: 30000 }
+    );
+    spinner.succeed('Logged in to GHCR');
+  } catch (error) {
+    spinner.fail('Failed to login to GHCR');
+    throw new Error(`GHCR login failed: ${error.message}`);
+  }
+}
+
+/**
+ * Build and push a Docker image
+ * @param {string} serviceName - Service name (e.g., 'backend', 'admin-frontend')
+ * @param {string} contextDir - Docker build context directory
+ * @param {string} registry - Registry URL (e.g., 'ghcr.io/myorg')
+ * @param {string} projectName - Project name
+ * @param {string[]} buildArgs - Array of build arguments (e.g., ['KEY=value'])
+ * @returns {Promise<void>}
+ */
+async function buildAndPushImage(serviceName, contextDir, registry, projectName, buildArgs = []) {
+  const imageName = `${registry}/${projectName}-${serviceName}:latest`;
+
+  console.log(chalk.blue(`\n🐳 Building ${serviceName}...\n`));
+
+  const spinner = ora(`Building ${serviceName} image...`).start();
+
+  try {
+    // Build image
+    const buildArgsStr = buildArgs.map(arg => `--build-arg "${arg}"`).join(' ');
+    const buildCmd = `docker build --target production --tag ${imageName} ${buildArgsStr} ${contextDir}`;
+
+    await execAsync(buildCmd, {
+      timeout: 600000, // 10 minutes per service
+      maxBuffer: 10 * 1024 * 1024 // 10MB buffer for build output
+    });
+
+    spinner.text = `Pushing ${serviceName} to registry...`;
+
+    // Push image
+    await execAsync(`docker push ${imageName}`, {
+      timeout: 600000 // 10 minutes for push
+    });
+
+    spinner.succeed(`${serviceName} built and pushed successfully`);
+  } catch (error) {
+    spinner.fail(`Failed to build ${serviceName}`);
+    throw new Error(`Build failed for ${serviceName}: ${error.message}`);
+  }
+}
+
+/**
+ * Load environment variables from .env.prod
+ * @param {string} envFilePath - Path to .env.prod file
+ * @returns {Object} Environment variables as key-value pairs
+ */
+function loadEnvFile(envFilePath) {
+  const envContent = fs.readFileSync(envFilePath, 'utf8');
+  const envVars = {};
+
+  envContent.split('\n').forEach(line => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) return;
+
+    const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+    if (match) {
+      const [, key, value] = match;
+      // Remove surrounding quotes if present
+      envVars[key] = value.replace(/^["']|["']$/g, '');
+    }
+  });
+
+  return envVars;
+}
+
+/**
+ * Build all production images for full app
+ * @param {string} projectRoot - Project root directory
+ * @param {string} projectName - Project name
+ * @param {string} githubOrg - GitHub organization/username
+ * @param {string} envFilePath - Path to .env.prod file
+ * @returns {Promise<void>}
+ */
+async function buildFullAppImages(projectRoot, projectName, githubOrg, envFilePath) {
+  const registry = `ghcr.io/${githubOrg}`;
+  const envVars = loadEnvFile(envFilePath);
+
+  console.log(chalk.yellow('\n📦 Building production Docker images...\n'));
+  console.log(chalk.gray('This may take 10-20 minutes depending on your system.\n'));
+
+  // Build backend
+  await buildAndPushImage(
+    'backend',
+    path.join(projectRoot, 'backend'),
+    registry,
+    projectName
+  );
+
+  // Build admin-frontend
+  await buildAndPushImage(
+    'admin-frontend',
+    path.join(projectRoot, 'admin-frontend'),
+    registry,
+    projectName
+  );
+
+  // Build customers-frontend
+  await buildAndPushImage(
+    'customers-frontend',
+    path.join(projectRoot, 'frontend'),
+    registry,
+    projectName
+  );
+
+  // Build website (requires build args)
+  const websiteBuildArgs = [
+    `APP_NAME=${envVars.APP_NAME || ''}`,
+    `DOCS_URL=${envVars.DOCS_URL || ''}`,
+    `CONTACT_EMAIL=${envVars.CONTACT_EMAIL || ''}`,
+    `CTA_LINK=${envVars.CTA_LINK || ''}`,
+    `LIVE_DEMO_URL=${envVars.LIVE_DEMO_URL || ''}`,
+    `MIXPANEL_PROJECT_TOKEN=${envVars.MIXPANEL_PROJECT_TOKEN || ''}`,
+    `GOOGLE_ANALYTICS_ID=${envVars.GOOGLE_ANALYTICS_ID || ''}`
+  ];
+
+  await buildAndPushImage(
+    'website',
+    path.join(projectRoot, 'website'),
+    registry,
+    projectName,
+    websiteBuildArgs
+  );
+}
+
+/**
+ * Build waitlist image
+ * @param {string} projectRoot - Project root directory
+ * @param {string} projectName - Project name (unused for waitlist, kept for API compatibility)
+ * @param {string} githubOrg - GitHub organization/username
+ * @returns {Promise<void>}
+ */
+async function buildWaitlistImage(projectRoot, projectName, githubOrg) {
+  const registry = `ghcr.io/${githubOrg}`;
+  const waitlistPath = path.join(projectRoot, 'waitlist');
+  const imageName = `${registry}/waitlist:latest`;
+
+  console.log(chalk.yellow('\n📦 Building waitlist Docker image...\n'));
+  console.log(chalk.gray(`Project root: ${projectRoot}`));
+  console.log(chalk.gray(`Waitlist path: ${waitlistPath}\n`));
+
+  // Load environment variables from waitlist .env.prod file (for production build)
+  const waitlistEnvProdPath = path.join(waitlistPath, '.env.prod');
+  const waitlistEnvPath = path.join(waitlistPath, '.env');
+
+  // Prefer .env.prod for deployment, fallback to .env
+  const envFilePath = fs.existsSync(waitlistEnvProdPath) ? waitlistEnvProdPath : waitlistEnvPath;
+  let buildArgs = [];
+
+  if (fs.existsSync(envFilePath)) {
+    const envVars = loadEnvFile(envFilePath);
+    buildArgs = [
+      `AIRTABLE_PERSONAL_ACCESS_TOKEN=${envVars.AIRTABLE_PERSONAL_ACCESS_TOKEN || ''}`,
+      `AIRTABLE_BASE_ID=${envVars.AIRTABLE_BASE_ID || ''}`,
+      `AIRTABLE_TABLE_NAME=${envVars.AIRTABLE_TABLE_NAME || 'Waitlist'}`,
+      `NEXT_PUBLIC_PROJECT_NAME=${envVars.NEXT_PUBLIC_PROJECT_NAME || envVars.PROJECT_NAME || ''}`,
+      `NEXT_PUBLIC_SITE_URL=${envVars.NEXT_PUBLIC_SITE_URL || ''}`,
+      `PROJECT_NAME=${envVars.PROJECT_NAME || ''}`,
+      `PRIMARY_DOMAIN=${envVars.PRIMARY_DOMAIN || ''}`
+    ];
+  }
+
+  console.log(chalk.blue(`\n🐳 Building waitlist...\n`));
+
+  const spinner = ora(`Building waitlist image...`).start();
+
+  try {
+    // Build image
+    const buildArgsStr = buildArgs.map(arg => `--build-arg "${arg}"`).join(' ');
+    const buildCmd = `docker build --tag ${imageName} ${buildArgsStr} ${waitlistPath}`;
+
+    await execAsync(buildCmd, {
+      timeout: 600000, // 10 minutes
+      maxBuffer: 10 * 1024 * 1024 // 10MB buffer for build output
+    });
+
+    spinner.text = `Pushing waitlist to registry...`;
+
+    // Push image
+    await execAsync(`docker push ${imageName}`, {
+      timeout: 600000 // 10 minutes for push
+    });
+
+    spinner.succeed(`waitlist built and pushed successfully`);
+  } catch (error) {
+    spinner.fail(`Failed to build waitlist`);
+    throw new Error(`Build failed for waitlist: ${error.message}`);
+  }
+}
+
+module.exports = {
+  checkDockerRunning,
+  loginToGHCR,
+  buildFullAppImages,
+  buildWaitlistImage
+};

package/src/utils/env-generator.js

@@ -0,0 +1,88 @@
+const fs = require('fs-extra');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Generate a secure random string
+ * @param {number} length - Length of the string
+ * @returns {string} Random hex string
+ */
+function generateSecret(length = 32) {
+  return crypto.randomBytes(length).toString('hex');
+}
+
+/**
+ * Generate environment file from .env.example
+ * @param {string} projectRoot - Root directory of the generated project
+ * @param {Object} answers - User answers from prompts
+ */
+async function generateEnvFile(projectRoot, answers) {
+  const envExamplePath = path.join(projectRoot, 'infrastructure', '.env.example');
+  const envPath = path.join(projectRoot, 'infrastructure', '.env');
+
+  // Read .env.example
+  const envTemplate = await fs.readFile(envExamplePath, 'utf8');
+
+  // Generate secure secrets
+  const secrets = {
+    JWT_SECRET: generateSecret(32),
+    DB_PASSWORD: generateSecret(24),
+    BULL_ADMIN_TOKEN: generateSecret(24)
+  };
+
+  // Create variable mappings
+  const variables = {
+    '{{PROJECT_NAME}}': answers.projectName,
+    '{{PROJECT_NAME_UPPER}}': answers.projectNameUpper,
+    '{{PRIMARY_DOMAIN}}': answers.primaryDomain,
+    '{{ADMIN_EMAIL}}': answers.adminEmail,
+
+    // Replace placeholder passwords with generated secrets
+    'your_secure_postgres_password': secrets.DB_PASSWORD,
+    'your_jwt_secret_key_change_this_in_production': secrets.JWT_SECRET,
+    'your_bull_admin_token': secrets.BULL_ADMIN_TOKEN
+  };
+
+  // Replace variables in template
+  let envContent = envTemplate;
+  for (const [placeholder, value] of Object.entries(variables)) {
+    envContent = envContent.split(placeholder).join(value);
+  }
+
+  // Write .env file
+  await fs.writeFile(envPath, envContent, 'utf8');
+
+  return {
+    envPath,
+    secrets
+  };
+}
+
+/**
+ * Update environment file with component-specific variables
+ * @param {string} envPath - Path to .env file
+ * @param {string} componentName - Name of the component
+ * @param {Object} envVarSchema - Schema of env vars (key: description)
+ * @param {Object} values - Actual values for the env vars
+ */
+async function updateEnvFile(envPath, componentName, envVarSchema, values) {
+  // Read existing .env file
+  let envContent = await fs.readFile(envPath, 'utf8');
+
+  // Add section header for component
+  envContent += `\n\n# ${componentName.charAt(0).toUpperCase() + componentName.slice(1)} Component\n`;
+
+  // Add each env var
+  for (const [key, description] of Object.entries(envVarSchema)) {
+    envContent += `${key}=${values[key]}\n`;
+  }
+
+  // Write back to file
+  await fs.writeFile(envPath, envContent, 'utf8');
+}
+
+module.exports = {
+  generateEnvFile,
+  generateSecret,
+  updateEnvFile
+};