@launchframe/cli 0.1.10 → 1.0.0-beta.1

package/README.md

@@ -4,14 +4,7 @@
 
 LaunchFrame is a production-ready SaaS boilerplate that deploys to a single affordable VPS. Get subscriptions, credits, multi-tenancy, feature gating, and API management out of the box.
 
-## Status
-
-LaunchFrame is currently in **private beta**. This CLI exists but does not yet generate projects.
-
-**[Join the waitlist at launchframe.dev](https://launchframe.dev)** to get early access, exclusive updates, and founding member perks.
-
-Here's a sneak peek of the CLI experience:
-![LaunchFrame CLI Preview](cli.png)
+![LaunchFrame CLI Preview](https://unpkg.com/@launchframe/cli@latest/cli.png)
 
 ## What You Get
 
@@ -30,14 +23,39 @@ Here's a sneak peek of the CLI experience:
 ## Installation
 
 ```bash
-npx @launchframe/cli init
+npm install -g @launchframe/cli
+```
+
+## Quick Start
+
+Initialize a new LaunchFrame project:
+
+```bash
+launchframe init
+```
+
+### Local Development
+
+Start the full stack locally with Docker:
+
+```bash
+launchframe docker:up
 ```
 
-## Early Access
+This spins up all services (backend, admin portal, customer portal, website, database, etc.) with hot-reload enabled. Build your domain logic, customize the UI, and test everything locally.
+
+### Deployment
+
+When you're ready to deploy to your VPS:
 
-LaunchFrame is currently in **private beta**.
+```bash
+launchframe deploy:configure  # Set up deployment configuration
+launchframe deploy:set-env    # Configure environment variables
+launchframe deploy:init       # Initialize the VPS
+launchframe deploy:up         # Deploy to production
+```
 
-Join the waitlist at **[launchframe.dev](https://launchframe.dev)** to get early access, exclusive updates, and founding member perks.
+**[Get started at launchframe.dev](https://launchframe.dev)** | **[Read the docs at docs.launchframe.dev](https://docs.launchframe.dev)**
 
 ## Why LaunchFrame?
 
@@ -53,6 +71,17 @@ Most SaaS boilerplates give you authentication and a database. LaunchFrame gives
 
 All tested in production. All ready to customize.
 
+## Documentation
+
+Full documentation is available at **[docs.launchframe.dev](https://docs.launchframe.dev)**, including:
+
+- Getting started guides
+- Architecture overview
+- Deployment instructions
+- API reference
+- Feature customization guides
+- Multi-tenancy patterns
+
 ## License
 
 MIT

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@launchframe/cli",
-  "version": "0.1.10",
+  "version": "1.0.0-beta.1",
   "description": "Production-ready B2B SaaS boilerplate with subscriptions, credits, and multi-tenancy",
   "main": "src/index.js",
   "bin": {
-    "launchframe": "./src/index.js"
+    "launchframe": "src/index.js"
   },
   "scripts": {
     "start": "node src/index.js"
@@ -28,7 +28,7 @@
   "homepage": "https://launchframe.dev",
   "repository": {
     "type": "git",
-    "url": "https://github.com/launchframe/cli"
+    "url": "git+https://github.com/launchframe/cli.git"
   },
   "bugs": {
     "url": "https://github.com/launchframe/cli/issues"
@@ -40,9 +40,9 @@
     "access": "public"
   },
   "dependencies": {
-    "inquirer": "^8.2.5",
     "chalk": "^4.1.2",
     "fs-extra": "^11.1.1",
-    "glob": "^10.3.10"
+    "glob": "^10.3.10",
+    "inquirer": "^8.2.5"
   }
 }

package/src/commands/cache.js

@@ -0,0 +1,102 @@
+const chalk = require('chalk');
+const { clearCache, getCacheInfo } = require('../utils/module-cache');
+
+/**
+ * Clear module cache
+ */
+async function cacheClear() {
+  console.log(chalk.yellow('\n⚠️  This will delete all cached modules'));
+  console.log(chalk.gray('You will need to re-download on next init or service:add\n'));
+  
+  const inquirer = require('inquirer');
+  const { confirmed } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirmed',
+    message: 'Continue with cache clear?',
+    default: false
+  }]);
+  
+  if (!confirmed) {
+    console.log('Cancelled');
+    return;
+  }
+  
+  await clearCache();
+}
+
+/**
+ * Show cache information
+ */
+async function cacheInfo() {
+  const info = await getCacheInfo();
+  
+  console.log(chalk.blue('\n📦 Module Cache Information\n'));
+  
+  console.log(chalk.white('Location:'));
+  console.log(chalk.gray(`  ${info.path}\n`));
+  
+  if (!info.exists) {
+    console.log(chalk.yellow('Status: Not initialized'));
+    console.log(chalk.gray('Cache will be created on first use\n'));
+    return;
+  }
+  
+  console.log(chalk.green('Status: Active\n'));
+  
+  if (info.size !== undefined) {
+    const sizeMB = (info.size / 1024 / 1024).toFixed(2);
+    console.log(chalk.white('Size:'));
+    console.log(chalk.gray(`  ${sizeMB} MB\n`));
+  }
+  
+  if (info.lastUpdate) {
+    console.log(chalk.white('Last Updated:'));
+    console.log(chalk.gray(`  ${info.lastUpdate.toLocaleString()}\n`));
+  }
+  
+  if (info.modules && info.modules.length > 0) {
+    console.log(chalk.white('Cached Modules:'));
+    info.modules.forEach(mod => {
+      console.log(chalk.gray(`  • ${mod}`));
+    });
+    console.log('');
+  } else {
+    console.log(chalk.gray('No modules cached yet\n'));
+  }
+  
+  console.log(chalk.gray('Commands:'));
+  console.log(chalk.gray('  launchframe cache:clear  - Delete cache'));
+  console.log(chalk.gray('  launchframe cache:update - Force update\n'));
+}
+
+/**
+ * Force update cache
+ */
+async function cacheUpdate() {
+  const { ensureCacheReady, getCacheInfo } = require('../utils/module-cache');
+  
+  console.log(chalk.blue('\n🔄 Forcing cache update...\n'));
+  
+  try {
+    const info = await getCacheInfo();
+    const currentModules = info.modules || [];
+    
+    if (currentModules.length === 0) {
+      console.log(chalk.yellow('No modules in cache yet. Use init or service:add to populate.\n'));
+      return;
+    }
+    
+    // Update cache with current modules
+    await ensureCacheReady(currentModules);
+    console.log(chalk.green('\n✓ Cache updated successfully\n'));
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Failed to update cache: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cacheClear,
+  cacheInfo,
+  cacheUpdate
+};

package/src/commands/deploy-configure.js

@@ -61,7 +61,24 @@ async function deployConfigure() {
   // Files that need template variable replacement
   const filesToUpdate = [
     'infrastructure/.env',
-    'infrastructure/.env.example'
+    'infrastructure/.env.example',
+    'infrastructure/docker-compose.yml',
+    'infrastructure/docker-compose.dev.yml',
+    'infrastructure/docker-compose.prod.yml',
+    'infrastructure/traefik.yml',
+    'backend/src/main.ts',
+    'admin-portal/.env.example',
+    'admin-portal/public/env-config.js',
+    'admin-portal/src/config/runtime.ts',
+    'admin-portal/src/config/pageMetadata.ts',
+    'admin-portal/src/pages/FirstProject.tsx',
+    'admin-portal/src/components/projects/NewProject.tsx',
+    'admin-portal/src/components/settings/CustomDomain.tsx',
+    'admin-portal/src/App.tsx',
+    'admin-portal/src/components/common/PageTitle.tsx',
+    'admin-portal/src/sentry.tsx',
+    'admin-portal/src/pages/AppSumo.tsx',
+    'customers-portal/src/App.tsx'
   ];
 
   const projectRoot = process.cwd();
@@ -134,14 +151,14 @@ async function deployConfigure() {
 
   const updatedConfig = {
     ...config,
-    primaryDomain: deployAnswers.primaryDomain,
-    githubOrg: deployAnswers.githubOrg,
-    vpsAppFolder: deployAnswers.vpsAppFolder,
     deployConfigured: true,
     deployment: {
       adminEmail: deployAnswers.adminEmail,
       vpsHost: deployAnswers.vpsHost,
       vpsUser: deployAnswers.vpsUser,
+      vpsAppFolder: deployAnswers.vpsAppFolder,
+      primaryDomain: deployAnswers.primaryDomain,
+      githubOrg: deployAnswers.githubOrg,
       ghcrToken: deployAnswers.ghcrToken,
       configuredAt: new Date().toISOString()
     }

package/src/commands/deploy-init.js

@@ -9,13 +9,11 @@ const {
   checkSSHKeys,
   executeSSH,
   copyFileToVPS,
-  copyDirectoryToVPS,
-  checkRepoPrivacy,
-  showDeployKeyInstructions
+  copyDirectoryToVPS
 } = require('../utils/ssh-helper');
 
 /**
- * Initial VPS setup - clone repo and configure environment
+ * Initial VPS setup - copy infrastructure files and configure environment
  */
 async function deployInit() {
   requireProject();
@@ -119,8 +117,9 @@ async function deployInit() {
     // Login to GHCR
     await loginToGHCR(githubOrg, ghcrToken);
 
-    // Build full-app images
-    await buildFullAppImages(projectRoot, projectName, githubOrg, envProdPath);
+    // Build full-app images (only for installed services)
+    const installedServices = config.installedServices || ['backend', 'admin-portal', 'website'];
+    await buildFullAppImages(projectRoot, projectName, githubOrg, envProdPath, installedServices);
 
     console.log(chalk.green.bold('\n✅ All images built and pushed to GHCR!\n'));
   } catch (error) {
@@ -137,57 +136,24 @@ async function deployInit() {
   }
 
 
-  // Step 4: Check repository privacy
-  console.log(chalk.yellow('🔍 Step 4: Checking repository access...\n'));
+  // Step 4: Create app directory and copy infrastructure files
+  console.log(chalk.yellow('📦 Step 4: Setting up application on VPS...\n'));
 
-  const repoCheck = await checkRepoPrivacy(githubOrg, projectName);
-  if (repoCheck.isPrivate) {
-    console.log(chalk.yellow('⚠️  Repository appears to be private or inaccessible\n'));
-    showDeployKeyInstructions(vpsUser, vpsHost, githubOrg, projectName);
-    process.exit(1);
-  }
-
-  console.log(chalk.green('✓ Repository is accessible (public)\n'));
-
-  // Step 5: Create app directory and clone repository
-  console.log(chalk.yellow('📦 Step 5: Setting up application on VPS...\n'));
-
-  const cloneSpinner = ora('Creating app directory...').start();
+  const setupSpinner = ora('Creating app directory...').start();
 
   try {
-    // Create directory
-    await executeSSH(vpsUser, vpsHost, `mkdir -p ${vpsAppFolder}`);
-    cloneSpinner.text = 'Cloning repository...';
-
-    // Check if directory is empty or has .git
-    const { stdout: lsOutput } = await executeSSH(vpsUser, vpsHost, `ls -A ${vpsAppFolder}`);
-
-    if (lsOutput.trim()) {
-      // Directory not empty
-      const { stdout: gitCheck } = await executeSSH(vpsUser, vpsHost, `test -d ${vpsAppFolder}/.git && echo "exists" || echo "missing"`);
-
-      if (gitCheck.trim() === 'exists') {
-        cloneSpinner.text = 'Repository already cloned, pulling latest changes...';
-        await executeSSH(vpsUser, vpsHost, `cd ${vpsAppFolder} && git pull origin main || git pull origin master`);
-      } else {
-        cloneSpinner.warn('Directory not empty and not a git repository');
-        console.log(chalk.yellow(`\n⚠️  Warning: ${vpsAppFolder} exists but is not a git repository\n`));
-        console.log(chalk.gray('Please clean up the directory or choose a different path.\n'));
-        process.exit(1);
-      }
-    } else {
-      // Clone fresh
-      await executeSSH(
-        vpsUser,
-        vpsHost,
-        `git clone https://github.com/${githubOrg}/${projectName}.git ${vpsAppFolder}`,
-        { timeout: 180000 } // 3 minutes for clone
-      );
-    }
+    // Create infrastructure directory on VPS
+    await executeSSH(vpsUser, vpsHost, `mkdir -p ${vpsAppFolder}/infrastructure`);
+    
+    setupSpinner.text = 'Copying infrastructure files to VPS...';
+
+    // Copy entire infrastructure directory to VPS
+    const infrastructurePath = path.join(projectRoot, 'infrastructure');
+    await copyDirectoryToVPS(infrastructurePath, vpsUser, vpsHost, `${vpsAppFolder}/infrastructure`);
 
-    cloneSpinner.succeed('Repository setup complete');
+    setupSpinner.succeed('Infrastructure files copied to VPS');
   } catch (error) {
-    cloneSpinner.fail('Failed to setup repository');
+    setupSpinner.fail('Failed to copy infrastructure files');
     console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
     process.exit(1);
   }
@@ -223,23 +189,23 @@ async function deployInit() {
     // If error, waitlist probably not running - continue
   }
 
-  // Step 6: Copy .env.prod to VPS
-  console.log(chalk.yellow('\n📄 Step 6: Copying production environment...\n'));
+  // Step 5: Copy .env.prod to VPS (overwrites .env copied from infrastructure/)
+  console.log(chalk.yellow('\n📄 Step 5: Configuring production environment...\n'));
 
   const envSpinner = ora('Copying .env.prod to VPS...').start();
 
   try {
     const remoteEnvPath = `${vpsAppFolder}/infrastructure/.env`;
     await copyFileToVPS(envProdPath, vpsUser, vpsHost, remoteEnvPath);
-    envSpinner.succeed('.env.prod copied successfully');
+    envSpinner.succeed('.env.prod copied as .env successfully');
   } catch (error) {
     envSpinner.fail('Failed to copy .env.prod');
     console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
     process.exit(1);
   }
 
-  // Step 7: Pull Docker images
-  console.log(chalk.yellow('\n🐳 Step 7: Pulling Docker images...\n'));
+  // Step 6: Pull Docker images
+  console.log(chalk.yellow('\n🐳 Step 6: Pulling Docker images...\n'));
   console.log(chalk.gray('This may take several minutes...\n'));
 
   const dockerSpinner = ora('Pulling Docker images...').start();
@@ -266,7 +232,7 @@ async function deployInit() {
   console.log(chalk.green.bold('\n✅ Initial VPS setup complete!\n'));
 
   console.log(chalk.white('Summary:'));
-  console.log(chalk.gray(`  - Repository cloned to: ${vpsAppFolder}`));
+  console.log(chalk.gray(`  - Infrastructure copied to: ${vpsAppFolder}`));
   console.log(chalk.gray('  - Production .env configured'));
   console.log(chalk.gray('  - Docker images pulled\n'));
 

package/src/commands/deploy-set-env.js

@@ -75,77 +75,65 @@ async function deploySetEnv() {
   const bullAdminToken = generateSecret(32);
 
   const answers = await inquirer.prompt([
-      {
-        type: 'password',
-        name: 'dbPassword',
-        message: 'Database password:',
-        default: dbPassword,
-        mask: '*'
-      },
-      {
-        type: 'password',
-        name: 'redisPassword',
-        message: 'Redis password:',
-        default: redisPassword,
-        mask: '*'
-      },
-      {
-        type: 'password',
-        name: 'jwtSecret',
-        message: 'JWT secret:',
-        default: jwtSecret,
-        mask: '*'
-      },
-      {
-        type: 'password',
-        name: 'bullAdminToken',
-        message: 'Bull Admin token:',
-        default: bullAdminToken,
-        mask: '*'
-      },
-      {
-        type: 'input',
-        name: 'resendApiKey',
-        message: 'Resend API key (email):',
-        default: ''
-      },
-      {
-        type: 'input',
-        name: 'openaiApiKey',
-        message: 'OpenAI API key:',
-        default: ''
-      },
-      {
-        type: 'input',
-        name: 'claudeApiKey',
-        message: 'Claude API key:',
-        default: ''
-      },
-      {
-        type: 'input',
-        name: 'polarAccessToken',
-        message: 'Polar Access Token:',
-        default: ''
-      },
-      {
-        type: 'input',
-        name: 'polarWebhookSecret',
-        message: 'Polar Webhook Secret:',
-        default: ''
-      },
-      {
-        type: 'input',
-        name: 'googleClientId',
-        message: 'Google OAuth Client ID:',
-        default: ''
-      },
-      {
-        type: 'input',
-        name: 'googleClientSecret',
-        message: 'Google OAuth Client Secret:',
-        default: ''
-      }
-    ]);
+    {
+      type: 'password',
+      name: 'dbPassword',
+      message: 'Database password:',
+      default: dbPassword,
+      mask: '*'
+    },
+    {
+      type: 'password',
+      name: 'redisPassword',
+      message: 'Redis password:',
+      default: redisPassword,
+      mask: '*'
+    },
+    {
+      type: 'password',
+      name: 'jwtSecret',
+      message: 'JWT secret:',
+      default: jwtSecret,
+      mask: '*'
+    },
+    {
+      type: 'password',
+      name: 'bullAdminToken',
+      message: 'Bull Admin token:',
+      default: bullAdminToken,
+      mask: '*'
+    },
+    {
+      type: 'input',
+      name: 'resendApiKey',
+      message: 'Resend API key (email):',
+      default: ''
+    },
+    {
+      type: 'input',
+      name: 'polarAccessToken',
+      message: 'Polar Access Token:',
+      default: ''
+    },
+    {
+      type: 'input',
+      name: 'polarWebhookSecret',
+      message: 'Polar Webhook Secret:',
+      default: ''
+    },
+    {
+      type: 'input',
+      name: 'googleClientId',
+      message: 'Google OAuth Client ID:',
+      default: ''
+    },
+    {
+      type: 'input',
+      name: 'googleClientSecret',
+      message: 'Google OAuth Client Secret:',
+      default: ''
+    }
+  ]);
 
   // Read current .env.prod content
   let envContent = await fs.readFile(envProdPath, 'utf8');
@@ -153,26 +141,15 @@ async function deploySetEnv() {
   // Replace values based on deployment mode
   const replacements = {};
 
-  if (isWaitlistMode) {
-    // Waitlist mode: only update Resend API key if provided
-    // Airtable credentials should already be in .env from component:add
-    if (answers.resendApiKey) {
-      replacements['RESEND_API_KEY'] = answers.resendApiKey;
-    }
-  } else {
-    // Full-app mode: update all configuration
-    replacements['DB_PASSWORD'] = answers.dbPassword;
-    replacements['REDIS_PASSWORD'] = answers.redisPassword;
-    replacements['JWT_SECRET'] = answers.jwtSecret;
-    replacements['BULL_ADMIN_TOKEN'] = answers.bullAdminToken;
-    replacements['RESEND_API_KEY'] = answers.resendApiKey || 're_your_resend_api_key';
-    replacements['OPENAI_API_KEY'] = answers.openaiApiKey || 'sk-your_openai_api_key';
-    replacements['CLAUDE_API_KEY'] = answers.claudeApiKey || 'sk-ant-your_claude_api_key';
-    replacements['POLAR_ACCESS_TOKEN'] = answers.polarAccessToken || 'polar_oat_your_token';
-    replacements['POLAR_WEBHOOK_SECRET'] = answers.polarWebhookSecret || 'polar_whs_your_secret';
-    replacements['GOOGLE_CLIENT_ID'] = answers.googleClientId || 'YOUR_GOOGLE_CLIENT_ID';
-    replacements['GOOGLE_CLIENT_SECRET'] = answers.googleClientSecret || 'YOUR_GOOGLE_CLIENT_SECRET';
-  }
+  replacements['DB_PASSWORD'] = answers.dbPassword;
+  replacements['REDIS_PASSWORD'] = answers.redisPassword;
+  replacements['JWT_SECRET'] = answers.jwtSecret;
+  replacements['BULL_ADMIN_TOKEN'] = answers.bullAdminToken;
+  replacements['RESEND_API_KEY'] = answers.resendApiKey || 're_your_resend_api_key';
+  replacements['POLAR_ACCESS_TOKEN'] = answers.polarAccessToken || 'polar_oat_your_token';
+  replacements['POLAR_WEBHOOK_SECRET'] = answers.polarWebhookSecret || 'polar_whs_your_secret';
+  replacements['GOOGLE_CLIENT_ID'] = answers.googleClientId || 'YOUR_GOOGLE_CLIENT_ID';
+  replacements['GOOGLE_CLIENT_SECRET'] = answers.googleClientSecret || 'YOUR_GOOGLE_CLIENT_SECRET';
 
   // Update environment variables
   for (const [key, value] of Object.entries(replacements)) {

package/src/commands/docker-destroy.js

@@ -47,36 +47,66 @@ async function dockerDestroy(options = {}) {
 
     console.log(chalk.yellow('\n🗑️  Destroying Docker resources...\n'));
 
-    // Step 1: Stop and remove all containers
-    console.log(chalk.gray('Stopping and removing containers...'));
+    // Step 1: Stop all running containers first
+    console.log(chalk.gray('Stopping running containers...'));
     try {
-      execSync(`docker ps -a --filter "name=${projectName}" -q | xargs -r docker rm -f`, { stdio: 'inherit' });
+      const runningContainerIds = execSync(`docker ps --filter "name=${projectName}" -q`, { encoding: 'utf8' }).trim();
+      if (runningContainerIds) {
+        const ids = runningContainerIds.replace(/\n/g, ' ');
+        // Use pipe mode instead of inherit to avoid Windows stdio issues
+        const output = execSync(`docker stop ${ids}`, { encoding: 'utf8' });
+        if (output) console.log(output);
+      }
+    } catch (error) {
+      // Ignore errors if no running containers
+    }
+
+    // Step 2: Remove all containers (running and stopped)
+    console.log(chalk.gray('Removing containers...'));
+    try {
+      const containerIds = execSync(`docker ps -a --filter "name=${projectName}" -q`, { encoding: 'utf8' }).trim();
+      if (containerIds) {
+        const ids = containerIds.replace(/\n/g, ' ');
+        const output = execSync(`docker rm -f ${ids}`, { encoding: 'utf8' });
+        if (output) console.log(output);
+      }
     } catch (error) {
       // Ignore errors if no containers found
     }
 
-    // Step 2: Remove all volumes
-    console.log(chalk.gray('Removing volumes...'));
+    // Step 3: Remove network (must be after containers are removed)
+    console.log(chalk.gray('Removing network...'));
     try {
-      execSync(`docker volume ls --filter "name=${projectName}" -q | xargs -r docker volume rm`, { stdio: 'inherit' });
+      const output = execSync(`docker network rm ${projectName}-network`, { encoding: 'utf8' });
+      if (output) console.log(output);
     } catch (error) {
-      // Ignore errors if no volumes found
+      // Ignore errors if network doesn't exist or has active endpoints
     }
 
-    // Step 3: Remove all images
-    console.log(chalk.gray('Removing images...'));
+    // Step 4: Remove all volumes (must be after containers are removed)
+    console.log(chalk.gray('Removing volumes...'));
     try {
-      execSync(`docker images --filter "reference=${projectName}*" -q | xargs -r docker rmi -f`, { stdio: 'inherit' });
+      const volumeIds = execSync(`docker volume ls --filter "name=${projectName}" -q`, { encoding: 'utf8' }).trim();
+      if (volumeIds) {
+        const ids = volumeIds.replace(/\n/g, ' ');
+        const output = execSync(`docker volume rm ${ids}`, { encoding: 'utf8' });
+        if (output) console.log(output);
+      }
     } catch (error) {
-      // Ignore errors if no images found
+      // Ignore errors if no volumes found
     }
 
-    // Step 4: Remove network
-    console.log(chalk.gray('Removing network...'));
+    // Step 5: Remove all images (do this last)
+    console.log(chalk.gray('Removing images...'));
     try {
-      execSync(`docker network rm ${projectName}-network`, { stdio: 'inherit' });
+      const imageIds = execSync(`docker images --filter "reference=${projectName}*" -q`, { encoding: 'utf8' }).trim();
+      if (imageIds) {
+        const ids = imageIds.replace(/\n/g, ' ');
+        const output = execSync(`docker rmi -f ${ids}`, { encoding: 'utf8' });
+        if (output) console.log(output);
+      }
     } catch (error) {
-      // Ignore errors if network doesn't exist
+      // Ignore errors if no images found
     }
 
     console.log(chalk.green.bold('\n✅ All Docker resources destroyed successfully!\n'));