@launchframe/cli 1.0.0-beta.8 → 1.0.0

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

@@ -3,8 +3,9 @@ const fs = require('fs-extra');
 const os = require('os');
 const { execSync } = require('child_process');
 const chalk = require('chalk');
+const logger = require('./logger');
 
-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 +16,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,36 +33,32 @@ 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...'));
-  
+
+  logger.detail('Initializing services cache...');
+
   try {
-    // Ensure parent directory exists
     await fs.ensureDir(path.dirname(cacheDir));
-    
-    // Sparse clone (only root files, no modules)
+
     execSync(
-      `git clone --sparse --depth 1 --branch ${BRANCH} ${MODULES_REPO} "${cacheDir}"`,
-      { 
-        stdio: 'pipe', // Hide output
-        timeout: 60000 // 1 minute timeout
+      `git clone --sparse --depth 1 --branch ${BRANCH} ${SERVICES_REPO} "${cacheDir}"`,
+      {
+        stdio: 'pipe',
+        timeout: 60000
       }
     );
-    
-    // Configure sparse checkout (starts with empty set)
+
     execSync('git sparse-checkout init --cone', {
       cwd: cacheDir,
       stdio: 'pipe'
     });
-    
-    console.log(chalk.green('✓ Cache initialized'));
+
+    logger.detail('Cache initialized');
   } catch (error) {
-    // Clean up partial clone on failure
     await fs.remove(cacheDir);
     throw new Error(`Failed to initialize cache: ${error.message}`);
   }
@@ -74,70 +71,67 @@ async function initializeCache() {
  */
 async function updateCache() {
   const cacheDir = getCacheDir();
-  
-  console.log(chalk.blue('🔄 Updating module cache...'));
-  
+
+  logger.detail('Updating service cache...');
+
   try {
     execSync('git pull origin main', {
       cwd: cacheDir,
       stdio: 'pipe',
-      timeout: 30000 // 30 seconds
+      timeout: 30000
     });
-    
-    console.log(chalk.green('✓ Cache updated'));
+
+    logger.detail('Cache updated');
   } catch (error) {
     throw new Error(`Failed to update cache: ${error.message}`);
   }
 }
 
 /**
- * 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(', ')}...`));
-  
+
+  logger.detail(`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(' ')}`, {
+
+    const allServices = [...new Set([...currentServices, ...serviceNames])];
+
+    execSync(`git sparse-checkout set ${allServices.join(' ')}`, {
       cwd: cacheDir,
       stdio: 'pipe',
-      timeout: 60000 // 1 minute (may need to download files)
+      timeout: 60000
     });
-    
-    console.log(chalk.green('✓ Modules loaded'));
+
+    logger.detail('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,24 +143,24 @@ 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'));
+    console.log(chalk.green('Cache cleared'));
   } else {
     console.log(chalk.gray('Cache is already empty'));
   }
 }
 
 /**
- * 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 +168,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 +195,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 +219,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 +238,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 +259,8 @@ module.exports = {
   cacheExists,
   initializeCache,
   updateCache,
-  expandModules,
-  getModulePath,
+  expandServices,
+  getServicePath,
   getCachePath,
   clearCache,
   getCacheInfo,

package/src/utils/ssh-helper.js

@@ -209,6 +209,54 @@ function showDeployKeyInstructions(vpsUser, vpsHost, githubOrg, projectName) {
   console.log(chalk.gray('   launchframe deploy:init\n'));
 }
 
+/**
+ * Pull Docker images on VPS
+ * @param {string} vpsUser - SSH username
+ * @param {string} vpsHost - VPS hostname or IP
+ * @param {string} vpsAppFolder - App folder path on VPS
+ * @returns {Promise<void>}
+ */
+async function pullImagesOnVPS(vpsUser, vpsHost, vpsAppFolder) {
+  const ora = require('ora');
+
+  const spinner = ora('Pulling images on VPS...').start();
+
+  try {
+    await execAsync(
+      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml pull"`,
+      { timeout: 600000 } // 10 minutes
+    );
+    spinner.succeed('Images pulled on VPS');
+  } catch (error) {
+    spinner.fail('Failed to pull images on VPS');
+    throw new Error(`Failed to pull images: ${error.message}`);
+  }
+}
+
+/**
+ * Restart services on VPS
+ * @param {string} vpsUser - SSH username
+ * @param {string} vpsHost - VPS hostname or IP
+ * @param {string} vpsAppFolder - App folder path on VPS
+ * @returns {Promise<void>}
+ */
+async function restartServicesOnVPS(vpsUser, vpsHost, vpsAppFolder) {
+  const ora = require('ora');
+
+  const spinner = ora('Restarting services...').start();
+
+  try {
+    await execAsync(
+      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d"`,
+      { timeout: 300000 } // 5 minutes
+    );
+    spinner.succeed('Services restarted');
+  } catch (error) {
+    spinner.fail('Failed to restart services');
+    throw new Error(`Failed to restart services: ${error.message}`);
+  }
+}
+
 module.exports = {
   testSSHConnection,
   checkSSHKeys,
@@ -216,5 +264,7 @@ module.exports = {
   copyFileToVPS,
   copyDirectoryToVPS,
   checkRepoPrivacy,
-  showDeployKeyInstructions
+  showDeployKeyInstructions,
+  pullImagesOnVPS,
+  restartServicesOnVPS
 };

package/src/utils/telemetry.js

@@ -0,0 +1,238 @@
+const https = require('https');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const chalk = require('chalk');
+
+const MIXPANEL_TOKEN = '3e6214f33ba535dec14021547039427c';
+const CONFIG_DIR = path.join(os.homedir(), '.launchframe');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+
+let config = null;
+
+/**
+ * Sanitize error messages by stripping file paths and capping length
+ * @param {string} message - Raw error message
+ * @returns {string} Sanitized message
+ */
+function sanitize(message) {
+  if (!message) return 'unknown';
+  return message
+    .replace(/\/[\w\-\/.]+/g, '<path>')
+    .replace(/[A-Z]:\\[\w\-\\.\\]+/g, '<path>')
+    .substring(0, 200);
+}
+
+/**
+ * Read config from disk, or return defaults
+ * @returns {Object} Config object
+ */
+function readConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const raw = fs.readFileSync(CONFIG_PATH, 'utf8');
+      return JSON.parse(raw);
+    }
+  } catch {
+    // Corrupted config — start fresh
+  }
+  return {};
+}
+
+/**
+ * Write config to disk
+ * @param {Object} cfg - Config object to write
+ */
+function writeConfig(cfg) {
+  try {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + '\n');
+  } catch {
+    // Silently ignore write failures
+  }
+}
+
+/**
+ * Check if telemetry is disabled via environment variables
+ * @returns {boolean} True if disabled via env
+ */
+function isDisabledByEnv() {
+  return process.env.DO_NOT_TRACK === '1' || process.env.LAUNCHFRAME_TELEMETRY_DISABLED === '1';
+}
+
+/**
+ * Check if running from a locally linked (dev) version
+ * @returns {boolean} True if running via npm link
+ */
+function isDevMode() {
+  return !__dirname.includes('node_modules');
+}
+
+/**
+ * Check if telemetry is enabled
+ * @returns {boolean} True if telemetry is enabled
+ */
+function isEnabled() {
+  if (isDevMode()) return false;
+  if (isDisabledByEnv()) return false;
+  if (!config || !config.telemetry) return false;
+  return config.telemetry.enabled !== false;
+}
+
+/**
+ * Initialize telemetry — call once at CLI startup.
+ * Reads/creates config, shows first-run notice if needed.
+ * Synchronous and fast.
+ */
+function initTelemetry() {
+  try {
+    config = readConfig();
+
+    if (!config.telemetry) {
+      config.telemetry = {
+        enabled: true,
+        noticeShown: false,
+        anonymousId: crypto.randomUUID()
+      };
+      writeConfig(config);
+    }
+
+    if (!config.telemetry.anonymousId) {
+      config.telemetry.anonymousId = crypto.randomUUID();
+      writeConfig(config);
+    }
+
+    if (!config.telemetry.noticeShown && !isDisabledByEnv() && !isDevMode()) {
+      console.log(
+        chalk.gray(
+          '\nLaunchFrame collects anonymous usage data to improve the CLI.\n' +
+            'No personal information is collected. Run `launchframe telemetry --disable` to opt out.\n' +
+            'Learn more: https://launchframe.dev/privacy\n'
+        )
+      );
+      config.telemetry.noticeShown = true;
+      writeConfig(config);
+    }
+  } catch {
+    // Telemetry init must never break the CLI
+  }
+}
+
+/**
+ * Fire-and-forget event tracking.
+ * @param {string} name - Event name
+ * @param {Object} properties - Event properties
+ */
+function trackEvent(name, properties = {}) {
+  try {
+    if (!isEnabled()) return;
+
+    const cliVersion = (() => {
+      try {
+        return require('../../package.json').version;
+      } catch {
+        return 'unknown';
+      }
+    })();
+
+    const payload = JSON.stringify([
+      {
+        event: name,
+        properties: {
+          token: MIXPANEL_TOKEN,
+          distinct_id: config.telemetry.anonymousId,
+          cli_version: cliVersion,
+          node_version: process.version,
+          os: process.platform,
+          os_arch: process.arch,
+          ...properties
+        }
+      }
+    ]);
+
+    const req = https.request(
+      {
+        hostname: 'api-eu.mixpanel.com',
+        path: '/track',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'text/plain',
+          'Content-Length': Buffer.byteLength(payload)
+        }
+      },
+      (res) => { res.resume(); }
+    );
+
+    req.on('error', () => {});
+    req.write(payload);
+    req.end();
+    req.unref();
+  } catch {
+    // Telemetry must never break the CLI
+  }
+}
+
+/**
+ * Enable or disable telemetry
+ * @param {boolean} enabled - Whether to enable telemetry
+ */
+function setTelemetryEnabled(enabled) {
+  config = readConfig();
+
+  if (!config.telemetry) {
+    config.telemetry = {
+      enabled,
+      noticeShown: true,
+      anonymousId: crypto.randomUUID()
+    };
+  } else {
+    config.telemetry.enabled = enabled;
+    config.telemetry.noticeShown = true;
+  }
+
+  writeConfig(config);
+
+  if (enabled) {
+    console.log(chalk.green('\nTelemetry enabled. Thank you for helping improve LaunchFrame!\n'));
+  } else {
+    console.log(chalk.yellow('\nTelemetry disabled. No data will be collected.\n'));
+  }
+}
+
+/**
+ * Show current telemetry status
+ */
+function showTelemetryStatus() {
+  config = readConfig();
+  const envDisabled = isDisabledByEnv();
+
+  console.log(chalk.blue.bold('\nTelemetry Status\n'));
+
+  if (envDisabled) {
+    console.log(chalk.yellow('  Disabled via environment variable'));
+    if (process.env.DO_NOT_TRACK === '1') {
+      console.log(chalk.gray('  DO_NOT_TRACK=1'));
+    }
+    if (process.env.LAUNCHFRAME_TELEMETRY_DISABLED === '1') {
+      console.log(chalk.gray('  LAUNCHFRAME_TELEMETRY_DISABLED=1'));
+    }
+  } else if (config.telemetry && config.telemetry.enabled !== false) {
+    console.log(chalk.green('  Enabled'));
+  } else {
+    console.log(chalk.yellow('  Disabled'));
+  }
+
+  if (config.telemetry && config.telemetry.anonymousId) {
+    console.log(chalk.gray(`  Anonymous ID: ${config.telemetry.anonymousId}`));
+  }
+
+  console.log(chalk.gray('\n  To disable: launchframe telemetry --disable'));
+  console.log(chalk.gray('  To enable:  launchframe telemetry --enable'));
+  console.log(chalk.gray('  Env vars:   DO_NOT_TRACK=1 or LAUNCHFRAME_TELEMETRY_DISABLED=1\n'));
+}
+
+module.exports = { initTelemetry, trackEvent, sanitize, setTelemetryEnabled, showTelemetryStatus };

package/src/utils/variable-replacer.js

@@ -1,6 +1,9 @@
 const fs = require('fs-extra');
+const { glob } = require('node:fs');
 const path = require('path');
-const { glob } = require('glob');
+
+const EXCLUDED_DIRS = new Set(['node_modules', '.git', '.next', 'dist', 'build']);
+const BINARY_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.ico', '.pdf', '.woff', '.woff2', '.ttf', '.eot']);
 
 /**
  * Replace template variables in all files within a directory
@@ -9,31 +12,23 @@ const { glob } = require('glob');
  */
 async function replaceVariables(directory, variables) {
   // Find all files (excluding node_modules, .git, binary files)
-  const files = await glob('**/*', {
-    cwd: directory,
-    nodir: true,
-    dot: true, // Include hidden files/directories like .vitepress
-    ignore: [
-      '**/node_modules/**',
-      '**/.git/**',
-      '**/.next/**',
-      '**/dist/**',
-      '**/build/**',
-      '**/*.png',
-      '**/*.jpg',
-      '**/*.jpeg',
-      '**/*.gif',
-      '**/*.ico',
-      '**/*.pdf',
-      '**/*.woff',
-      '**/*.woff2',
-      '**/*.ttf',
-      '**/*.eot'
-    ]
+  const files = await new Promise((resolve, reject) => {
+    glob('**/*', {
+      cwd: directory,
+      exclude: (name) => EXCLUDED_DIRS.has(name),
+    }, (err, matches) => err ? reject(err) : resolve(matches));
+  });
+
+  const filtered = files.filter(f => {
+    const ext = path.extname(f).toLowerCase();
+    return !BINARY_EXTENSIONS.has(ext);
   });
 
-  for (const file of files) {
+  for (const file of filtered) {
     const filePath = path.join(directory, file);
+    // Skip directories (fs.glob includes them unlike third-party glob packages)
+    const stat = await fs.stat(filePath);
+    if (stat.isDirectory()) continue;
     await replaceVariablesInFile(filePath, variables);
   }
 }