@launchframe/cli 0.1.6

package/src/utils/env-validator.js

@@ -0,0 +1,75 @@
+const fs = require('fs-extra');
+
+/**
+ * Check if a file contains any template placeholders ({{VAR}})
+ * @param {string} filePath - Path to file to check
+ * @returns {Promise<{hasPlaceholders: boolean, placeholders: string[]}>}
+ */
+async function checkForPlaceholders(filePath) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+
+    // Regex to find {{VAR}} patterns (but not ${{VAR}} which is GitHub Actions)
+    const placeholderRegex = /(?<!\$)\{\{([A-Z_][A-Z0-9_]*)\}\}/g;
+    const placeholders = [];
+    let match;
+
+    while ((match = placeholderRegex.exec(content)) !== null) {
+      const placeholder = match[0]; // Full match including {{ }}
+      if (!placeholders.includes(placeholder)) {
+        placeholders.push(placeholder);
+      }
+    }
+
+    return {
+      hasPlaceholders: placeholders.length > 0,
+      placeholders
+    };
+  } catch (error) {
+    throw new Error(`Failed to read file ${filePath}: ${error.message}`);
+  }
+}
+
+/**
+ * Validate that .env.prod file exists and has no placeholders
+ * @param {string} envProdPath - Path to .env.prod file
+ * @returns {Promise<{valid: boolean, error?: string, placeholders?: string[]}>}
+ */
+async function validateEnvProd(envProdPath) {
+  // Check if file exists
+  if (!await fs.pathExists(envProdPath)) {
+    return {
+      valid: false,
+      error: 'File does not exist'
+    };
+  }
+
+  // Check for placeholders
+  const { hasPlaceholders, placeholders } = await checkForPlaceholders(envProdPath);
+
+  if (hasPlaceholders) {
+    return {
+      valid: false,
+      error: 'File contains placeholder variables',
+      placeholders
+    };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Generate a secure random string for secrets
+ * @param {number} length - Length of string to generate
+ * @returns {string}
+ */
+function generateSecret(length = 32) {
+  const crypto = require('crypto');
+  return crypto.randomBytes(length).toString('base64').slice(0, length);
+}
+
+module.exports = {
+  checkForPlaceholders,
+  validateEnvProd,
+  generateSecret
+};

package/src/utils/file-ops.js

@@ -0,0 +1,87 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Copy a directory recursively with whitelist or blacklist filtering
+ * @param {string} source - Source directory path
+ * @param {string} destination - Destination directory path
+ * @param {Object} options - Options object
+ * @param {string[]} options.exclude - Array of directory names to exclude (blacklist approach)
+ * @param {string[]} options.include - Array of directory names to include (whitelist approach, takes precedence)
+ */
+async function copyDirectory(source, destination, options = {}) {
+  const { exclude = ['node_modules', '.git', '.next', 'dist', 'build', '.env'], include = null } = options;
+
+  // Ensure destination exists
+  await fs.ensureDir(destination);
+
+  // Read directory contents
+  const entries = await fs.readdir(source, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const sourcePath = path.join(source, entry.name);
+    const destPath = path.join(destination, entry.name);
+
+    // Always check exclude list first (applies at all levels)
+    if (exclude.includes(entry.name)) {
+      continue;
+    }
+
+    // Whitelist approach: if include array is provided, only copy items in the list (only at top level)
+    if (include !== null && include.length > 0) {
+      if (!include.includes(entry.name)) {
+        continue;
+      }
+    }
+
+    if (entry.isDirectory()) {
+      // Recursively copy directory (pass exclude, remove include for nested levels)
+      await copyDirectory(sourcePath, destPath, { exclude });
+    } else {
+      // Copy file
+      await fs.copy(sourcePath, destPath);
+    }
+  }
+}
+
+/**
+ * Delete a file
+ * @param {string} filePath - Path to file
+ */
+async function deleteFile(filePath) {
+  await fs.remove(filePath);
+}
+
+/**
+ * Delete a directory
+ * @param {string} dirPath - Path to directory
+ */
+async function deleteDirectory(dirPath) {
+  await fs.remove(dirPath);
+}
+
+/**
+ * Copy a single file
+ * @param {string} source - Source file path
+ * @param {string} destination - Destination file path
+ */
+async function copyFile(source, destination) {
+  await fs.copy(source, destination);
+}
+
+/**
+ * Move a file
+ * @param {string} source - Source file path
+ * @param {string} destination - Destination file path
+ */
+async function moveFile(source, destination) {
+  await fs.move(source, destination);
+}
+
+module.exports = {
+  copyDirectory,
+  deleteFile,
+  deleteDirectory,
+  copyFile,
+  moveFile
+};

package/src/utils/project-helpers.js

@@ -0,0 +1,104 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Check if current directory is a LaunchFrame project
+ */
+function isLaunchFrameProject() {
+  const markerPath = path.join(process.cwd(), '.launchframe');
+  return fs.existsSync(markerPath);
+}
+
+/**
+ * Require that the current directory is a LaunchFrame project
+ * Exits with error if not
+ */
+function requireProject() {
+  if (!isLaunchFrameProject()) {
+    console.error(chalk.red('\n❌ Error: Not in a LaunchFrame project'));
+    console.log(chalk.gray('Run this command from the root of your LaunchFrame project.\n'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Get project configuration from .launchframe file
+ */
+function getProjectConfig() {
+  requireProject();
+  const markerPath = path.join(process.cwd(), '.launchframe');
+  const content = fs.readFileSync(markerPath, 'utf8');
+  return JSON.parse(content);
+}
+
+/**
+ * Update project configuration in .launchframe file
+ */
+function updateProjectConfig(config) {
+  const markerPath = path.join(process.cwd(), '.launchframe');
+  fs.writeFileSync(markerPath, JSON.stringify(config, null, 2), 'utf8');
+}
+
+/**
+ * Get list of installed services
+ */
+function getInstalledComponents() {
+  const config = getProjectConfig();
+  return config.installedServices || [];
+}
+
+/**
+ * Check if a service is installed
+ */
+function isComponentInstalled(componentName) {
+  const installedComponents = getInstalledComponents();
+  return installedComponents.includes(componentName);
+}
+
+/**
+ * Add a service to the installed services list
+ */
+function addInstalledComponent(componentName) {
+  const config = getProjectConfig();
+  if (!config.installedServices) {
+    config.installedServices = [];
+  }
+  if (!config.installedServices.includes(componentName)) {
+    config.installedServices.push(componentName);
+    updateProjectConfig(config);
+  }
+}
+
+/**
+ * Get primary domain from config
+ * @param {Object} config - Project config object
+ * @returns {string|null} Primary domain
+ */
+function getPrimaryDomain(config) {
+  return config.primaryDomain || null;
+}
+
+/**
+ * Check if waitlist service is installed
+ * @param {Object} config - Project config object (optional, will fetch if not provided)
+ * @returns {boolean}
+ */
+function isWaitlistInstalled(config = null) {
+  if (!config) {
+    config = getProjectConfig();
+  }
+  return (config.installedServices || []).includes('waitlist');
+}
+
+module.exports = {
+  isLaunchFrameProject,
+  requireProject,
+  getProjectConfig,
+  updateProjectConfig,
+  getInstalledComponents,
+  isComponentInstalled,
+  addInstalledComponent,
+  getPrimaryDomain,
+  isWaitlistInstalled
+};

package/src/utils/section-replacer.js

@@ -0,0 +1,71 @@
+const fs = require('fs-extra');
+
+/**
+ * Replace a marked section in a file
+ * @param {string} filePath - Path to file
+ * @param {string} sectionName - Name of section (e.g., 'CORS_CONFIG')
+ * @param {string} newContent - New content to insert
+ */
+async function replaceSection(filePath, sectionName, newContent) {
+  const content = await fs.readFile(filePath, 'utf8');
+
+  // Try both comment formats (// for regular comments, {/* */} for JSX)
+  const startMarkerRegular = `// ${sectionName}_START`;
+  const endMarkerRegular = `// ${sectionName}_END`;
+  const startMarkerJSX = `{/* ${sectionName}_START */}`;
+  const endMarkerJSX = `{/* ${sectionName}_END */}`;
+
+  let startIndex = content.indexOf(startMarkerRegular);
+  let endIndex = content.indexOf(endMarkerRegular);
+  let isJSX = false;
+
+  // If not found with regular comments, try JSX comments
+  if (startIndex === -1 || endIndex === -1) {
+    startIndex = content.indexOf(startMarkerJSX);
+    endIndex = content.indexOf(endMarkerJSX);
+    isJSX = true;
+  }
+
+  if (startIndex === -1 || endIndex === -1) {
+    throw new Error(`Section markers not found: ${sectionName} in ${filePath}`);
+  }
+
+  // Find the end of the end marker line
+  const endLineEnd = content.indexOf('\n', endIndex);
+
+  // Construct new content - exclude both marker lines
+  const before = content.substring(0, startIndex);
+  const after = content.substring(endLineEnd + 1);
+  const replaced = before + newContent + after;
+
+  await fs.writeFile(filePath, replaced, 'utf8');
+}
+
+/**
+ * Check if a file contains a specific section marker
+ * @param {string} filePath - Path to file
+ * @param {string} sectionName - Name of section
+ * @returns {Promise<boolean>} - True if section exists
+ */
+async function hasSection(filePath, sectionName) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    const startMarkerRegular = `// ${sectionName}_START`;
+    const endMarkerRegular = `// ${sectionName}_END`;
+    const startMarkerJSX = `{/* ${sectionName}_START */}`;
+    const endMarkerJSX = `{/* ${sectionName}_END */}`;
+
+    // Check both comment formats
+    const hasRegular = content.includes(startMarkerRegular) && content.includes(endMarkerRegular);
+    const hasJSX = content.includes(startMarkerJSX) && content.includes(endMarkerJSX);
+
+    return hasRegular || hasJSX;
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = {
+  replaceSection,
+  hasSection
+};

package/src/utils/ssh-helper.js

@@ -0,0 +1,220 @@
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+const execAsync = promisify(exec);
+
+/**
+ * Test SSH connection to VPS
+ * @param {string} vpsUser - SSH username
+ * @param {string} vpsHost - VPS hostname or IP
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function testSSHConnection(vpsUser, vpsHost) {
+  try {
+    // Try a simple SSH command (echo test)
+    await execAsync(`ssh -o ConnectTimeout=10 -o BatchMode=yes ${vpsUser}@${vpsHost} "echo 'Connection successful'"`, {
+      timeout: 15000
+    });
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Check if SSH keys are configured
+ * @returns {Promise<{hasKeys: boolean, keyPaths: string[]}>}
+ */
+async function checkSSHKeys() {
+  const homeDir = os.homedir();
+  const sshDir = path.join(homeDir, '.ssh');
+
+  const commonKeyNames = [
+    'id_rsa',
+    'id_ed25519',
+    'id_ecdsa',
+    'id_dsa'
+  ];
+
+  const keyPaths = [];
+
+  for (const keyName of commonKeyNames) {
+    const keyPath = path.join(sshDir, keyName);
+    if (await fs.pathExists(keyPath)) {
+      keyPaths.push(keyPath);
+    }
+  }
+
+  return {
+    hasKeys: keyPaths.length > 0,
+    keyPaths
+  };
+}
+
+/**
+ * Execute SSH command on VPS
+ * @param {string} vpsUser - SSH username
+ * @param {string} vpsHost - VPS hostname or IP
+ * @param {string} command - Command to execute
+ * @param {Object} options - Execution options
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+async function executeSSH(vpsUser, vpsHost, command, options = {}) {
+  const { timeout = 120000 } = options;
+
+  try {
+    const { stdout, stderr } = await execAsync(
+      `ssh -o ConnectTimeout=10 ${vpsUser}@${vpsHost} "${command.replace(/"/g, '\\"')}"`,
+      { timeout }
+    );
+    return { stdout, stderr };
+  } catch (error) {
+    throw new Error(`SSH command failed: ${error.message}`);
+  }
+}
+
+/**
+ * Copy file to VPS via SCP
+ * @param {string} localPath - Local file path
+ * @param {string} vpsUser - SSH username
+ * @param {string} vpsHost - VPS hostname or IP
+ * @param {string} remotePath - Remote file path
+ * @returns {Promise<void>}
+ */
+async function copyFileToVPS(localPath, vpsUser, vpsHost, remotePath) {
+  try {
+    await execAsync(`scp "${localPath}" ${vpsUser}@${vpsHost}:"${remotePath}"`, {
+      timeout: 60000
+    });
+  } catch (error) {
+    throw new Error(`Failed to copy file: ${error.message}`);
+  }
+}
+
+/**
+ * Copy entire directory to VPS using tar + scp
+ * @param {string} localDir - Local directory path
+ * @param {string} vpsUser - SSH username
+ * @param {string} vpsHost - VPS hostname or IP
+ * @param {string} remoteDir - Remote directory path
+ * @returns {Promise<void>}
+ */
+async function copyDirectoryToVPS(localDir, vpsUser, vpsHost, remoteDir) {
+  const path = require('path');
+  const fs = require('fs-extra');
+
+  try {
+    // Create a temporary tarball excluding unnecessary files
+    const tarballName = `deploy-${Date.now()}.tar.gz`;
+    const tarballPath = path.join('/tmp', tarballName);
+
+    // Create tarball with exclusions
+    await execAsync(
+      `tar -czf "${tarballPath}" -C "${localDir}" --exclude='node_modules' --exclude='.next' --exclude='dist' --exclude='build' --exclude='.git' --exclude='*.log' .`,
+      { timeout: 60000 }
+    );
+
+    // Ensure remote directory exists
+    await execAsync(
+      `ssh ${vpsUser}@${vpsHost} "mkdir -p ${remoteDir}"`,
+      { timeout: 30000 }
+    );
+
+    // Copy tarball to VPS
+    await execAsync(
+      `scp "${tarballPath}" ${vpsUser}@${vpsHost}:/tmp/${tarballName}`,
+      { timeout: 180000 } // 3 minutes
+    );
+
+    // Extract tarball on VPS
+    await execAsync(
+      `ssh ${vpsUser}@${vpsHost} "tar -xzf /tmp/${tarballName} -C ${remoteDir} && rm /tmp/${tarballName}"`,
+      { timeout: 60000 }
+    );
+
+    // Clean up local tarball
+    await fs.remove(tarballPath);
+  } catch (error) {
+    throw new Error(`Failed to copy directory: ${error.message}`);
+  }
+}
+
+/**
+ * Check if repository is private by attempting to clone
+ * @param {string} githubOrg - GitHub organization/username
+ * @param {string} projectName - Project name
+ * @returns {Promise<{isPrivate: boolean, error?: string}>}
+ */
+async function checkRepoPrivacy(githubOrg, projectName) {
+  try {
+    // Try to get repository info via HTTPS (no auth)
+    await execAsync(`git ls-remote https://github.com/${githubOrg}/${projectName}.git HEAD`, {
+      timeout: 10000
+    });
+    return { isPrivate: false };
+  } catch (error) {
+    // If error contains "authentication" or "not found", likely private or doesn't exist
+    if (error.message.includes('Authentication') || error.message.includes('not found')) {
+      return {
+        isPrivate: true,
+        error: 'Repository appears to be private or does not exist'
+      };
+    }
+    // Other errors
+    return {
+      isPrivate: true,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Display instructions for setting up deploy keys for private repository
+ * @param {string} vpsUser - SSH username
+ * @param {string} vpsHost - VPS hostname or IP
+ * @param {string} githubOrg - GitHub organization/username
+ * @param {string} projectName - Project name
+ */
+function showDeployKeyInstructions(vpsUser, vpsHost, githubOrg, projectName) {
+  console.log(chalk.yellow('\n📝 Private Repository Detected\n'));
+  console.log(chalk.white('Your repository appears to be private. Follow these steps:\n'));
+
+  console.log(chalk.white('1. SSH to your VPS:'));
+  console.log(chalk.gray(`   ssh ${vpsUser}@${vpsHost}\n`));
+
+  console.log(chalk.white('2. Generate SSH key (if not already exists):'));
+  console.log(chalk.gray(`   ssh-keygen -t ed25519 -C "deploy-key-${projectName}"\n`));
+
+  console.log(chalk.white('3. Display the public key:'));
+  console.log(chalk.gray('   cat ~/.ssh/id_ed25519.pub\n'));
+
+  console.log(chalk.white('4. Add deploy key to GitHub:'));
+  console.log(chalk.gray(`   - Go to: https://github.com/${githubOrg}/${projectName}/settings/keys`));
+  console.log(chalk.gray('   - Click "Add deploy key"'));
+  console.log(chalk.gray('   - Paste the public key'));
+  console.log(chalk.gray('   - Title: "VPS Deploy Key"'));
+  console.log(chalk.gray('   - Check "Allow write access" if needed\n'));
+
+  console.log(chalk.white('5. Test the connection:'));
+  console.log(chalk.gray('   ssh -T git@github.com\n'));
+
+  console.log(chalk.white('6. Then retry:'));
+  console.log(chalk.gray('   launchframe deploy:init\n'));
+}
+
+module.exports = {
+  testSSHConnection,
+  checkSSHKeys,
+  executeSSH,
+  copyFileToVPS,
+  copyDirectoryToVPS,
+  checkRepoPrivacy,
+  showDeployKeyInstructions
+};

package/src/utils/variable-replacer.js

@@ -0,0 +1,95 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { glob } = require('glob');
+
+/**
+ * Replace template variables in all files within a directory
+ * @param {string} directory - Root directory to search
+ * @param {Object} variables - Object with variable mappings (e.g., {'{{VAR}}': 'value'})
+ */
+async function replaceVariables(directory, variables) {
+  // Find all files (excluding node_modules, .git, binary files)
+  const files = await glob('**/*', {
+    cwd: directory,
+    nodir: true,
+    dot: true, // Include hidden files/directories like .vitepress
+    ignore: [
+      '**/node_modules/**',
+      '**/.git/**',
+      '**/.next/**',
+      '**/dist/**',
+      '**/build/**',
+      '**/*.png',
+      '**/*.jpg',
+      '**/*.jpeg',
+      '**/*.gif',
+      '**/*.ico',
+      '**/*.pdf',
+      '**/*.woff',
+      '**/*.woff2',
+      '**/*.ttf',
+      '**/*.eot'
+    ]
+  });
+
+  for (const file of files) {
+    const filePath = path.join(directory, file);
+    await replaceVariablesInFile(filePath, variables);
+  }
+}
+
+/**
+ * Escape special regex characters in a string
+ * @param {string} string - String to escape
+ * @returns {string} Escaped string safe for use in regex
+ */
+function escapeRegex(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Replace template variables in a single file
+ * Uses negative lookbehind to avoid replacing GitHub Actions syntax (${{ }})
+ * @param {string} filePath - Path to file
+ * @param {Object} variables - Object with variable mappings
+ */
+async function replaceVariablesInFile(filePath, variables) {
+  try {
+    let content = await fs.readFile(filePath, 'utf8');
+    let modified = false;
+
+    // Replace each variable using regex with negative lookbehind
+    for (const [placeholder, value] of Object.entries(variables)) {
+      // Create regex that matches {{VAR}} but NOT ${{VAR}}
+      // Negative lookbehind: (?<!\$) means "not preceded by $"
+      const escapedPlaceholder = escapeRegex(placeholder);
+      const regex = new RegExp(`(?<!\\$)${escapedPlaceholder}`, 'g');
+
+      if (regex.test(content)) {
+        // Reset regex lastIndex after test
+        regex.lastIndex = 0;
+        content = content.replace(regex, value);
+        modified = true;
+      }
+    }
+
+    // Only write if changes were made
+    if (modified) {
+      await fs.writeFile(filePath, content, 'utf8');
+    }
+
+    return modified;
+  } catch (error) {
+    // Skip binary files or files that can't be read as text
+    if (error.code !== 'EISDIR') {
+      // Log warning but continue
+      console.warn(`Warning: Could not process ${filePath}`);
+    }
+    return false;
+  }
+}
+
+module.exports = {
+  replaceVariables,
+  replaceVariablesInFile
+};