@launchframe/cli 1.0.0-beta.3 → 1.0.0-beta.31

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);
   }
 }

package/src/utils/variant-processor.js

@@ -15,6 +15,7 @@ const { replaceVariables } = require('./variable-replacer');
 const { getVariantConfig, getVariantsToApply } = require('../services/variant-config');
 const fs = require('fs-extra');
 const path = require('path');
+const logger = require('./logger');
 
 /**
  * Process service with variant modifications
@@ -32,7 +33,7 @@ async function processServiceVariant(
   replacements,
   templateRoot
 ) {
-  console.log(`\n📦 Processing ${serviceName} with choices:`, variantChoices);
+  logger.detail(`Processing ${serviceName} with choices: ${JSON.stringify(variantChoices)}`, 2);
 
   const serviceConfig = getVariantConfig(serviceName);
   if (!serviceConfig) {
@@ -41,33 +42,35 @@ async function processServiceVariant(
 
   const basePath = path.join(templateRoot, serviceConfig.base);
 
-  // Step 1: Copy base template (minimal - B2B + single-tenant)
-  console.log(`  📁 Copying base template from ${serviceConfig.base}`);
+  // Copy base template
+  logger.detail(`Copying base template from ${serviceConfig.base}`, 2);
   await copyDirectory(basePath, destination, {
     exclude: ['node_modules', '.git', 'dist', '.env']
   });
 
-  // Step 2: Determine which variants to apply
+  // Determine which variants to apply
   const variantsToApply = getVariantsToApply(variantChoices);
 
   if (variantsToApply.length === 0) {
-    console.log(`  ✅ Using base template (no variants to apply)`);
+    logger.detail('Using base template (no variants)', 2);
   } else {
-    console.log(`  🔧 Applying variants: ${variantsToApply.join(', ')}`);
+    logger.detail(`Applying variants: ${variantsToApply.join(', ')}`, 2);
   }
 
-  // Step 3: Apply each variant
+  // Apply each variant
   for (const variantName of variantsToApply) {
     const variantConfig = serviceConfig.variants[variantName];
 
     if (!variantConfig) {
-      console.warn(`  ⚠️  No configuration found for variant: ${variantName}, skipping`);
+      // Silently skip - not every service needs every variant combination
+      // (e.g., b2b2c_multi-tenant may only apply to backend, not admin-portal)
+      logger.detail(`Skipping ${variantName} (not applicable to this service)`, 3);
       continue;
     }
 
-    console.log(`\n  ✨ Applying ${variantName} variant:`);
+    logger.detail(`Applying ${variantName} variant`, 2);
 
-    // Step 3a: Copy variant FILES
+    // Copy variant FILES
     await copyVariantFiles(
       variantName,
       variantConfig.files || [],
@@ -76,7 +79,7 @@ async function processServiceVariant(
       templateRoot
     );
 
-    // Step 3b: Insert variant SECTIONS
+    // Insert variant SECTIONS
     await insertVariantSections(
       variantName,
       variantConfig.sections || {},
@@ -86,15 +89,15 @@ async function processServiceVariant(
     );
   }
 
-  // Step 4: Clean up unused section markers
-  console.log(`\n  🧹 Cleaning up unused section markers`);
+  // Clean up unused section markers
+  logger.detail('Cleaning up unused section markers', 2);
   await cleanupSectionMarkers(serviceName, serviceConfig, variantsToApply, destination);
 
-  // Step 5: Replace template variables ({{PROJECT_NAME}}, etc.)
-  console.log(`\n  🔤 Replacing template variables`);
+  // Replace template variables
+  logger.detail('Replacing template variables', 2);
   await replaceVariables(destination, replacements);
 
-  console.log(`  ✅ ${serviceName} processing complete\n`);
+  logger.detail(`${serviceName} complete`, 2);
 }
 
 /**
@@ -110,7 +113,7 @@ async function cleanupSectionMarkers(serviceName, serviceConfig, appliedVariants
   const unappliedVariants = allVariants.filter(v => !appliedVariants.includes(v));
 
   if (unappliedVariants.length === 0) {
-    console.log(`    ✓ No unused section markers to clean`);
+    logger.detail('No unused section markers to clean', 3);
     return;
   }
 
@@ -146,8 +149,6 @@ async function cleanupSectionMarkers(serviceName, serviceConfig, appliedVariants
       // Remove each unused section marker (keep content, remove only marker comments)
       for (const sectionName of sectionNames) {
         // Try all comment formats (// for JS/TS, {/* */} for JSX, # for YAML/Shell)
-        // Capture: START marker, content, END marker - replace with just content
-        // Include leading whitespace before markers to prevent indentation issues
         const slashPattern = new RegExp(
           `^[ \\t]*\\/\\/ ${sectionName}_START\\n([\\s\\S]*?)^[ \\t]*\\/\\/ ${sectionName}_END\\n?`,
           'gm'
@@ -185,14 +186,14 @@ async function cleanupSectionMarkers(serviceName, serviceConfig, appliedVariants
         totalCleaned++;
       }
     } catch (error) {
-      console.warn(`    ⚠️  Could not clean markers in ${filePath}:`, error.message);
+      logger.warn(`Could not clean markers in ${filePath}: ${error.message}`);
     }
   }
 
   if (totalCleaned > 0) {
-    console.log(`    ✓ Cleaned up section markers in ${totalCleaned} file(s)`);
+    logger.detail(`Cleaned section markers in ${totalCleaned} file(s)`, 3);
   } else {
-    console.log(`    ✓ No unused section markers found`);
+    logger.detail('No unused section markers found', 3);
   }
 }
 
@@ -206,11 +207,11 @@ async function cleanupSectionMarkers(serviceName, serviceConfig, appliedVariants
  */
 async function copyVariantFiles(variantName, files, filesDir, destination, templateRoot) {
   if (!files || files.length === 0) {
-    console.log(`    📂 No files to copy for ${variantName}`);
+    logger.detail(`No files to copy for ${variantName}`, 3);
     return;
   }
 
-  console.log(`    📂 Copying ${files.length} file(s)/folder(s):`);
+  logger.detail(`Copying ${files.length} file(s) for ${variantName}`, 3);
 
   const variantFilesPath = path.join(templateRoot, filesDir, variantName);
 
@@ -219,22 +220,18 @@ async function copyVariantFiles(variantName, files, filesDir, destination, templ
     const destPath = path.join(destination, filePath);
 
     try {
-      // Check if source exists
       if (!await fs.pathExists(sourcePath)) {
-        console.warn(`      ⚠️  Source not found: ${filePath}, skipping`);
+        logger.warn(`Source not found: ${filePath}, skipping`);
         continue;
       }
 
-      // Create parent directory if needed
       await fs.ensureDir(path.dirname(destPath));
-
-      // Copy file or directory
       await fs.copy(sourcePath, destPath, { overwrite: true });
 
       const isDir = (await fs.stat(sourcePath)).isDirectory();
-      console.log(`      ✓ Copied ${isDir ? 'folder' : 'file'}: ${filePath}`);
+      logger.detail(`Copied ${isDir ? 'folder' : 'file'}: ${filePath}`, 4);
     } catch (error) {
-      console.warn(`      ⚠️  Could not copy ${filePath}:`, error.message);
+      logger.warn(`Could not copy ${filePath}: ${error.message}`);
     }
   }
 }
@@ -249,45 +246,41 @@ async function copyVariantFiles(variantName, files, filesDir, destination, templ
  */
 async function insertVariantSections(variantName, sections, sectionsDir, destination, templateRoot) {
   if (!sections || Object.keys(sections).length === 0) {
-    console.log(`    ✏️  No sections to insert for ${variantName}`);
+    logger.detail(`No sections to insert for ${variantName}`, 3);
     return;
   }
 
   const sectionFiles = Object.keys(sections);
-  console.log(`    ✏️  Inserting sections into ${sectionFiles.length} file(s):`);
+  logger.detail(`Inserting sections into ${sectionFiles.length} file(s)`, 3);
 
   const variantSectionsPath = path.join(templateRoot, sectionsDir, variantName);
 
   for (const [filePath, sectionNames] of Object.entries(sections)) {
     const targetFilePath = path.join(destination, filePath);
 
-    // Check if target file exists
     if (!await fs.pathExists(targetFilePath)) {
-      console.warn(`      ⚠️  Target file not found: ${filePath}, skipping sections`);
+      logger.warn(`Target file not found: ${filePath}, skipping sections`);
       continue;
     }
 
-    console.log(`      📝 ${filePath}:`);
+    logger.detail(`Processing ${filePath}`, 4);
 
     for (const sectionName of sectionNames) {
       try {
-        // Read section content from file
         const fileName = path.basename(filePath);
         const sectionFileName = `${fileName}.${sectionName}`;
         const sectionFilePath = path.join(variantSectionsPath, sectionFileName);
 
         if (!await fs.pathExists(sectionFilePath)) {
-          console.warn(`        ⚠️  Section file not found: ${sectionFileName}, skipping`);
+          logger.warn(`Section file not found: ${sectionFileName}, skipping`);
           continue;
         }
 
         const sectionContent = await fs.readFile(sectionFilePath, 'utf-8');
-
-        // Insert section content into target file
         await replaceSection(targetFilePath, sectionName, sectionContent);
-        console.log(`        ✓ Inserted [${sectionName}]`);
+        logger.detail(`Inserted [${sectionName}]`, 5);
       } catch (error) {
-        console.warn(`        ⚠️  Could not insert section ${sectionName}:`, error.message);
+        logger.warn(`Could not insert section ${sectionName}: ${error.message}`);
       }
     }
   }