@launchframe/cli 0.1.6

package/README.md

@@ -0,0 +1,59 @@
+# LaunchFrame CLI
+
+> Ship your B2B SaaS to production in hours, not weeks.
+
+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.
+
+## What You Get
+
+- **Single VPS deployment**: Everything runs on one $7-20/mo server (Docker + Traefik)
+- **Variant selection on init**: Choose single/multi-tenant, B2B/B2B2C - optimized for your use case
+- **Service registry**: Add new services (docs, waitlist, admin tools) with zero config
+- **Full-stack TypeScript**: NestJS backend, React frontends, Next.js marketing site
+- **Monetization built-in**: Subscriptions (Polar.sh MOR) + usage-based credits
+- **Flexible tenancy models**: Single-tenant (simpler) or multi-tenant (workspaces + custom domains)
+- **B2B + B2B2C support**: Admin-only or admin+end-user models
+- **Feature guard system**: Tier-based access control across frontend and backend
+- **Production-grade auth**: JWT + OAuth (Google), role-based access control
+- **API-first**: Auto-generated OpenAPI docs, API key management
+- **Resilient architecture**: Background jobs, webhook processing, health checks
+
+## Installation
+
+```bash
+npx @launchframe/cli init
+```
+
+## Early Access
+
+LaunchFrame is currently in **private beta**.
+
+Join the waitlist at **[launchframe.dev](https://launchframe.dev)** to get early access, exclusive updates, and founding member perks.
+
+## Why LaunchFrame?
+
+Most SaaS boilerplates give you authentication and a database. LaunchFrame gives you a **complete business**:
+
+- Subscriptions AND credits (hybrid monetization)
+- Feature flags tied to billing tiers
+- Multi-tenant architecture with project isolation
+- Webhook processing that actually scales
+- API key system with usage tracking
+- Zero-downtime deployment patterns
+- Comprehensive documentation
+
+All tested in production. All ready to customize.
+
+## Status
+
+This CLI is **preview-only** - it demonstrates the architecture but doesn't yet generate fully functional projects.
+
+For production-ready access and full documentation, **[join the waitlist](https://launchframe.dev)**.
+
+## License
+
+MIT
+
+---
+
+Built with ⚡ by developers who were tired of rebuilding the same SaaS infrastructure over and over.

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@launchframe/cli",
+  "version": "0.1.6",
+  "description": "Production-ready B2B SaaS boilerplate with subscriptions, credits, and multi-tenancy",
+  "main": "src/index.js",
+  "bin": {
+    "launchframe": "./src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "keywords": [
+    "saas",
+    "boilerplate",
+    "template",
+    "nestjs",
+    "react",
+    "nextjs",
+    "typescript",
+    "subscriptions",
+    "multi-tenant",
+    "b2b",
+    "starter-kit",
+    "cli"
+  ],
+  "author": "LaunchFrame",
+  "license": "MIT",
+  "homepage": "https://launchframe.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/launchframe/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/launchframe/cli/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "inquirer": "^8.2.5",
+    "chalk": "^4.1.2",
+    "fs-extra": "^11.1.1",
+    "glob": "^10.3.10"
+  }
+}

package/src/commands/deploy-configure.js

@@ -0,0 +1,219 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const path = require('path');
+const ora = require('ora');
+const { runDeployPrompts } = require('../prompts');
+const { requireProject, getProjectConfig, updateProjectConfig } = require('../utils/project-helpers');
+const { replaceVariablesInFile } = require('../utils/variable-replacer');
+const { testSSHConnection, executeSSH } = require('../utils/ssh-helper');
+
+/**
+ * Configure deployment settings
+ */
+async function deployConfigure() {
+  requireProject();
+
+  console.log(chalk.blue.bold('\n🚀 LaunchFrame Deployment Configuration\n'));
+
+  // Check if already configured
+  const config = getProjectConfig();
+  if (config.deployConfigured) {
+    console.log(chalk.yellow('⚠️  Deployment already configured. This will update existing settings.\n'));
+    console.log(chalk.gray('Current configuration:'));
+    console.log(chalk.gray(`  Domain: ${config.deployment?.primaryDomain || 'Not set'}`));
+    console.log(chalk.gray(`  Email: ${config.deployment?.adminEmail || 'Not set'}`));
+    console.log(chalk.gray(`  GitHub Org: ${config.deployment?.githubOrg || config.githubOrg || 'Not set'}`));
+    console.log(chalk.gray(`  VPS Host: ${config.deployment?.vpsHost || 'Not set'}`));
+    console.log(chalk.gray(`  VPS User: ${config.deployment?.vpsUser || 'Not set'}`));
+    console.log(chalk.gray(`  VPS App Folder: ${config.deployment?.vpsAppFolder || config.vpsAppFolder || 'Not set'}\n`));
+
+    const { proceed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'proceed',
+        message: 'Continue with reconfiguration?',
+        default: false
+      }
+    ]);
+
+    if (!proceed) {
+      console.log(chalk.yellow('\n❌ Configuration cancelled\n'));
+      return;
+    }
+  }
+
+  console.log(chalk.yellow('Configure your production deployment settings.\n'));
+  console.log(chalk.gray('Note: VPS credentials (SSH keys, passwords) are managed via GitHub Secrets.'));
+  console.log(chalk.gray('This command configures domain and connection details.\n'));
+
+  const deployAnswers = await runDeployPrompts(config.projectName);
+
+  // Prepare variable mappings for file replacement
+  const variables = {
+    '{{PRIMARY_DOMAIN}}': deployAnswers.primaryDomain,
+    '{{ADMIN_EMAIL}}': deployAnswers.adminEmail,
+    '{{GITHUB_ORG}}': deployAnswers.githubOrg,
+    '{{VPS_APP_FOLDER}}': deployAnswers.vpsAppFolder
+  };
+
+  console.log(chalk.yellow('\n⚙️  Updating configuration files...\n'));
+
+  // Files that need template variable replacement
+  const filesToUpdate = [
+    'infrastructure/.env',
+    'infrastructure/.env.example'
+  ];
+
+  const projectRoot = process.cwd();
+  let filesUpdated = 0;
+
+  for (const relativePath of filesToUpdate) {
+    const filePath = path.join(projectRoot, relativePath);
+
+    try {
+      const fs = require('fs-extra');
+      if (!await fs.pathExists(filePath)) {
+        console.log(chalk.gray(`  ⊘ Skipping ${relativePath} (not found)`));
+        continue;
+      }
+
+      const modified = await replaceVariablesInFile(filePath, variables);
+      if (modified) {
+        console.log(chalk.green(`  ✓ Updated ${relativePath}`));
+        filesUpdated++;
+      } else {
+        console.log(chalk.gray(`  − No changes needed in ${relativePath}`));
+      }
+    } catch (error) {
+      console.log(chalk.red(`  ✗ Failed to update ${relativePath}: ${error.message}`));
+    }
+  }
+
+  // Update all installed component .env.prod files with new domain
+  const installedComponents = config.installedComponents || [];
+  if (installedComponents.length > 0) {
+    console.log(chalk.yellow('\n⚙️  Updating component environment files...\n'));
+
+    for (const componentName of installedComponents) {
+      const componentEnvProdPath = path.join(projectRoot, componentName, '.env.prod');
+
+      try {
+        const fs = require('fs-extra');
+        if (!await fs.pathExists(componentEnvProdPath)) {
+          console.log(chalk.gray(`  ⊘ Skipping ${componentName}/.env.prod (not found)`));
+          continue;
+        }
+
+        // Read current .env.prod content
+        let envContent = await fs.readFile(componentEnvProdPath, 'utf8');
+
+        // Replace PRIMARY_DOMAIN with new value
+        const oldDomainMatch = envContent.match(/PRIMARY_DOMAIN=.*/);
+        if (oldDomainMatch) {
+          const newEnvContent = envContent.replace(
+            /PRIMARY_DOMAIN=.*/,
+            `PRIMARY_DOMAIN=${deployAnswers.primaryDomain}`
+          );
+
+          if (newEnvContent !== envContent) {
+            await fs.writeFile(componentEnvProdPath, newEnvContent, 'utf8');
+            console.log(chalk.green(`  ✓ Updated ${componentName}/.env.prod`));
+            filesUpdated++;
+          } else {
+            console.log(chalk.gray(`  − No changes needed in ${componentName}/.env.prod`));
+          }
+        }
+      } catch (error) {
+        console.log(chalk.red(`  ✗ Failed to update ${componentName}/.env.prod: ${error.message}`));
+      }
+    }
+  }
+
+  // Update .launchframe config
+  console.log(chalk.yellow('\n📝 Saving configuration...\n'));
+
+  const updatedConfig = {
+    ...config,
+    primaryDomain: deployAnswers.primaryDomain,
+    githubOrg: deployAnswers.githubOrg,
+    vpsAppFolder: deployAnswers.vpsAppFolder,
+    deployConfigured: true,
+    deployment: {
+      adminEmail: deployAnswers.adminEmail,
+      vpsHost: deployAnswers.vpsHost,
+      vpsUser: deployAnswers.vpsUser,
+      ghcrToken: deployAnswers.ghcrToken,
+      configuredAt: new Date().toISOString()
+    }
+  };
+
+  updateProjectConfig(updatedConfig);
+
+  // Authenticate to GHCR on VPS
+  console.log(chalk.yellow('\n🔐 Authenticating to GitHub Container Registry on VPS...\n'));
+
+  const authSpinner = ora('Testing VPS connection...').start();
+
+  try {
+    // Test SSH connection
+    const connectionTest = await testSSHConnection(deployAnswers.vpsUser, deployAnswers.vpsHost);
+
+    if (!connectionTest.success) {
+      authSpinner.warn('Could not connect to VPS');
+      console.log(chalk.yellow('\n⚠️  Warning: Unable to authenticate to GHCR on VPS\n'));
+      console.log(chalk.gray(`Error: ${connectionTest.error}`));
+      console.log(chalk.gray('\nYou can authenticate manually later by running:'));
+      console.log(chalk.white(`  ssh ${deployAnswers.vpsUser}@${deployAnswers.vpsHost} "echo 'YOUR_GHCR_TOKEN' | docker login ghcr.io -u ${deployAnswers.githubOrg} --password-stdin"\n`));
+    } else {
+      authSpinner.text = 'Logging into GitHub Container Registry...';
+
+      // Login to GHCR on VPS
+      await executeSSH(
+        deployAnswers.vpsUser,
+        deployAnswers.vpsHost,
+        `echo '${deployAnswers.ghcrToken}' | docker login ghcr.io -u ${deployAnswers.githubOrg} --password-stdin`
+      );
+
+      authSpinner.succeed('VPS authenticated to GitHub Container Registry');
+      console.log(chalk.gray('  Docker can now pull images from ghcr.io\n'));
+    }
+  } catch (error) {
+    authSpinner.warn('Could not authenticate to GHCR');
+    console.log(chalk.yellow('\n⚠️  Warning: Failed to authenticate to GHCR on VPS\n'));
+    console.log(chalk.gray(`Error: ${error.message}`));
+    console.log(chalk.gray('\nYou can authenticate manually later by running:'));
+    console.log(chalk.white(`  ssh ${deployAnswers.vpsUser}@${deployAnswers.vpsHost} "echo 'YOUR_GHCR_TOKEN' | docker login ghcr.io -u ${deployAnswers.githubOrg} --password-stdin"\n`));
+  }
+
+  console.log(chalk.green.bold('\n✅ Deployment configuration complete!\n'));
+  console.log(chalk.white('Configuration saved to:'));
+  console.log(chalk.gray(`  - .launchframe`));
+  if (filesUpdated > 0) {
+    console.log(chalk.gray(`  - ${filesUpdated} file(s) updated\n`));
+  }
+
+  console.log(chalk.white('Prerequisites:\n'));
+  console.log(chalk.white('• Docker must be installed and running locally'));
+  console.log(chalk.gray('  (Required for building production images during deploy:init)\n'));
+
+  console.log(chalk.white('Next steps:\n'));
+  console.log(chalk.white('1. Configure GitHub Secrets (required for CI/CD):'));
+  console.log(chalk.gray(`   Repository: https://github.com/${deployAnswers.githubOrg}/${config.projectName}/settings/secrets/actions`));
+  console.log(chalk.gray(`   Required secrets:`));
+  console.log(chalk.gray(`     - VPS_HOST: ${deployAnswers.vpsHost}`));
+  console.log(chalk.gray(`     - VPS_USER: ${deployAnswers.vpsUser}`));
+  console.log(chalk.gray(`     - VPS_SSH_KEY: (your private SSH key)`));
+  console.log(chalk.gray(`     - GHCR_TOKEN: (use the same token you just provided)`));
+
+  console.log(chalk.white('\n2. Point DNS records to your VPS:'));
+  console.log(chalk.gray(`   - A record: ${deployAnswers.primaryDomain} → VPS IP`));
+  console.log(chalk.gray(`   - A record: *.${deployAnswers.primaryDomain} → VPS IP`));
+
+  console.log(chalk.white('\n3. Configure production environment variables:'));
+  console.log(chalk.gray(`   Run: launchframe deploy:set-env`));
+
+  console.log(chalk.white('\n4. Initial VPS deployment:'));
+  console.log(chalk.gray(`   Run: launchframe deploy:init\n`));
+}
+
+module.exports = { deployConfigure };

package/src/commands/deploy-init.js

@@ -0,0 +1,277 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const ora = require('ora');
+const { requireProject, getProjectConfig } = require('../utils/project-helpers');
+const { validateEnvProd } = require('../utils/env-validator');
+const {
+  testSSHConnection,
+  checkSSHKeys,
+  executeSSH,
+  copyFileToVPS,
+  copyDirectoryToVPS,
+  checkRepoPrivacy,
+  showDeployKeyInstructions
+} = require('../utils/ssh-helper');
+
+/**
+ * Initial VPS setup - clone repo and configure environment
+ */
+async function deployInit() {
+  requireProject();
+
+  console.log(chalk.blue.bold('\n🚀 LaunchFrame Initial VPS Setup\n'));
+
+  const config = getProjectConfig();
+
+  // Validate deployment is configured
+  if (!config.deployConfigured || !config.deployment) {
+    console.log(chalk.red('❌ Error: Deployment not configured yet\n'));
+    console.log(chalk.gray('Run this command first:'));
+    console.log(chalk.white('  launchframe deploy:configure\n'));
+    process.exit(1);
+  }
+
+  const { vpsHost, vpsUser, vpsAppFolder, githubOrg } = config.deployment;
+  const { projectName } = config;
+  const projectRoot = process.cwd();
+  const envProdPath = path.join(projectRoot, 'infrastructure', '.env.prod');
+
+  // Step 1: Validate .env.prod exists and has no placeholders
+  console.log(chalk.yellow('📋 Step 1: Validating production environment...\n'));
+
+  const validation = await validateEnvProd(envProdPath);
+  if (!validation.valid) {
+    console.log(chalk.red(`❌ Error: ${validation.error}\n`));
+
+    if (validation.placeholders) {
+      console.log(chalk.yellow('Placeholder variables found:'));
+      validation.placeholders.forEach(p => console.log(chalk.gray(`  - ${p}`)));
+      console.log();
+    }
+
+    console.log(chalk.gray('Run this command first:'));
+    console.log(chalk.white('  launchframe deploy:set-env\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.green('✓ Production environment validated\n'));
+
+  // Step 2: Check SSH keys
+  console.log(chalk.yellow('🔑 Step 2: Checking SSH configuration...\n'));
+
+  const { hasKeys, keyPaths } = await checkSSHKeys();
+  if (!hasKeys) {
+    console.log(chalk.yellow('⚠️  Warning: No SSH keys found in ~/.ssh/\n'));
+    console.log(chalk.gray('You may need to generate SSH keys:'));
+    console.log(chalk.white('  ssh-keygen -t ed25519\n'));
+  } else {
+    console.log(chalk.green(`✓ Found SSH keys: ${keyPaths.length} key(s)\n`));
+  }
+
+  // Step 3: Test SSH connection
+  console.log(chalk.yellow('🔌 Step 3: Testing VPS connection...\n'));
+
+  const spinner = ora('Connecting to VPS...').start();
+  const connectionTest = await testSSHConnection(vpsUser, vpsHost);
+
+  if (!connectionTest.success) {
+    spinner.fail('Failed to connect to VPS');
+    console.log(chalk.red(`\n❌ SSH connection failed: ${connectionTest.error}\n`));
+    console.log(chalk.gray('Troubleshooting:'));
+    console.log(chalk.gray(`  - Check VPS is online: ping ${vpsHost}`));
+    console.log(chalk.gray(`  - Test SSH manually: ssh ${vpsUser}@${vpsHost}`));
+    console.log(chalk.gray('  - Verify SSH keys are configured\n'));
+    process.exit(1);
+  }
+
+  spinner.succeed('Connected to VPS successfully');
+  console.log();
+
+  // Step 3.5: Build and push Docker images
+  console.log(chalk.yellow('🐳 Step 3.5: Building Docker images locally...\n'));
+
+  // Check if Docker is running
+  const {
+    checkDockerRunning,
+    loginToGHCR,
+    buildFullAppImages
+  } = require('../utils/docker-helper');
+
+  const dockerRunning = await checkDockerRunning();
+  if (!dockerRunning) {
+    console.log(chalk.red('❌ Docker is not running\n'));
+    console.log(chalk.gray('Please start Docker Desktop and try again.\n'));
+    console.log(chalk.gray('Docker is required to build production images for deployment.\n'));
+    process.exit(1);
+  }
+
+  // Validate GHCR token is configured
+  const { ghcrToken } = config.deployment || {};
+  if (!ghcrToken) {
+    console.log(chalk.red('❌ GHCR token not configured\n'));
+    console.log(chalk.gray('Run this command first:'));
+    console.log(chalk.white('  launchframe deploy:configure\n'));
+    process.exit(1);
+  }
+
+  try {
+    // Login to GHCR
+    await loginToGHCR(githubOrg, ghcrToken);
+
+    // Build full-app images
+    await buildFullAppImages(projectRoot, projectName, githubOrg, envProdPath);
+
+    console.log(chalk.green.bold('\n✅ All images built and pushed to GHCR!\n'));
+  } catch (error) {
+    console.log(chalk.red('\n❌ Failed to build Docker images\n'));
+    console.log(chalk.gray('Error:'), error.message, '\n');
+    console.log(chalk.gray('Common issues:'));
+    console.log(chalk.gray('  - Invalid GHCR token (check write:packages permission)'));
+    console.log(chalk.gray('  - Dockerfile syntax errors'));
+    console.log(chalk.gray('  - Insufficient disk space (~10GB required)'));
+    console.log(chalk.gray('  - Network connection issues\n'));
+    console.log(chalk.white('To create a valid token:'));
+    console.log(chalk.gray('  https://github.com/settings/tokens/new\n'));
+    process.exit(1);
+  }
+
+
+  // Step 4: Check repository privacy
+  console.log(chalk.yellow('🔍 Step 4: Checking repository access...\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();
+
+  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
+      );
+    }
+
+    cloneSpinner.succeed('Repository setup complete');
+  } catch (error) {
+    cloneSpinner.fail('Failed to setup repository');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+
+  // Check if waitlist is running and stop it (full-app deployment)
+  try {
+    const { stdout: psOutput } = await executeSSH(
+      vpsUser,
+      vpsHost,
+      `docker ps --filter "name=${projectName}-waitlist" --format "{{.Names}}"`,
+      { timeout: 10000 }
+    );
+
+    if (psOutput.trim()) {
+      console.log(chalk.yellow('\n⚠️  Waitlist is currently running. Stopping it...\n'));
+
+      const stopSpinner = ora('Stopping waitlist containers...').start();
+
+      try {
+        await executeSSH(
+          vpsUser,
+          vpsHost,
+          `cd ${vpsAppFolder}/waitlist && docker-compose -f docker-compose.waitlist.yml down`,
+          { timeout: 30000 }
+        );
+        stopSpinner.succeed('Waitlist stopped');
+      } catch (stopError) {
+        stopSpinner.warn('Could not stop waitlist automatically');
+        console.log(chalk.gray('You may need to stop it manually after deployment.\n'));
+      }
+    }
+  } catch (error) {
+    // 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'));
+
+  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');
+  } 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'));
+  console.log(chalk.gray('This may take several minutes...\n'));
+
+  const dockerSpinner = ora('Pulling Docker images...').start();
+
+  try {
+    await executeSSH(
+      vpsUser,
+      vpsHost,
+      `cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml pull`,
+      { timeout: 600000 } // 10 minutes for image pull
+    );
+    dockerSpinner.succeed('Docker images pulled successfully');
+  } catch (error) {
+    dockerSpinner.fail('Failed to pull Docker images');
+    console.log(chalk.yellow(`\n⚠️  Warning: ${error.message}\n`));
+    console.log(chalk.gray('This might mean Docker is not installed on the VPS.'));
+    console.log(chalk.gray('Please install Docker and Docker Compose:\n'));
+    console.log(chalk.white('  curl -fsSL https://get.docker.com | sh'));
+    console.log(chalk.white('  sudo usermod -aG docker ${vpsUser}\n'));
+    process.exit(1);
+  }
+
+  // Success!
+  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('  - Production .env configured'));
+  console.log(chalk.gray('  - Docker images pulled\n'));
+
+  console.log(chalk.white('Next step:'));
+  console.log(chalk.gray('  Run: launchframe deploy:up\n'));
+}
+
+module.exports = { deployInit };