@launchframe/cli 1.0.0-beta.8 → 1.0.0

package/src/utils/docker-helper.js

@@ -159,7 +159,6 @@ async function buildFullAppImages(projectRoot, projectName, githubOrg, envFilePa
       `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 || ''}`
     ];
@@ -245,15 +244,130 @@ async function buildWaitlistImage(projectRoot, projectName, githubOrg) {
     });
 
     spinner.succeed(`waitlist built and pushed successfully`);
+
+    // Clean up local image after push
+    const cleanupSpinner = ora('Cleaning up local waitlist image...').start();
+    try {
+      await execAsync(`docker rmi ${imageName}`, { timeout: 30000 });
+      cleanupSpinner.succeed('Cleaned up local waitlist image');
+    } catch (error) {
+      cleanupSpinner.info('Could not remove local waitlist image (may be in use)');
+    }
   } catch (error) {
     spinner.fail(`Failed to build waitlist`);
     throw new Error(`Build failed for waitlist: ${error.message}`);
   }
 }
 
+/**
+ * Clean up local Docker images after push
+ * @param {string} registry - Registry URL (e.g., 'ghcr.io/myorg')
+ * @param {string} projectName - Project name
+ * @param {string[]} services - List of services to clean up
+ * @returns {Promise<void>}
+ */
+async function cleanupLocalImages(registry, projectName, services) {
+  const spinner = ora('Cleaning up local Docker images...').start();
+
+  const imagesToRemove = services.map(service => `${registry}/${projectName}-${service}:latest`);
+  let removedCount = 0;
+
+  for (const imageName of imagesToRemove) {
+    try {
+      await execAsync(`docker rmi ${imageName}`, { timeout: 30000 });
+      removedCount++;
+    } catch (error) {
+      // Image might not exist or be in use, continue
+    }
+  }
+
+  if (removedCount > 0) {
+    spinner.succeed(`Cleaned up ${removedCount} local Docker image(s)`);
+  } else {
+    spinner.info('No local images to clean up');
+  }
+}
+
+/**
+ * Complete build and push workflow - checks Docker, logs in to GHCR, builds and pushes images
+ * @param {Object} options - Workflow options
+ * @param {string} options.projectRoot - Project root directory
+ * @param {string} options.projectName - Project name
+ * @param {string} options.githubOrg - GitHub organization/username
+ * @param {string} options.ghcrToken - GitHub Container Registry token
+ * @param {string} options.envProdPath - Path to .env.prod file
+ * @param {string[]} options.installedServices - List of installed services
+ * @param {string} [options.serviceName] - Optional specific service to build (if not provided, builds all)
+ * @returns {Promise<void>}
+ */
+async function buildAndPushWorkflow(options) {
+  const {
+    projectRoot,
+    projectName,
+    githubOrg,
+    ghcrToken,
+    envProdPath,
+    installedServices,
+    serviceName
+  } = options;
+
+  // Step 1: Check Docker is running
+  const dockerSpinner = ora('Checking Docker...').start();
+
+  const dockerRunning = await checkDockerRunning();
+  if (!dockerRunning) {
+    dockerSpinner.fail('Docker is not running');
+    throw new Error('Docker is not running. Please start Docker and try again.');
+  }
+
+  dockerSpinner.succeed('Docker is running');
+
+  // Step 2: Login to GHCR
+  if (!ghcrToken) {
+    throw new Error('GHCR token not found. Run deploy:configure to set up your GitHub token.');
+  }
+
+  await loginToGHCR(githubOrg, ghcrToken);
+
+  // Step 3: Build and push images
+  console.log(chalk.yellow('\n📦 Building and pushing images...\n'));
+
+  const registry = `ghcr.io/${githubOrg}`;
+
+  if (serviceName) {
+    // Build specific service
+    if (!installedServices.includes(serviceName)) {
+      throw new Error(`Service "${serviceName}" not found in installed services. Available: ${installedServices.join(', ')}`);
+    }
+
+    await buildAndPushImage(
+      serviceName,
+      path.join(projectRoot, serviceName),
+      registry,
+      projectName
+    );
+
+    // Clean up local image after push
+    await cleanupLocalImages(registry, projectName, [serviceName]);
+
+    console.log(chalk.green.bold(`\n✅ ${serviceName} built and pushed to GHCR!\n`));
+  } else {
+    // Build all services
+    await buildFullAppImages(projectRoot, projectName, githubOrg, envProdPath, installedServices);
+
+    // Clean up local images after push
+    await cleanupLocalImages(registry, projectName, installedServices);
+
+    console.log(chalk.green.bold('\n✅ All images built and pushed to GHCR!\n'));
+  }
+}
+
 module.exports = {
   checkDockerRunning,
   loginToGHCR,
+  buildAndPushImage,
   buildFullAppImages,
-  buildWaitlistImage
+  buildWaitlistImage,
+  buildAndPushWorkflow,
+  cleanupLocalImages
 };

package/src/utils/env-generator.js

@@ -25,28 +25,31 @@ async function generateEnvFile(projectRoot, answers) {
 
   // Generate secure secrets
   const secrets = {
-    JWT_SECRET: generateSecret(32),
+    BETTER_AUTH_SECRET: generateSecret(32),
     DB_PASSWORD: generateSecret(24),
     BULL_ADMIN_TOKEN: generateSecret(24)
   };
 
   // Create variable mappings
+  // Note: PRIMARY_DOMAIN and ADMIN_EMAIL are NOT replaced here - they stay as placeholders
+  // until deploy:configure and deploy:set-env are run
   const variables = {
     '{{PROJECT_NAME}}': answers.projectName,
     '{{PROJECT_NAME_UPPER}}': answers.projectNameUpper,
-    '{{PRIMARY_DOMAIN}}': answers.primaryDomain,
-    '{{ADMIN_EMAIL}}': answers.adminEmail,
+    '{{PROJECT_DISPLAY_NAME}}': answers.projectDisplayName,
 
     // 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_better_auth_secret_minimum_32_chars': secrets.BETTER_AUTH_SECRET,
     'your_bull_admin_token': secrets.BULL_ADMIN_TOKEN
   };
 
-  // Replace variables in template
+  // Replace variables in template (only those with defined values)
   let envContent = envTemplate;
   for (const [placeholder, value] of Object.entries(variables)) {
-    envContent = envContent.split(placeholder).join(value);
+    if (value !== undefined && value !== null) {
+      envContent = envContent.split(placeholder).join(value);
+    }
   }
 
   // Write .env file

package/src/utils/env-validator.js

@@ -59,13 +59,15 @@ async function validateEnvProd(envProdPath) {
 }
 
 /**
- * Generate a secure random string for secrets
+ * Generate a secure random string for secrets (URL-safe)
  * @param {number} length - Length of string to generate
  * @returns {string}
  */
 function generateSecret(length = 32) {
   const crypto = require('crypto');
-  return crypto.randomBytes(length).toString('base64').slice(0, length);
+  // Use hex encoding to avoid URL-unsafe characters (+, /, =)
+  // Hex produces 2 chars per byte, so divide by 2
+  return crypto.randomBytes(Math.ceil(length / 2)).toString('hex').slice(0, length);
 }
 
 module.exports = {

package/src/utils/github-access.js

@@ -14,14 +14,14 @@ function makeClickable(text, url) {
 }
 
 /**
- * Check if user has SSH access to LaunchFrame modules repository
+ * Check if user has SSH access to LaunchFrame services repository
  * @returns {Promise<{hasAccess: boolean, error?: string}>}
  */
 async function checkGitHubAccess() {
   try {
     // Test SSH access by checking if we can list remote refs
     execSync(
-      'git ls-remote git@github.com:launchframe-dev/modules.git HEAD',
+      'git ls-remote git@github.com:launchframe-dev/services.git HEAD',
       { 
         timeout: 15000,
         stdio: 'pipe' // Don't show output
@@ -37,27 +37,29 @@ async function checkGitHubAccess() {
 }
 
 /**
- * Display message when user doesn't have access to modules repository
- * Guides them to either purchase or setup SSH keys
+ * Display message when user doesn't have access to services repository
+ * Guides them to either get beta access or setup SSH keys
  */
 function showAccessDeniedMessage() {
-  const purchaseUrl = 'https://buy.polar.sh/polar_cl_Zy4YqEwhoIEdUrAH8vHaWuZtwZuv306sYMnq118MbKi';
+  const betaUrl = 'https://launchframe.dev/';
   const docsUrl = 'https://docs.launchframe.dev/guide/quick-start#add-ssh-key-to-repo';
-  
-  console.log(chalk.red('\n❌ Cannot access LaunchFrame modules repository\n'));
-  
+
+  console.log(chalk.red('\n❌ Cannot access LaunchFrame services repository\n'));
+
   console.log(chalk.white('This could mean:\n'));
-  console.log(chalk.gray('  1. You haven\'t purchased LaunchFrame yet'));
-  console.log(chalk.gray('  2. You purchased but haven\'t added your SSH key to the repo\n'));
-  
-  console.log(chalk.cyan('→ New customers:'));
-  console.log('  ' + chalk.blue.bold.underline(makeClickable('Purchase LaunchFrame', purchaseUrl)));
-  console.log('  ' + chalk.cyan(purchaseUrl + '\n'));
-  
-  console.log(chalk.cyan('→ Existing customers:'));
+  console.log(chalk.gray('  1. You don\'t have beta access yet'));
+  console.log(chalk.gray('  2. You have access but haven\'t added your SSH key to the repo\n'));
+
+  console.log(chalk.cyan('→ Get beta access:'));
+  console.log(chalk.white('  LaunchFrame is in open beta for 100 users.'));
+  console.log(chalk.white('  Get free lifetime access at:'));
+  console.log('  ' + chalk.blue.bold.underline(makeClickable('launchframe.dev', betaUrl)));
+  console.log('  ' + chalk.cyan(betaUrl + '\n'));
+
+  console.log(chalk.cyan('→ Already have access?'));
   console.log('  ' + chalk.blue.bold.underline(makeClickable('Setup SSH key (docs)', docsUrl)));
   console.log('  ' + chalk.cyan(docsUrl + '\n'));
-  
+
   console.log(chalk.gray('After setup, run: launchframe init\n'));
 }
 

package/src/utils/logger.js

@@ -0,0 +1,93 @@
+const chalk = require('chalk');
+
+/**
+ * Simple logger with verbose mode support
+ *
+ * Usage:
+ *   logger.setVerbose(true);
+ *   logger.info('Main message');    // Always shown
+ *   logger.detail('Nested detail'); // Only shown in verbose mode
+ */
+
+let verboseMode = false;
+
+/**
+ * Enable or disable verbose mode
+ * @param {boolean} enabled
+ */
+function setVerbose(enabled) {
+  verboseMode = enabled;
+}
+
+/**
+ * Check if verbose mode is enabled
+ * @returns {boolean}
+ */
+function isVerbose() {
+  return verboseMode;
+}
+
+/**
+ * Log a main info message (always shown)
+ * @param {string} message
+ */
+function info(message) {
+  console.log(message);
+}
+
+/**
+ * Log a success message (always shown)
+ * @param {string} message
+ */
+function success(message) {
+  console.log(chalk.green(message));
+}
+
+/**
+ * Log an error message (always shown)
+ * @param {string} message
+ */
+function error(message) {
+  console.error(chalk.red(message));
+}
+
+/**
+ * Log a warning message (always shown)
+ * @param {string} message
+ */
+function warn(message) {
+  console.warn(chalk.yellow(message));
+}
+
+/**
+ * Log a detail/nested message (only in verbose mode)
+ * @param {string} message
+ * @param {number} indent - Indentation level (default 1)
+ */
+function detail(message, indent = 1) {
+  if (verboseMode) {
+    const prefix = '  '.repeat(indent);
+    console.log(chalk.gray(`${prefix}${message}`));
+  }
+}
+
+/**
+ * Log a step within an operation (only in verbose mode)
+ * @param {string} message
+ */
+function step(message) {
+  if (verboseMode) {
+    console.log(chalk.gray(`  - ${message}`));
+  }
+}
+
+module.exports = {
+  setVerbose,
+  isVerbose,
+  info,
+  success,
+  error,
+  warn,
+  detail,
+  step
+};

package/src/utils/module-installer.js

@@ -0,0 +1,58 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+const { replaceSection } = require('./section-replacer');
+
+/**
+ * Install a module into a project
+ * @param {string} moduleName - Name of the module to install
+ * @param {Object} moduleConfig - Config object from MODULE_CONFIG[moduleName]
+ */
+async function installModule(moduleName, moduleConfig) {
+  const templateRoot = path.resolve(__dirname, '../../../services');
+  const cwd = process.cwd();
+
+  for (const [serviceName, config] of Object.entries(moduleConfig)) {
+    const moduleFilesDir = path.join(templateRoot, 'modules', moduleName, serviceName, 'files');
+    const moduleSectionsDir = path.join(templateRoot, 'modules', moduleName, serviceName, 'sections');
+    const serviceDir = path.join(cwd, serviceName);
+
+    // Copy files
+    for (const filePath of config.files) {
+      const src = path.join(moduleFilesDir, filePath);
+      const dest = path.join(serviceDir, filePath);
+      console.log(`  Adding ${filePath}`);
+      await fs.copy(src, dest, { overwrite: true });
+    }
+
+    // Inject sections
+    for (const [targetFile, markerNames] of Object.entries(config.sections)) {
+      const targetFilePath = path.join(serviceDir, targetFile);
+      const targetBasename = path.basename(targetFile);
+
+      for (const markerName of markerNames) {
+        const sectionFile = path.join(moduleSectionsDir, `${targetBasename}.${markerName}`);
+        console.log(`  Injecting ${markerName} into ${targetFile}`);
+        const sectionContent = await fs.readFile(sectionFile, 'utf8');
+        await replaceSection(targetFilePath, markerName, sectionContent);
+      }
+    }
+
+    // Merge dependencies into package.json and sync lockfile
+    if (config.dependencies && Object.keys(config.dependencies).length > 0) {
+      const packageJsonPath = path.join(serviceDir, 'package.json');
+      const packageJson = await fs.readJson(packageJsonPath);
+      packageJson.dependencies = {
+        ...packageJson.dependencies,
+        ...config.dependencies,
+      };
+      await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+
+      // Run npm install to sync package-lock.json, otherwise `npm ci` will fail on rebuild
+      console.log(`\nRunning npm install in ${serviceName}...`);
+      execSync('npm install', { cwd: serviceDir, stdio: 'inherit' });
+    }
+  }
+}
+
+module.exports = { installModule };

package/src/utils/project-helpers.js

@@ -95,6 +95,36 @@ function isWaitlistInstalled(config = null) {
   return (config.installedServices || []).includes('waitlist');
 }
 
+/**
+ * Get list of installed modules
+ */
+function getInstalledModules() {
+  const config = getProjectConfig();
+  return config.installedModules || [];
+}
+
+/**
+ * Check if a module is installed
+ */
+function isModuleInstalled(moduleName) {
+  const installedModules = getInstalledModules();
+  return installedModules.includes(moduleName);
+}
+
+/**
+ * Add a module to the installed modules list
+ */
+function addInstalledModule(moduleName) {
+  const config = getProjectConfig();
+  if (!config.installedModules) {
+    config.installedModules = [];
+  }
+  if (!config.installedModules.includes(moduleName)) {
+    config.installedModules.push(moduleName);
+    updateProjectConfig(config);
+  }
+}
+
 module.exports = {
   isLaunchFrameProject,
   requireProject,
@@ -104,5 +134,8 @@ module.exports = {
   isComponentInstalled,
   addInstalledComponent,
   getPrimaryDomain,
-  isWaitlistInstalled
+  isWaitlistInstalled,
+  getInstalledModules,
+  isModuleInstalled,
+  addInstalledModule
 };