@launchframe/cli 1.0.0-beta.8 → 1.0.0-beta.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@launchframe/cli",
-  "version": "1.0.0-beta.8",
+  "version": "1.0.0-beta.9",
   "description": "Production-ready B2B SaaS boilerplate with subscriptions, credits, and multi-tenancy",
   "main": "src/index.js",
   "bin": {

package/src/commands/cache.js

@@ -1,11 +1,11 @@
 const chalk = require('chalk');
-const { clearCache, getCacheInfo } = require('../utils/module-cache');
+const { clearCache, getCacheInfo } = require('../utils/service-cache');
 
 /**
- * Clear module cache
+ * Clear service cache
  */
 async function cacheClear() {
-  console.log(chalk.yellow('\n⚠️  This will delete all cached modules'));
+  console.log(chalk.yellow('\n⚠️  This will delete all cached services'));
   console.log(chalk.gray('You will need to re-download on next init or service:add\n'));
   
   const inquirer = require('inquirer');
@@ -30,7 +30,7 @@ async function cacheClear() {
 async function cacheInfo() {
   const info = await getCacheInfo();
   
-  console.log(chalk.blue('\n📦 Module Cache Information\n'));
+  console.log(chalk.blue('\n📦 Service Cache Information\n'));
   
   console.log(chalk.white('Location:'));
   console.log(chalk.gray(`  ${info.path}\n`));
@@ -54,14 +54,14 @@ async function cacheInfo() {
     console.log(chalk.gray(`  ${info.lastUpdate.toLocaleString()}\n`));
   }
   
-  if (info.modules && info.modules.length > 0) {
-    console.log(chalk.white('Cached Modules:'));
-    info.modules.forEach(mod => {
+  if (info.services && info.services.length > 0) {
+    console.log(chalk.white('Cached Services:'));
+    info.services.forEach(mod => {
       console.log(chalk.gray(`  • ${mod}`));
     });
     console.log('');
   } else {
-    console.log(chalk.gray('No modules cached yet\n'));
+    console.log(chalk.gray('No services cached yet\n'));
   }
   
   console.log(chalk.gray('Commands:'));
@@ -73,21 +73,21 @@ async function cacheInfo() {
  * Force update cache
  */
 async function cacheUpdate() {
-  const { ensureCacheReady, getCacheInfo } = require('../utils/module-cache');
+  const { ensureCacheReady, getCacheInfo } = require('../utils/service-cache');
   
   console.log(chalk.blue('\n🔄 Forcing cache update...\n'));
   
   try {
     const info = await getCacheInfo();
-    const currentModules = info.modules || [];
+    const currentServices = info.services || [];
     
-    if (currentModules.length === 0) {
-      console.log(chalk.yellow('No modules in cache yet. Use init or service:add to populate.\n'));
+    if (currentServices.length === 0) {
+      console.log(chalk.yellow('No services in cache yet. Use init or service:add to populate.\n'));
       return;
     }
     
-    // Update cache with current modules
-    await ensureCacheReady(currentModules);
+    // Update cache with current services
+    await ensureCacheReady(currentServices);
     console.log(chalk.green('\n✓ Cache updated successfully\n'));
   } catch (error) {
     console.error(chalk.red(`\n❌ Failed to update cache: ${error.message}\n`));

package/src/commands/help.js

@@ -40,7 +40,7 @@ function help() {
     console.log(chalk.white('Available Services:'));
     console.log(chalk.gray('  waitlist          Coming soon page with email collection\n'));
     console.log(chalk.white('Cache Management:'));
-    console.log(chalk.gray('  cache:info        Show cache location, size, and cached modules'));
+    console.log(chalk.gray('  cache:info        Show cache location, size, and cached services'));
     console.log(chalk.gray('  cache:update      Force update cache to latest version'));
     console.log(chalk.gray('  cache:clear       Delete cache (re-download on next use)\n'));
     console.log(chalk.white('Other commands:'));
@@ -75,7 +75,7 @@ function help() {
     console.log(chalk.gray('    --user-model <b2b|b2b2c>  User model (skips prompt)'));
     console.log(chalk.gray('  help                        Show this help message\n'));
     console.log(chalk.white('Cache Management:'));
-    console.log(chalk.gray('  cache:info        Show cache location, size, and cached modules'));
+    console.log(chalk.gray('  cache:info        Show cache location, size, and cached services'));
     console.log(chalk.gray('  cache:update      Force update cache to latest version'));
     console.log(chalk.gray('  cache:clear       Delete cache (re-download on next use)\n'));
     console.log(chalk.white('Examples:'));

package/src/commands/init.js

@@ -4,7 +4,7 @@ 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');
+const { ensureCacheReady } = require('../utils/service-cache');
 const { isLaunchFrameProject } = require('../utils/project-helpers');
 
 /**
@@ -116,8 +116,8 @@ async function init(options = {}) {
       variantChoices = await runVariantPrompts();
     }
 
-    // Determine which modules are needed based on variant choices
-    const requiredModules = [
+    // Determine which services are needed based on variant choices
+    const requiredServices = [
       'backend',
       'admin-portal',
       'infrastructure',
@@ -126,20 +126,20 @@ async function init(options = {}) {
     
     // Add customers-portal only if B2B2C mode
     if (variantChoices.userModel === 'b2b2c') {
-      requiredModules.push('customers-portal');
+      requiredServices.push('customers-portal');
     }
 
     // Determine template source (dev mode = local, production = cache)
     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`));
+      // Dev mode: Use local services directory
+      templateRoot = path.resolve(__dirname, '../../../services');
+      console.log(chalk.gray(`[DEV MODE] Using local services: ${templateRoot}\n`));
     } 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`));
         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);

package/src/generator.js

@@ -142,7 +142,7 @@ 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/)
+  // Step 5: Copy additional files (from project root, not services/)
   console.log('📋 Copying additional files...');
   const additionalFiles = [
     '.github',
@@ -174,13 +174,13 @@ async function generateProject(answers, variantChoices, templateRoot) {
   // Step 7: Create .launchframe marker file with variant metadata
   console.log('📝 Creating LaunchFrame 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(),

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,14 +37,14 @@ async function checkGitHubAccess() {
 }
 
 /**
- * Display message when user doesn't have access to modules repository
+ * Display message when user doesn't have access to services repository
  * Guides them to either purchase or setup SSH keys
  */
 function showAccessDeniedMessage() {
   const purchaseUrl = 'https://buy.polar.sh/polar_cl_Zy4YqEwhoIEdUrAH8vHaWuZtwZuv306sYMnq118MbKi';
   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'));

package/src/utils/{module-cache.js → service-cache.js}

@@ -4,7 +4,7 @@ const os = require('os');
 const { execSync } = require('child_process');
 const chalk = require('chalk');
 
-const MODULES_REPO = 'git@github.com:launchframe-dev/modules.git';
+const SERVICES_REPO = 'git@github.com:launchframe-dev/services.git';
 const BRANCH = 'main';
 
 /**
@@ -15,9 +15,9 @@ const BRANCH = 'main';
 function getCacheDir() {
   const homeDir = os.homedir();
   // Use same path structure on all platforms
-  // Windows: C:\Users\username\.launchframe\cache\modules
-  // Mac/Linux: /home/username/.launchframe/cache/modules
-  return path.join(homeDir, '.launchframe', 'cache', 'modules');
+  // Windows: C:\Users\username\.launchframe\cache\services
+  // Mac/Linux: /home/username/.launchframe/cache/services
+  return path.join(homeDir, '.launchframe', 'cache', 'services');
 }
 
 /**
@@ -32,33 +32,33 @@ async function cacheExists() {
 
 /**
  * Initialize cache with sparse checkout
- * Clones only the repository structure, no modules yet
+ * Clones only the repository structure, no services yet
  * @returns {Promise<void>}
  */
 async function initializeCache() {
   const cacheDir = getCacheDir();
-  
-  console.log(chalk.blue('🔄 Initializing module cache...'));
-  
+
+  console.log(chalk.blue('🔄 Initializing services cache...'));
+
   try {
     // Ensure parent directory exists
     await fs.ensureDir(path.dirname(cacheDir));
-    
-    // Sparse clone (only root files, no modules)
+
+    // Sparse clone (only root files, no services)
     execSync(
-      `git clone --sparse --depth 1 --branch ${BRANCH} ${MODULES_REPO} "${cacheDir}"`,
-      { 
+      `git clone --sparse --depth 1 --branch ${BRANCH} ${SERVICES_REPO} "${cacheDir}"`,
+      {
         stdio: 'pipe', // Hide output
         timeout: 60000 // 1 minute timeout
       }
     );
-    
+
     // Configure sparse checkout (starts with empty set)
     execSync('git sparse-checkout init --cone', {
       cwd: cacheDir,
       stdio: 'pipe'
     });
-    
+
     console.log(chalk.green('✓ Cache initialized'));
   } catch (error) {
     // Clean up partial clone on failure
@@ -74,16 +74,16 @@ async function initializeCache() {
  */
 async function updateCache() {
   const cacheDir = getCacheDir();
-  
-  console.log(chalk.blue('🔄 Updating module cache...'));
-  
+
+  console.log(chalk.blue('🔄 Updating service cache...'));
+
   try {
     execSync('git pull origin main', {
       cwd: cacheDir,
       stdio: 'pipe',
       timeout: 30000 // 30 seconds
     });
-    
+
     console.log(chalk.green('✓ Cache updated'));
   } catch (error) {
     throw new Error(`Failed to update cache: ${error.message}`);
@@ -91,53 +91,53 @@ async function updateCache() {
 }
 
 /**
- * Expand sparse checkout to include specific modules
- * @param {string[]} moduleNames - Array of module names to expand
+ * Expand sparse checkout to include specific services
+ * @param {string[]} serviceNames - Array of services names to expand
  * @returns {Promise<void>}
  */
-async function expandModules(moduleNames) {
+async function expandServices(serviceNames) {
   const cacheDir = getCacheDir();
-  
-  console.log(chalk.blue(`📦 Loading modules: ${moduleNames.join(', ')}...`));
-  
+
+  console.log(chalk.blue(`📦 Loading services: ${serviceNames.join(', ')}...`));
+
   try {
     // Get current sparse checkout list
-    let currentModules = [];
+    let currentServices = [];
     try {
       const output = execSync('git sparse-checkout list', {
         cwd: cacheDir,
         stdio: 'pipe',
         encoding: 'utf8'
       });
-      currentModules = output.trim().split('\n').filter(Boolean);
+      currentServices = output.trim().split('\n').filter(Boolean);
     } catch (error) {
-      // No modules yet, that's fine
+      // No services yet, that's fine
     }
-    
-    // Add new modules to the list
-    const allModules = [...new Set([...currentModules, ...moduleNames])];
-    
-    // Set sparse checkout to include all modules
-    execSync(`git sparse-checkout set ${allModules.join(' ')}`, {
+
+    // Add new services to the list
+    const allServices = [...new Set([...currentServices, ...serviceNames])];
+
+    // Set sparse checkout to include all services
+    execSync(`git sparse-checkout set ${allServices.join(' ')}`, {
       cwd: cacheDir,
       stdio: 'pipe',
       timeout: 60000 // 1 minute (may need to download files)
     });
-    
-    console.log(chalk.green('✓ Modules loaded'));
+
+    console.log(chalk.green('✓ Services loaded'));
   } catch (error) {
-    throw new Error(`Failed to expand modules: ${error.message}`);
+    throw new Error(`Failed to expand services: ${error.message}`);
   }
 }
 
 /**
- * Get path to a specific module in the cache
- * @param {string} moduleName - Module name (e.g., 'backend', 'admin-portal')
- * @returns {string} Absolute path to module
+ * Get path to a specific service in the cache
+ * @param {string} serviceName - Service name (e.g., 'backend', 'admin-portal')
+ * @returns {string} Absolute path to service
  */
-function getModulePath(moduleName) {
+function getServicePath(serviceName) {
   const cacheDir = getCacheDir();
-  return path.join(cacheDir, moduleName);
+  return path.join(cacheDir, serviceName);
 }
 
 /**
@@ -149,13 +149,13 @@ function getCachePath() {
 }
 
 /**
- * Clear the entire module cache
+ * Clear the entire service cache
  * Useful for troubleshooting or forcing fresh download
  * @returns {Promise<void>}
  */
 async function clearCache() {
   const cacheDir = getCacheDir();
-  
+
   if (await fs.pathExists(cacheDir)) {
     await fs.remove(cacheDir);
     console.log(chalk.green('✓ Cache cleared'));
@@ -165,8 +165,8 @@ async function clearCache() {
 }
 
 /**
- * Get cache information (size, last update, modules)
- * @returns {Promise<{exists: boolean, path: string, size?: number, modules?: string[], lastUpdate?: Date}>}
+ * Get cache information (size, last update, services)
+ * @returns {Promise<{exists: boolean, path: string, size?: number, services?: string[], lastUpdate?: Date}>}
  */
 async function getCacheInfo() {
   const cacheDir = getCacheDir();
@@ -174,13 +174,13 @@ async function getCacheInfo() {
     exists: false,
     path: cacheDir
   };
-  
+
   if (!(await cacheExists())) {
     return info;
   }
-  
+
   info.exists = true;
-  
+
   try {
     // Get cache size (du command works on Unix/Mac, different on Windows)
     if (process.platform === 'win32') {
@@ -201,19 +201,19 @@ async function getCacheInfo() {
   } catch (error) {
     // Size calculation failed, not critical
   }
-  
+
   try {
-    // Get list of expanded modules
+    // Get list of expanded services
     const output = execSync('git sparse-checkout list', {
       cwd: cacheDir,
       encoding: 'utf8',
       stdio: 'pipe'
     });
-    info.modules = output.trim().split('\n').filter(Boolean);
+    info.services = output.trim().split('\n').filter(Boolean);
   } catch (error) {
-    info.modules = [];
+    info.services = [];
   }
-  
+
   try {
     // Get last update time from git log
     const output = execSync('git log -1 --format=%cd --date=iso', {
@@ -225,17 +225,17 @@ async function getCacheInfo() {
   } catch (error) {
     // Last update time failed, not critical
   }
-  
+
   return info;
 }
 
 /**
  * Ensure cache is ready (initialize if needed, update if exists)
  * This is the main entry point for cache management
- * @param {string[]} requiredModules - Modules needed for the operation
+ * @param {string[]} requiredServices - Services needed for the operation
  * @returns {Promise<string>} Path to cache root
  */
-async function ensureCacheReady(requiredModules) {
+async function ensureCacheReady(requiredServices) {
   try {
     if (!(await cacheExists())) {
       // Cache doesn't exist, initialize it
@@ -244,10 +244,10 @@ async function ensureCacheReady(requiredModules) {
       // Cache exists, update it
       await updateCache();
     }
-    
-    // Expand sparse checkout to include required modules
-    await expandModules(requiredModules);
-    
+
+    // Expand sparse checkout to include required services
+    await expandServices(requiredServices);
+
     return getCachePath();
   } catch (error) {
     // If we fail and it's a network error, provide helpful message
@@ -265,8 +265,8 @@ module.exports = {
   cacheExists,
   initializeCache,
   updateCache,
-  expandModules,
-  getModulePath,
+  expandServices,
+  getServicePath,
   getCachePath,
   clearCache,
   getCacheInfo,