@launchframe/cli 1.0.0-beta.9 → 1.0.1

package/src/commands/module.js

@@ -0,0 +1,148 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { MODULE_REGISTRY } = require('../services/module-registry');
+const { MODULE_CONFIG } = require('../services/module-config');
+const { installModule } = require('../utils/module-installer');
+const { dockerBuild } = require('./docker-build');
+const { dockerDown } = require('./docker-down');
+const { dockerUp } = require('./docker-up');
+const {
+  requireProject,
+  getProjectConfig,
+  getInstalledModules,
+  isModuleInstalled,
+  addInstalledModule
+} = require('../utils/project-helpers');
+
+// Core services that can't be added via service:add
+const CORE_SERVICES = ['backend', 'admin-portal', 'infrastructure', 'website'];
+
+async function moduleList() {
+  requireProject();
+
+  const installedModules = getInstalledModules();
+  const modules = Object.values(MODULE_REGISTRY);
+
+  console.log(chalk.blue('\nAvailable Modules:\n'));
+
+  modules.forEach(mod => {
+    const installed = installedModules.includes(mod.name);
+    const status = installed ? chalk.green(' [installed]') : '';
+    console.log(chalk.green(`  ${mod.name}`) + status);
+    console.log(`    ${mod.description}`);
+    console.log(`    Affects services: ${mod.services.join(', ')}`);
+    console.log('');
+  });
+
+  console.log('To install a module:');
+  console.log('  launchframe module:add <module-name>');
+}
+
+async function moduleAdd(moduleName, flags = {}) {
+  requireProject();
+
+  // Validate module exists in registry
+  const mod = MODULE_REGISTRY[moduleName];
+  if (!mod) {
+    console.error(chalk.red(`Error: Module "${moduleName}" not found`));
+    console.log('\nAvailable modules:');
+    Object.keys(MODULE_REGISTRY).forEach(key => {
+      console.log(`  - ${key}`);
+    });
+    process.exit(1);
+  }
+
+  // Check not already installed
+  if (isModuleInstalled(moduleName)) {
+    console.error(chalk.red(`Error: Module "${moduleName}" is already installed`));
+    process.exit(1);
+  }
+
+  // Validate required services
+  const config = getProjectConfig();
+  const installedServices = config.installedServices || [];
+  const errors = [];
+
+  for (const service of mod.services) {
+    // Check if service is in installedServices
+    if (!installedServices.includes(service)) {
+      if (CORE_SERVICES.includes(service)) {
+        errors.push(`Core service '${service}' is missing from your project`);
+      } else {
+        errors.push(`Service '${service}' is not installed. Install it first with: launchframe service:add ${service}`);
+      }
+      continue;
+    }
+
+    // Check if service directory exists on disk
+    const serviceDir = path.join(process.cwd(), service);
+    if (!fs.existsSync(serviceDir)) {
+      errors.push(`Service '${service}' directory not found. Your project structure may be corrupted.`);
+    }
+  }
+
+  if (errors.length > 0) {
+    console.error(chalk.red(`\nCannot install module "${moduleName}":\n`));
+    errors.forEach(err => {
+      console.error(chalk.red(`  - ${err}`));
+    });
+    process.exit(1);
+  }
+
+  // Display module info and confirm
+  console.log(chalk.green(`\n${mod.displayName}`));
+  console.log(mod.description);
+  console.log(`Affects services: ${mod.services.join(', ')}`);
+
+  if (!(flags.yes || flags.y)) {
+    const { confirmed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmed',
+      message: `Add module "${mod.displayName}" to your project?`,
+      default: true
+    }]);
+
+    if (!confirmed) {
+      console.log('Installation cancelled');
+      process.exit(0);
+    }
+  }
+
+  const affectedServices = [...new Set(Object.keys(MODULE_CONFIG[moduleName] || {}))].filter(s => s !== 'infrastructure');
+  const infrastructurePath = path.join(process.cwd(), 'infrastructure');
+  const composeCmd = 'docker-compose -f docker-compose.yml -f docker-compose.dev.yml';
+
+  // Bring the stack down and remove affected containers before touching files
+  await dockerDown();
+  for (const service of affectedServices) {
+    try {
+      execSync(`${composeCmd} rm -f ${service}`, { cwd: infrastructurePath, stdio: 'inherit' });
+    } catch (_) {
+      // Container may already be gone — that's fine
+    }
+  }
+
+  // Register module in .launchframe
+  addInstalledModule(moduleName);
+
+  // Install module files, sections, and dependencies
+  const moduleServiceConfig = MODULE_CONFIG[moduleName];
+  if (moduleServiceConfig) {
+    await installModule(moduleName, moduleServiceConfig);
+  }
+
+  console.log(chalk.green(`\n✓ Module "${moduleName}" installed successfully!`));
+
+  // Rebuild affected containers
+  for (const service of affectedServices) {
+    await dockerBuild(service);
+  }
+
+  // Restart the full stack (detached when running non-interactively, watch otherwise)
+  await dockerUp(undefined, flags.yes || flags.y ? { detach: true } : {});
+}
+
+module.exports = { moduleAdd, moduleList };

package/src/commands/service.js

@@ -10,7 +10,7 @@ const { updateEnvFile } = require('../utils/env-generator');
 const { checkGitHubAccess, showAccessDeniedMessage } = require('../utils/github-access');
 const { ensureCacheReady, getServicePath } = require('../utils/service-cache');
 
-async function serviceAdd(serviceName) {
+async function serviceAdd(serviceName, flags = {}) {
   // STEP 1: Validation
   console.log(chalk.blue(`Installing ${serviceName} service...`));
 
@@ -49,16 +49,18 @@ async function serviceAdd(serviceName) {
   console.log(`Tech stack: ${service.techStack}`);
   console.log(`Dependencies: ${service.dependencies.join(', ')}`);
 
-  const { confirmed } = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'confirmed',
-    message: 'Continue with installation?',
-    default: true
-  }]);
+  if (!(flags.yes || flags.y)) {
+    const { confirmed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmed',
+      message: 'Continue with installation?',
+      default: true
+    }]);
 
-  if (!confirmed) {
-    console.log('Installation cancelled');
-    process.exit(0);
+    if (!confirmed) {
+      console.log('Installation cancelled');
+      process.exit(0);
+    }
   }
 
   // STEP 3: Get service files (from cache in production, local in dev)
@@ -124,7 +126,7 @@ async function serviceAdd(serviceName) {
 
   // STEP 4: Service-specific prompts (e.g., Airtable credentials)
   console.log(chalk.blue('\nConfiguring service...'));
-  const envValues = await runServicePrompts(service);
+  const envValues = await runServicePrompts(service, flags);
 
   // STEP 5: Replace template variables
   console.log(chalk.blue('\nCustomizing service for your project...'));
@@ -265,9 +267,17 @@ async function serviceAdd(serviceName) {
   console.log(`\n📖 See README.md in ${serviceName}/ for more details.`);
 }
 
-async function runServicePrompts(service) {
+async function runServicePrompts(service, flags = {}) {
   const envValues = {};
 
+  if (flags.yes || flags.y) {
+    // Non-interactive mode — use empty values; configure manually after install
+    for (const key of Object.keys(service.envVars)) {
+      envValues[key] = '';
+    }
+    return envValues;
+  }
+
   // Prompt for each required env var
   for (const [key, description] of Object.entries(service.envVars)) {
     const { value } = await inquirer.prompt([{

package/src/commands/waitlist-deploy.js

@@ -205,6 +205,7 @@ async function waitlistDeploy() {
     verifySpinner.succeed('Services verified');
     console.log(chalk.gray('\n' + psOutput));
   } catch (error) {
+    console.error(chalk.yellow(`\n⚠️  Error: ${error.message}\n`));
     verifySpinner.warn('Could not verify services');
   }
 

package/src/commands/waitlist-logs.js

@@ -1,11 +1,14 @@
 const chalk = require('chalk');
-const { spawn } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 const { requireProject, getProjectConfig, isWaitlistInstalled } = require('../utils/project-helpers');
 
 /**
- * View waitlist logs from VPS (streaming)
+ * View waitlist logs from VPS
+ * @param {Object} flags - Optional flags
+ * @param {boolean} flags['no-follow'] - Snapshot mode: print tail and exit (non-interactive)
+ * @param {number} flags.tail - Number of lines to show (default 100, used with --no-follow)
  */
-async function waitlistLogs() {
+async function waitlistLogs(flags = {}) {
   requireProject();
 
   console.log(chalk.blue.bold('\n📋 Waitlist Logs\n'));
@@ -28,6 +31,20 @@ async function waitlistLogs() {
 
   const { vpsHost, vpsUser, vpsAppFolder } = config.deployment;
 
+  if (flags['no-follow']) {
+    // Snapshot mode — print tail and exit (non-interactive, suitable for MCP)
+    const tail = flags.tail || 100;
+    const sshCmd = `cd ${vpsAppFolder}/waitlist && docker-compose -f docker-compose.waitlist.yml logs --no-follow --tail=${tail}`;
+
+    const result = spawnSync('ssh', [`${vpsUser}@${vpsHost}`, sshCmd], { stdio: 'inherit' });
+
+    if (result.status !== 0 && result.status !== null) {
+      console.log(chalk.yellow(`\n⚠️  Process exited with code ${result.status}\n`));
+    }
+    return;
+  }
+
+  // Streaming mode (interactive)
   console.log(chalk.gray('Connecting to VPS and streaming logs...\n'));
   console.log(chalk.gray('Press Ctrl+C to exit\n'));
 

package/src/generator.js

@@ -1,11 +1,13 @@
 const path = require('path');
 const fs = require('fs-extra');
 const { execSync } = require('child_process');
+const chalk = require('chalk');
 const { replaceVariables } = require('./utils/variable-replacer');
 const { copyDirectory } = require('./utils/file-ops');
 const { generateEnvFile } = require('./utils/env-generator');
 const { processServiceVariant } = require('./utils/variant-processor');
 const { resolveVariantChoices } = require('./services/variant-config');
+const logger = require('./utils/logger');
 
 /**
  * Initialize git repository in a service directory
@@ -14,13 +16,13 @@ const { resolveVariantChoices } = require('./services/variant-config');
  */
 function initGitRepo(servicePath, serviceName) {
   try {
-    console.log(`🔧 Initializing git repository for ${serviceName}...`);
+    logger.detail(`Initializing git repository for ${serviceName}`);
     execSync('git init', { cwd: servicePath, stdio: 'ignore' });
     execSync('git add .', { cwd: servicePath, stdio: 'ignore' });
     execSync('git commit -m "Initial commit"', { cwd: servicePath, stdio: 'ignore' });
-    console.log(`✅ Git repository initialized for ${serviceName}`);
+    logger.detail(`Git initialized: ${serviceName}`);
   } catch (error) {
-    console.warn(`⚠️  Could not initialize git repository for ${serviceName}: ${error.message}`);
+    logger.warn(`Could not initialize git for ${serviceName}: ${error.message}`);
   }
 }
 
@@ -34,12 +36,11 @@ async function generateProject(answers, variantChoices, templateRoot) {
   const { projectName } = answers;
 
   // Define source (template) and destination paths
-  // templateRoot is now passed as parameter (cache or local dev path)
-  const projectRoot = path.resolve(__dirname, '../..'); // For root-level files like .github, README.md
+  const projectRoot = path.resolve(__dirname, '../..'); // For root-level files
   const destinationRoot = path.resolve(process.cwd(), projectName);
 
-  console.log(`📁 Template source: ${templateRoot}`);
-  console.log(`📁 Destination: ${destinationRoot}\n`);
+  logger.detail(`Template source: ${templateRoot}`);
+  logger.detail(`Destination: ${destinationRoot}`);
 
   // Ensure destination directory exists
   await fs.ensureDir(destinationRoot);
@@ -60,8 +61,8 @@ async function generateProject(answers, variantChoices, templateRoot) {
   // Resolve variant choices for all services
   const allServiceVariants = resolveVariantChoices(variantChoices);
 
-  // Step 1: Process backend service with variants
-  console.log('🔧 Processing backend service...');
+  // Process backend
+  console.log(chalk.gray('  Processing backend...'));
   await processServiceVariant(
     'backend',
     allServiceVariants.backend,
@@ -71,11 +72,10 @@ async function generateProject(answers, variantChoices, templateRoot) {
   );
   initGitRepo(path.join(destinationRoot, 'backend'), 'backend');
 
-  // Step 2: Process admin-portal service with variants
-  // Note: admin-portal folder might not exist yet in templates, skip if missing
+  // Process admin-portal
   const adminPortalTemplatePath = path.join(templateRoot, 'admin-portal/base');
   if (await fs.pathExists(adminPortalTemplatePath)) {
-    console.log('🔧 Processing admin-portal service...');
+    console.log(chalk.gray('  Processing admin-portal...'));
     await processServiceVariant(
       'admin-portal',
       allServiceVariants['admin-portal'],
@@ -85,8 +85,8 @@ async function generateProject(answers, variantChoices, templateRoot) {
     );
     initGitRepo(path.join(destinationRoot, 'admin-portal'), 'admin-portal');
   } else {
-    // Fallback: Copy admin-portal directly without variants (for now)
-    console.log('📋 Copying admin-portal service (no variants yet)...');
+    // Fallback: Copy admin-portal directly without variants
+    console.log(chalk.gray('  Copying admin-portal...'));
     const adminPortalSource = path.join(templateRoot, 'admin-portal');
     if (await fs.pathExists(adminPortalSource)) {
       await copyDirectory(adminPortalSource, path.join(destinationRoot, 'admin-portal'));
@@ -95,12 +95,11 @@ async function generateProject(answers, variantChoices, templateRoot) {
     }
   }
 
-  // Step 3: Process customers-portal service (ONLY if B2B2C selected)
+  // Process customers-portal (only if B2B2C)
   if (variantChoices.userModel === 'b2b2c') {
-    // Note: customers-portal folder might not exist yet in templates, skip if missing
     const customersPortalTemplatePath = path.join(templateRoot, 'customers-portal/base');
     if (await fs.pathExists(customersPortalTemplatePath)) {
-      console.log('🔧 Processing customers-portal service...');
+      console.log(chalk.gray('  Processing customers-portal...'));
       await processServiceVariant(
         'customers-portal',
         allServiceVariants['customers-portal'],
@@ -110,8 +109,7 @@ async function generateProject(answers, variantChoices, templateRoot) {
       );
       initGitRepo(path.join(destinationRoot, 'customers-portal'), 'customers-portal');
     } else {
-      // Fallback: Copy customers-portal directly without variants (for now)
-      console.log('📋 Copying customers-portal service (B2B2C mode)...');
+      console.log(chalk.gray('  Copying customers-portal...'));
       const customersPortalSource = path.join(templateRoot, 'customers-portal');
       if (await fs.pathExists(customersPortalSource)) {
         await copyDirectory(customersPortalSource, path.join(destinationRoot, 'customers-portal'));
@@ -120,11 +118,11 @@ async function generateProject(answers, variantChoices, templateRoot) {
       }
     }
   } else {
-    console.log('📋 Skipping customers-portal (B2B mode - admin users only)');
+    logger.detail('Skipping customers-portal (B2B mode)');
   }
 
-  // Step 4: Process infrastructure with variants (docker-compose files conditionally include customers-portal)
-  console.log('🔧 Processing infrastructure...');
+  // Process infrastructure
+  console.log(chalk.gray('  Processing infrastructure...'));
   await processServiceVariant(
     'infrastructure',
     allServiceVariants.infrastructure,
@@ -134,7 +132,8 @@ async function generateProject(answers, variantChoices, templateRoot) {
   );
   initGitRepo(path.join(destinationRoot, 'infrastructure'), 'infrastructure');
 
-  console.log('📋 Copying website...');
+  // Process website
+  console.log(chalk.gray('  Processing website...'));
   await copyDirectory(
     path.join(templateRoot, 'website'),
     path.join(destinationRoot, 'website')
@@ -142,14 +141,9 @@ 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 services/)
-  console.log('📋 Copying additional files...');
-  const additionalFiles = [
-    '.github',
-    'README.md',
-    '.gitignore',
-    'LICENSE'
-  ];
+  // Copy additional files
+  logger.detail('Copying additional files...');
+  const additionalFiles = ['.github', 'README.md', '.gitignore', 'LICENSE'];
 
   for (const file of additionalFiles) {
     const sourcePath = path.join(projectRoot, file);
@@ -166,16 +160,26 @@ async function generateProject(answers, variantChoices, templateRoot) {
     }
   }
 
-  // Step 6: Generate .env file with localhost defaults
-  console.log('\n🔐 Generating .env file with secure secrets...');
+  // Copy MCP configuration files from template root
+  logger.detail('Copying MCP configuration files...');
+  const mcpFiles = ['CLAUDE.md', '.mcp.json'];
+  for (const file of mcpFiles) {
+    const sourcePath = path.join(templateRoot, file);
+    const destPath = path.join(destinationRoot, file);
+    if (await fs.pathExists(sourcePath)) {
+      await fs.copy(sourcePath, destPath);
+    }
+  }
+
+  // Generate .env file
+  console.log(chalk.gray('  Generating environment file...'));
   const { envPath } = await generateEnvFile(destinationRoot, answers);
-  console.log(`✅ Environment file created: ${envPath}`);
+  logger.detail(`Environment file: ${envPath}`);
 
-  // Step 7: Create .launchframe marker file with variant metadata
-  console.log('📝 Creating LaunchFrame marker file...');
+  // Create .launchframe marker file
+  logger.detail('Creating project 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');
@@ -188,12 +192,9 @@ async function generateProject(answers, variantChoices, templateRoot) {
     projectDisplayName: answers.projectDisplayName,
     deployConfigured: false,
     installedServices: installedServices,
-    // Store variant choices for future reference
     variants: variantChoices
   };
   await fs.writeJson(markerPath, markerContent, { spaces: 2 });
-
-  console.log('✅ Base project generated with variants applied');
 }
 
 module.exports = { generateProject };

package/src/index.js

@@ -2,6 +2,17 @@
 
 const chalk = require('chalk');
 const { isLaunchFrameProject } = require('./utils/project-helpers');
+const logger = require('./utils/logger');
+const { initTelemetry, trackEvent, sanitize, setTelemetryEnabled, showTelemetryStatus } = require('./utils/telemetry');
+
+// Detect locally linked version: npm link installs to global node_modules
+// as a symlink. When running from a real install, __dirname is inside the
+// global node_modules folder. When linked, it resolves to the source directory.
+const isDevMode = !__dirname.includes('node_modules');
+if (isDevMode) {
+  const packageJson = require('../package.json');
+  console.log(chalk.yellow(`⚠ Running locally linked CLI v${packageJson.version} (${__dirname})`));
+}
 
 // Import commands
 const { init } = require('./commands/init');
@@ -9,6 +20,7 @@ const { deployConfigure } = require('./commands/deploy-configure');
 const { deploySetEnv } = require('./commands/deploy-set-env');
 const { deployInit } = require('./commands/deploy-init');
 const { deployUp } = require('./commands/deploy-up');
+const { deployBuild } = require('./commands/deploy-build');
 const { waitlistDeploy } = require('./commands/waitlist-deploy');
 const { waitlistUp } = require('./commands/waitlist-up');
 const { waitlistDown } = require('./commands/waitlist-down');
@@ -17,6 +29,10 @@ const { dockerBuild } = require('./commands/docker-build');
 const { dockerUp } = require('./commands/docker-up');
 const { dockerDown } = require('./commands/docker-down');
 const { dockerLogs } = require('./commands/docker-logs');
+const { migrateRun } = require('./commands/migration-run');
+const { migrateCreate } = require('./commands/migration-create');
+const { migrateRevert } = require('./commands/migration-revert');
+const { databaseConsole } = require('./commands/database-console');
 const { dockerDestroy } = require('./commands/docker-destroy');
 const { doctor } = require('./commands/doctor');
 const { help } = require('./commands/help');
@@ -25,7 +41,13 @@ const {
   serviceList,
   serviceRemove
 } = require('./commands/service');
+const { moduleAdd, moduleList } = require('./commands/module');
 const { cacheClear, cacheInfo, cacheUpdate } = require('./commands/cache');
+const { devAddUser } = require('./commands/dev-add-user');
+const { devQueue } = require('./commands/dev-queue');
+const { devLogo } = require('./commands/dev-logo');
+const { devNpmInstall } = require('./commands/dev-npm-install');
+const { deploySyncFeatures } = require('./commands/deploy-sync-features');
 
 // Get command and arguments
 const command = process.argv[2];
@@ -62,9 +84,23 @@ function parseFlags(args) {
  * Main CLI router
  */
 async function main() {
+  initTelemetry();
+
   const inProject = isLaunchFrameProject();
   const flags = parseFlags(args);
 
+  // Handle version flag (only as standalone command)
+  if (command === '--version') {
+    const packageJson = require('../package.json');
+    console.log(packageJson.version);
+    process.exit(0);
+  }
+
+  // Set verbose mode globally
+  if (flags.verbose || flags.v) {
+    logger.setVerbose(true);
+  }
+
   // No command provided
   if (!command) {
     help();
@@ -74,7 +110,7 @@ async function main() {
   // Route commands
   switch (command) {
     case 'init':
-      await init({ 
+      await init({
         projectName: flags['project-name'],
         tenancy: flags['tenancy'],
         userModel: flags['user-model']
@@ -92,6 +128,12 @@ async function main() {
     case 'deploy:up':
       await deployUp();
       break;
+    case 'deploy:build':
+      await deployBuild(args[1]); // Optional service name
+      break;
+    case 'deploy:sync-features':
+      await deploySyncFeatures(flags);
+      break;
     case 'waitlist:deploy':
       await waitlistDeploy();
       break;
@@ -102,33 +144,45 @@ async function main() {
       await waitlistDown();
       break;
     case 'waitlist:logs':
-      await waitlistLogs();
+      await waitlistLogs(flags);
       break;
     case 'docker:build':
-      await dockerBuild();
+      await dockerBuild(args[1]); // Optional service name
       break;
     case 'docker:up':
-      await dockerUp(args[1]); // Pass optional service name
+      await dockerUp(args[1] || flags.service, flags);
       break;
     case 'docker:down':
       await dockerDown();
       break;
     case 'docker:logs':
-      await dockerLogs();
+      await dockerLogs(args[1] || flags.service, flags);
       break;
     case 'docker:destroy':
       await dockerDestroy({ force: flags.force || flags.f });
       break;
+    case 'migration:run':
+      await migrateRun();
+      break;
+    case 'migration:create':
+      await migrateCreate(args[1] || flags.name);
+      break;
+    case 'migration:revert':
+      await migrateRevert();
+      break;
+    case 'database:console':
+      await databaseConsole({ remote: flags.remote, query: flags.query });
+      break;
     case 'doctor':
       await doctor();
       break;
     case 'service:add':
-      if (!args[1]) {
+      if (!args[1] && !flags.service) {
         console.error(chalk.red('Error: Service name required'));
         console.log('Usage: launchframe service:add <service-name>');
         process.exit(1);
       }
-      await serviceAdd(args[1]);
+      await serviceAdd(args[1] || flags.service, flags);
       break;
     case 'service:list':
       await serviceList();
@@ -141,8 +195,19 @@ async function main() {
       }
       await serviceRemove(args[1]);
       break;
+    case 'module:add':
+      if (!args[1] && !flags.name) {
+        console.error(chalk.red('Error: Module name required'));
+        console.log('Usage: launchframe module:add <module-name>');
+        process.exit(1);
+      }
+      await moduleAdd(args[1] || flags.name, flags);
+      break;
+    case 'module:list':
+      await moduleList();
+      break;
     case 'cache:clear':
-      await cacheClear();
+      await cacheClear(flags);
       break;
     case 'cache:info':
       await cacheInfo();
@@ -150,16 +215,56 @@ async function main() {
     case 'cache:update':
       await cacheUpdate();
       break;
+    case 'dev:add-user':
+      await devAddUser();
+      break;
+    case 'dev:queue':
+      await devQueue();
+      break;
+    case 'dev:logo':
+      await devLogo(args[1] || flags.svg);
+      break;
+    case 'dev:npm-install':
+      if (!args[1]) {
+        console.error(chalk.red('Error: Service name required'));
+        console.log('Usage: launchframe dev:npm-install <service> [packages...]');
+        process.exit(1);
+      }
+      await devNpmInstall(args[1], args.slice(2));
+      break;
+    case 'telemetry':
+      if (flags.disable) {
+        setTelemetryEnabled(false);
+      } else if (flags.enable) {
+        setTelemetryEnabled(true);
+      } else {
+        showTelemetryStatus();
+      }
+      break;
     case 'help':
     case '--help':
     case '-h':
       help();
       break;
     default:
-      console.error(chalk.red(`\n❌ Unknown command: ${command}\n`));
+      console.error(chalk.red(`\nUnknown command: ${command}\n`));
       help();
       process.exit(1);
   }
 }
 
-main();
+main()
+  .then(() => {
+    if (command && command !== 'help' && command !== '--help' && command !== '-h' && command !== '--version') {
+      trackEvent('command_executed', { command, success: true });
+    }
+  })
+  .catch((error) => {
+    trackEvent('command_executed', {
+      command,
+      success: false,
+      error_message: sanitize(error.message)
+    });
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  });