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

package/package.json

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

package/src/commands/docker-build.js

@@ -6,8 +6,9 @@ const { requireProject } = require('../utils/project-helpers');
 
 /**
  * Build Docker images for the project
+ * @param {string} [serviceName] - Optional service to build (builds all if omitted)
  */
-async function dockerBuild() {
+async function dockerBuild(serviceName) {
   requireProject();
 
   const infrastructurePath = path.join(process.cwd(), 'infrastructure');
@@ -18,11 +19,11 @@ async function dockerBuild() {
     process.exit(1);
   }
 
-  console.log(chalk.blue.bold('\n🔨 Building Docker Images\n'));
-  console.log(chalk.gray('This will build all service images for local development...\n'));
+  const target = serviceName ? `${serviceName} service` : 'all services';
+  console.log(chalk.blue.bold(`\n🔨 Building Docker Images (${target})\n`));
 
   try {
-    const buildCommand = 'docker-compose -f docker-compose.yml -f docker-compose.dev.yml build';
+    const buildCommand = `docker-compose -f docker-compose.yml -f docker-compose.dev.yml build${serviceName ? ` ${serviceName}` : ''}`;
 
     console.log(chalk.gray(`Running: ${buildCommand}\n`));
 
@@ -32,8 +33,10 @@ async function dockerBuild() {
     });
 
     console.log(chalk.green.bold('\n✅ Docker images built successfully!\n'));
-    console.log(chalk.white('Next steps:'));
-    console.log(chalk.gray('  launchframe docker:up    # Start all services\n'));
+    if (!serviceName) {
+      console.log(chalk.white('Next steps:'));
+      console.log(chalk.gray('  launchframe docker:up    # Start all services\n'));
+    }
 
   } catch (error) {
     console.error(chalk.red('\n❌ Error during build:'), error.message);

package/src/commands/help.js

@@ -49,6 +49,9 @@ function help() {
     console.log(chalk.gray('  service:add <name>     Add an optional service to your project'));
     console.log(chalk.gray('  service:list           List available services'));
     console.log(chalk.gray('  service:remove <name>  Remove installed service\n'));
+    console.log(chalk.white('Module Management:'));
+    console.log(chalk.gray('  module:add <name>      Add a module to your project'));
+    console.log(chalk.gray('  module:list            List available modules\n'));
     console.log(chalk.white('Available Services:'));
     console.log(chalk.gray('  waitlist          Coming soon page with email collection\n'));
     console.log(chalk.white('Cache Management:'));

package/src/commands/module.js

@@ -0,0 +1,146 @@
+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) {
+  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(', ')}`);
+
+  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 in watch mode
+  await dockerUp();
+}
+
+module.exports = { moduleAdd, moduleList };

package/src/index.js

@@ -41,6 +41,7 @@ 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');
@@ -140,7 +141,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
@@ -188,6 +189,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;

package/src/services/module-config.js

@@ -0,0 +1,26 @@
+// Module configuration - defines files, sections, and dependencies for each module
+const MODULE_CONFIG = {
+  blog: {
+    website: {
+      modulesDir: 'blog',
+      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/utils/module-installer.js

@@ -0,0 +1,58 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+const { replaceSection } = require('./section-replacer');
+
+/**
+ * Install a module into a project
+ * @param {string} moduleName - Name of the module to install
+ * @param {Object} moduleConfig - Config object from MODULE_CONFIG[moduleName]
+ */
+async function installModule(moduleName, moduleConfig) {
+  const templateRoot = path.resolve(__dirname, '../../../services');
+  const cwd = process.cwd();
+
+  for (const [serviceName, config] of Object.entries(moduleConfig)) {
+    const moduleFilesDir = path.join(templateRoot, serviceName, 'modules', config.modulesDir, 'files');
+    const moduleSectionsDir = path.join(templateRoot, serviceName, 'modules', config.modulesDir, 'sections');
+    const serviceDir = path.join(cwd, serviceName);
+
+    // Copy files
+    for (const filePath of config.files) {
+      const src = path.join(moduleFilesDir, filePath);
+      const dest = path.join(serviceDir, filePath);
+      console.log(`  Adding ${filePath}`);
+      await fs.copy(src, dest, { overwrite: true });
+    }
+
+    // Inject sections
+    for (const [targetFile, markerNames] of Object.entries(config.sections)) {
+      const targetFilePath = path.join(serviceDir, targetFile);
+      const targetBasename = path.basename(targetFile);
+
+      for (const markerName of markerNames) {
+        const sectionFile = path.join(moduleSectionsDir, `${targetBasename}.${markerName}`);
+        console.log(`  Injecting ${markerName} into ${targetFile}`);
+        const sectionContent = await fs.readFile(sectionFile, 'utf8');
+        await replaceSection(targetFilePath, markerName, sectionContent);
+      }
+    }
+
+    // Merge dependencies into package.json and sync lockfile
+    if (config.dependencies && Object.keys(config.dependencies).length > 0) {
+      const packageJsonPath = path.join(serviceDir, 'package.json');
+      const packageJson = await fs.readJson(packageJsonPath);
+      packageJson.dependencies = {
+        ...packageJson.dependencies,
+        ...config.dependencies,
+      };
+      await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+
+      // Run npm install to sync package-lock.json, otherwise `npm ci` will fail on rebuild
+      console.log(`\nRunning npm install in ${serviceName}...`);
+      execSync('npm install', { cwd: serviceDir, stdio: 'inherit' });
+    }
+  }
+}
+
+module.exports = { installModule };

package/src/utils/project-helpers.js

@@ -95,6 +95,36 @@ function isWaitlistInstalled(config = null) {
   return (config.installedServices || []).includes('waitlist');
 }
 
+/**
+ * Get list of installed modules
+ */
+function getInstalledModules() {
+  const config = getProjectConfig();
+  return config.installedModules || [];
+}
+
+/**
+ * Check if a module is installed
+ */
+function isModuleInstalled(moduleName) {
+  const installedModules = getInstalledModules();
+  return installedModules.includes(moduleName);
+}
+
+/**
+ * Add a module to the installed modules list
+ */
+function addInstalledModule(moduleName) {
+  const config = getProjectConfig();
+  if (!config.installedModules) {
+    config.installedModules = [];
+  }
+  if (!config.installedModules.includes(moduleName)) {
+    config.installedModules.push(moduleName);
+    updateProjectConfig(config);
+  }
+}
+
 module.exports = {
   isLaunchFrameProject,
   requireProject,
@@ -104,5 +134,8 @@ module.exports = {
   isComponentInstalled,
   addInstalledComponent,
   getPrimaryDomain,
-  isWaitlistInstalled
+  isWaitlistInstalled,
+  getInstalledModules,
+  isModuleInstalled,
+  addInstalledModule
 };