@launchframe/cli 1.0.0-beta.9 → 1.0.0

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();
+      break;
     case 'waitlist:deploy':
       await waitlistDeploy();
       break;
@@ -105,7 +147,7 @@ async function main() {
       await waitlistLogs();
       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
@@ -119,6 +161,18 @@ async function main() {
     case 'docker:destroy':
       await dockerDestroy({ force: flags.force || flags.f });
       break;
+    case 'migration:run':
+      await migrateRun();
+      break;
+    case 'migration:create':
+      await migrateCreate();
+      break;
+    case 'migration:revert':
+      await migrateRevert();
+      break;
+    case 'database:console':
+      await databaseConsole({ remote: flags.remote });
+      break;
     case 'doctor':
       await doctor();
       break;
@@ -141,6 +195,17 @@ async function main() {
       }
       await serviceRemove(args[1]);
       break;
+    case 'module:add':
+      if (!args[1]) {
+        console.error(chalk.red('Error: Module name required'));
+        console.log('Usage: launchframe module:add <module-name>');
+        process.exit(1);
+      }
+      await moduleAdd(args[1]);
+      break;
+    case 'module:list':
+      await moduleList();
+      break;
     case 'cache:clear':
       await cacheClear();
       break;
@@ -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();
+      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);
+  });

package/src/services/module-config.js

@@ -0,0 +1,25 @@
+// Module configuration - defines files, sections, and dependencies for each module
+const MODULE_CONFIG = {
+  blog: {
+    website: {
+      files: [
+        'src/lib/blog.ts',
+        'src/types/blog.ts',
+        'src/app/blog',
+        'src/components/blog',
+        'src/app/sitemap.ts',
+        'content/blog',
+      ],
+      sections: {
+        'src/components/layout/Navbar.tsx': ['BLOG_NAV_LINK'],
+        'src/components/layout/Footer.tsx': ['BLOG_FOOTER_LINK'],
+      },
+      dependencies: {
+        'gray-matter': '^4.0.3',
+        'marked': '^12.0.0',
+      },
+    },
+  },
+};
+
+module.exports = { MODULE_CONFIG };

package/src/services/module-registry.js

@@ -0,0 +1,12 @@
+// Module registry - available modules for LaunchFrame services
+const MODULE_REGISTRY = {
+  blog: {
+    name: 'blog',
+    displayName: 'Blog',
+    description: 'Markdown-based blog using local .md files with YAML front-matter — no database required',
+    services: ['website'],
+    version: '1.0.0'
+  }
+};
+
+module.exports = { MODULE_REGISTRY };

package/src/services/variant-config.js

@@ -21,24 +21,16 @@ const VARIANT_CONFIG = {
         // Complete files/folders to copy
         files: [
           'src/modules/domain/projects',           // Entire projects module
-          'src/modules/domain/ai/services/project-config.service.ts', // Project config service
           'src/guards/project-ownership.guard.ts', // Project ownership guard (header-based)
           'src/guards/project-param.guard.ts',     // Project param guard (route-based)
-          'src/modules/auth/auth.service.ts',      // Auth service with multi-tenant support
-          'src/modules/auth/auth.controller.ts',   // Auth controller with multi-tenant support
           'src/modules/users/users.service.ts',    // Users service with multi-tenant support
           'src/modules/users/users.controller.ts', // Users controller with multi-tenant support
           'src/modules/users/create-user.dto.ts'   // CreateUserDto with businessId
         ],
 
         // Code sections to insert into base template files
+        // Note: main.ts uses PRIMARY_DOMAIN env var for dynamic CORS - no sections needed
         sections: {
-          'src/main.ts': [
-            'PROJECT_IMPORTS',              // Add project-related imports
-            'PROJECT_CUSTOM_DOMAINS',       // Add custom domains query
-            'PROJECT_CUSTOM_DOMAINS_CORS',  // Add custom domains to CORS
-            'PROJECT_GUARD'                 // Add ProjectOwnershipGuard registration
-          ],
           'src/modules/app/app.module.ts': [
             'PROJECTS_MODULE_IMPORT',       // Add ProjectsModule import
             'PROJECTS_MODULE'               // Add ProjectsModule to imports array
@@ -60,11 +52,15 @@ const VARIANT_CONFIG = {
         }
       },
 
-      // B2B2C variant: Adds regular_user support (for single-tenant only)
+      // B2B2C variant: Adds regular_user support with separate customer auth
       'b2b2c': {
         // Complete files to copy
         files: [
-          'src/modules/users/user-business.entity.ts',  // Business-to-user linking entity
+          'src/modules/users/user-business.entity.ts',           // Business-to-user linking entity
+          'src/modules/auth/auth-customer.ts',                   // Customer auth config (regular_user, customer_ cookie)
+          'src/modules/auth/better-auth-customer.controller.ts', // Customer auth controller (/api/auth/customer)
+          'src/modules/auth/auth.module.ts',                     // Auth module with customer controller
+          'src/modules/auth/better-auth.guard.ts',               // Guard handling both auth instances
         ],
 
         // Code sections to insert
@@ -77,6 +73,9 @@ const VARIANT_CONFIG = {
           'src/modules/users/users.module.ts': [
             'B2B2C_IMPORTS',           // Add UserBusiness import
             'B2B2C_ENTITIES'           // Add UserBusiness to TypeORM
+          ],
+          'src/database/migrations/1764300000001-CreateSessionsTable.ts': [
+            'B2B2C_TENANT_COLUMN'      // Add tenant_id column for session scoping
           ]
         }
       },
@@ -126,8 +125,7 @@ const VARIANT_CONFIG = {
         // Complete files to copy (has both multi-tenant and B2B2C features)
         files: [
           'src/modules/users/user-business.entity.ts',         // Business-to-user linking entity
-          'src/modules/auth/auth.service.ts',                  // Combined auth service
-          'src/modules/auth/auth.controller.ts',               // Combined auth controller
+          'src/modules/auth/auth.ts',                          // Combined Better Auth config
           'src/modules/users/users.service.ts',                // Combined users service
           'src/modules/users/users.controller.ts',             // Combined users controller
           'src/modules/domain/projects/projects.module.ts'     // Projects module with UserBusiness
@@ -310,6 +308,14 @@ const VARIANT_CONFIG = {
           'src/store/useProjectStore.ts'          // Project state
         ],
         sections: {}
+      },
+
+      'b2b2c': {
+        // B2B2C uses separate auth endpoint for customer sessions
+        files: [
+          'src/lib/auth-client.ts'                // Auth client with /api/auth/customer basePath
+        ],
+        sections: {}
       }
     },
 
@@ -395,6 +401,11 @@ function resolveVariantChoices(backendChoices) {
     choices['admin-portal'].userModel = backendChoices.userModel;
   }
 
+  // Special case: customers-portal inherits BOTH tenancy and userModel
+  if (choices['customers-portal']) {
+    choices['customers-portal'].userModel = backendChoices.userModel;
+  }
+
   // Special case: infrastructure needs BOTH tenancy and userModel for proper variant resolution
   if (choices['infrastructure']) {
     choices['infrastructure'].tenancy = backendChoices.tenancy;

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