@launchframe/cli 1.0.0-beta.18 → 1.0.0-beta.19

package/CLAUDE.md

@@ -0,0 +1,27 @@
+# LaunchFrame CLI
+
+CLI tool for generating new projects from the LaunchFrame template.
+
+## Purpose
+
+The CLI takes user input (project name, domain, GitHub org, etc.) and:
+1. Copies the `services/` template
+2. Replaces all `{{TEMPLATE_VARIABLES}}`
+3. Generates secrets (DB password, auth secret)
+4. Sets up the project structure
+
+## Template Variables
+
+The CLI replaces these placeholders in all files:
+- `{{PROJECT_NAME}}` - lowercase project name
+- `{{PROJECT_NAME_UPPER}}` - uppercase project name
+- `{{GITHUB_ORG}}` - GitHub organization/username
+- `{{PRIMARY_DOMAIN}}` - main domain (e.g., mysaas.com)
+- `{{ADMIN_EMAIL}}` - admin email for Let's Encrypt
+- `{{VPS_HOST}}` - VPS hostname/IP
+- `{{BETTER_AUTH_SECRET}}` - auto-generated (32+ chars)
+- `{{DB_PASSWORD}}` - auto-generated
+
+## Development
+
+TODO: CLI implementation details

package/package.json

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

package/src/commands/deploy-build.js

@@ -1,12 +1,8 @@
 const chalk = require('chalk');
-const { exec } = require('child_process');
-const { promisify } = require('util');
-const ora = require('ora');
 const path = require('path');
 const { requireProject, getProjectConfig } = require('../utils/project-helpers');
-const { checkDockerRunning, loginToGHCR, buildFullAppImages, buildAndPushImage } = require('../utils/docker-helper');
-
-const execAsync = promisify(exec);
+const { buildAndPushWorkflow } = require('../utils/docker-helper');
+const { pullImagesOnVPS, restartServicesOnVPS } = require('../utils/ssh-helper');
 
 /**
  * Build, push, and deploy Docker images
@@ -29,102 +25,45 @@ async function deployBuild(serviceName) {
     process.exit(1);
   }
 
-  const { vpsHost, vpsUser, vpsAppFolder, githubOrg } = config.deployment;
+  const { vpsHost, vpsUser, vpsAppFolder, githubOrg, ghcrToken } = config.deployment;
   const { projectName, installedServices } = config;
   const envProdPath = path.join(projectRoot, 'infrastructure', '.env.prod');
 
-  // Step 1: Check Docker is running
-  console.log(chalk.yellow('🐳 Step 1: Checking Docker...\n'));
-
-  const dockerSpinner = ora('Checking Docker...').start();
-
-  const dockerRunning = await checkDockerRunning();
-  if (!dockerRunning) {
-    dockerSpinner.fail('Docker is not running');
-    console.log(chalk.red('\n❌ Please start Docker and try again.\n'));
-    process.exit(1);
-  }
-
-  dockerSpinner.succeed('Docker is running');
-
-  // Step 2: Login to GHCR
-  console.log(chalk.yellow('\n🔐 Step 2: Logging in to GitHub Container Registry...\n'));
-
-  const ghcrToken = config.deployment.ghcrToken;
-  if (!ghcrToken) {
-    console.log(chalk.red('❌ Error: GHCR token not found in .launchframe config\n'));
-    console.log(chalk.gray('Run deploy:configure to set up your GitHub token.\n'));
-    process.exit(1);
-  }
+  // Step 1-3: Build and push images
+  console.log(chalk.yellow('🐳 Step 1: Building and pushing images...\n'));
 
   try {
-    await loginToGHCR(githubOrg, ghcrToken);
+    await buildAndPushWorkflow({
+      projectRoot,
+      projectName,
+      githubOrg,
+      ghcrToken,
+      envProdPath,
+      installedServices,
+      serviceName
+    });
   } catch (error) {
     console.log(chalk.red(`\n❌ ${error.message}\n`));
     process.exit(1);
   }
 
-  // Step 3: Build and push images
-  console.log(chalk.yellow('\n📦 Step 3: Building and pushing images...\n'));
-
-  try {
-    if (serviceName) {
-      // Build specific service
-      if (!installedServices.includes(serviceName)) {
-        console.log(chalk.red(`❌ Service "${serviceName}" not found in installed services.\n`));
-        console.log(chalk.gray(`Available services: ${installedServices.join(', ')}\n`));
-        process.exit(1);
-      }
-
-      const registry = `ghcr.io/${githubOrg}`;
-      await buildAndPushImage(
-        serviceName,
-        path.join(projectRoot, serviceName),
-        registry,
-        projectName
-      );
-      console.log(chalk.green.bold(`\n✅ ${serviceName} built and pushed to GHCR!\n`));
-    } else {
-      // Build all services
-      await buildFullAppImages(projectRoot, projectName, githubOrg, envProdPath, installedServices);
-      console.log(chalk.green.bold('\n✅ All images built and pushed to GHCR!\n'));
-    }
-  } catch (error) {
-    console.log(chalk.red(`\n❌ Build failed: ${error.message}\n`));
-    process.exit(1);
-  }
-
   // Step 4: Pull images on VPS
-  console.log(chalk.yellow('\n🚀 Step 4: Pulling images on VPS...\n'));
-
-  const pullSpinner = ora('Pulling images on VPS...').start();
+  console.log(chalk.yellow('🚀 Step 2: Pulling images on VPS...\n'));
 
   try {
-    await execAsync(
-      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml pull"`,
-      { timeout: 600000 } // 10 minutes
-    );
-    pullSpinner.succeed('Images pulled on VPS');
+    await pullImagesOnVPS(vpsUser, vpsHost, vpsAppFolder);
   } catch (error) {
-    pullSpinner.fail('Failed to pull images');
-    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    console.log(chalk.red(`\n❌ ${error.message}\n`));
     process.exit(1);
   }
 
   // Step 5: Restart services
-  console.log(chalk.yellow('\n🔄 Step 5: Restarting services...\n'));
-
-  const restartSpinner = ora('Restarting services...').start();
+  console.log(chalk.yellow('\n🔄 Step 3: Restarting services...\n'));
 
   try {
-    await execAsync(
-      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d"`,
-      { timeout: 300000 } // 5 minutes
-    );
-    restartSpinner.succeed('Services restarted');
+    await restartServicesOnVPS(vpsUser, vpsHost, vpsAppFolder);
   } catch (error) {
-    restartSpinner.fail('Failed to restart services');
-    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    console.log(chalk.red(`\n❌ ${error.message}\n`));
     process.exit(1);
   }
 

package/src/commands/deploy-configure.js

@@ -59,8 +59,8 @@ async function deployConfigure() {
   console.log(chalk.yellow('\n⚙️  Updating configuration files...\n'));
 
   // Files that need template variable replacement
+  // Note: infrastructure/.env is NOT updated - it's for local development only
   const filesToUpdate = [
-    'infrastructure/.env',
     'infrastructure/.env.example',
     'infrastructure/docker-compose.yml',
     'infrastructure/docker-compose.dev.yml',

package/src/commands/deploy-init.js

@@ -1,6 +1,5 @@
 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');
@@ -9,8 +8,10 @@ const {
   checkSSHKeys,
   executeSSH,
   copyFileToVPS,
-  copyDirectoryToVPS
+  copyDirectoryToVPS,
+  pullImagesOnVPS
 } = require('../utils/ssh-helper');
+const { buildAndPushWorkflow } = require('../utils/docker-helper');
 
 /**
  * Initial VPS setup - copy infrastructure files and configure environment
@@ -30,8 +31,8 @@ async function deployInit() {
     process.exit(1);
   }
 
-  const { vpsHost, vpsUser, vpsAppFolder, githubOrg } = config.deployment;
-  const { projectName } = config;
+  const { vpsHost, vpsUser, vpsAppFolder, githubOrg, ghcrToken } = config.deployment;
+  const { projectName, installedServices } = config;
   const projectRoot = process.cwd();
   const envProdPath = path.join(projectRoot, 'infrastructure', '.env.prod');
 
@@ -86,42 +87,18 @@ async function deployInit() {
   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);
-  }
+  // Step 4: Build and push Docker images
+  console.log(chalk.yellow('🐳 Step 4: Building Docker images locally...\n'));
 
   try {
-    // Login to GHCR
-    await loginToGHCR(githubOrg, ghcrToken);
-
-    // 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'));
+    await buildAndPushWorkflow({
+      projectRoot,
+      projectName,
+      githubOrg,
+      ghcrToken,
+      envProdPath,
+      installedServices: installedServices || ['backend', 'admin-portal', 'website']
+    });
   } catch (error) {
     console.log(chalk.red('\n❌ Failed to build Docker images\n'));
     console.log(chalk.gray('Error:'), error.message, '\n');
@@ -135,16 +112,15 @@ async function deployInit() {
     process.exit(1);
   }
 
-
-  // Step 4: Create app directory and copy infrastructure files
-  console.log(chalk.yellow('📦 Step 4: Setting up application on VPS...\n'));
+  // Step 5: Create app directory and copy infrastructure files
+  console.log(chalk.yellow('📦 Step 5: Setting up application on VPS...\n'));
 
   const setupSpinner = ora('Creating app directory...').start();
 
   try {
     // 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
@@ -205,8 +181,8 @@ async function deployInit() {
     // If error, waitlist probably not running - continue
   }
 
-  // Step 5: Copy .env.prod to VPS (overwrites .env copied from infrastructure/)
-  console.log(chalk.yellow('\n📄 Step 5: Configuring production environment...\n'));
+  // Step 6: Copy .env.prod to VPS (overwrites .env copied from infrastructure/)
+  console.log(chalk.yellow('\n📄 Step 6: Configuring production environment...\n'));
 
   const envSpinner = ora('Copying .env.prod to VPS...').start();
 
@@ -220,27 +196,18 @@ async function deployInit() {
     process.exit(1);
   }
 
-  // Step 6: Pull Docker images
-  console.log(chalk.yellow('\n🐳 Step 6: Pulling Docker images...\n'));
+  // Step 7: Pull Docker images
+  console.log(chalk.yellow('\n🐳 Step 7: Pulling Docker images on VPS...\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');
+    await pullImagesOnVPS(vpsUser, vpsHost, vpsAppFolder);
   } 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'));
+    console.log(chalk.white(`  sudo usermod -aG docker ${vpsUser}\n`));
     process.exit(1);
   }
 

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

@@ -163,12 +163,21 @@ async function deploySetEnv() {
   // Update production URLs based on deployment config
   if (config.deployment?.primaryDomain) {
     const domain = config.deployment.primaryDomain;
+    const adminEmail = config.deployment.adminEmail || `admin@${domain}`;
+
+    // First, replace all {{PRIMARY_DOMAIN}} and {{ADMIN_EMAIL}} placeholders globally
+    envContent = envContent.split('{{PRIMARY_DOMAIN}}').join(domain);
+    envContent = envContent.split('{{ADMIN_EMAIL}}').join(adminEmail);
+
+    // Then update specific URL variables for production
     const urlReplacements = {
       'PRIMARY_DOMAIN': domain,
+      'NODE_ENV': 'production',
       'API_BASE_URL': `https://api.${domain}`,
       'ADMIN_BASE_URL': `https://admin.${domain}`,
-      'FRONTEND_BASE_URL': `https://app.${domain}`,
-      'WEBSITE_BASE_URL': `https://${domain}`
+      'FRONTEND_BASE_URL': `https://${domain}`,
+      'WEBSITE_BASE_URL': `https://www.${domain}`,
+      'GOOGLE_REDIRECT_URI': `https://api.${domain}/auth/google/callback`
     };
 
     for (const [key, value] of Object.entries(urlReplacements)) {

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,16 +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
 };

package/src/utils/env-generator.js

@@ -31,11 +31,12 @@ async function generateEnvFile(projectRoot, answers) {
   };
 
   // Create variable mappings
+  // Note: PRIMARY_DOMAIN and ADMIN_EMAIL are NOT replaced here - they stay as placeholders
+  // until deploy:configure and deploy:set-env are run
   const variables = {
     '{{PROJECT_NAME}}': answers.projectName,
     '{{PROJECT_NAME_UPPER}}': answers.projectNameUpper,
-    '{{PRIMARY_DOMAIN}}': answers.primaryDomain,
-    '{{ADMIN_EMAIL}}': answers.adminEmail,
+    '{{PROJECT_DISPLAY_NAME}}': answers.projectDisplayName,
 
     // Replace placeholder passwords with generated secrets
     'your_secure_postgres_password': secrets.DB_PASSWORD,
@@ -43,10 +44,12 @@ async function generateEnvFile(projectRoot, answers) {
     'your_bull_admin_token': secrets.BULL_ADMIN_TOKEN
   };
 
-  // Replace variables in template
+  // Replace variables in template (only those with defined values)
   let envContent = envTemplate;
   for (const [placeholder, value] of Object.entries(variables)) {
-    envContent = envContent.split(placeholder).join(value);
+    if (value !== undefined && value !== null) {
+      envContent = envContent.split(placeholder).join(value);
+    }
   }
 
   // Write .env file

package/src/utils/env-validator.js

@@ -59,13 +59,15 @@ async function validateEnvProd(envProdPath) {
 }
 
 /**
- * Generate a secure random string for secrets
+ * Generate a secure random string for secrets (URL-safe)
  * @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);
+  // Use hex encoding to avoid URL-unsafe characters (+, /, =)
+  // Hex produces 2 chars per byte, so divide by 2
+  return crypto.randomBytes(Math.ceil(length / 2)).toString('hex').slice(0, length);
 }
 
 module.exports = {

package/src/utils/ssh-helper.js

@@ -209,6 +209,54 @@ function showDeployKeyInstructions(vpsUser, vpsHost, githubOrg, projectName) {
   console.log(chalk.gray('   launchframe deploy:init\n'));
 }
 
+/**
+ * Pull Docker images on VPS
+ * @param {string} vpsUser - SSH username
+ * @param {string} vpsHost - VPS hostname or IP
+ * @param {string} vpsAppFolder - App folder path on VPS
+ * @returns {Promise<void>}
+ */
+async function pullImagesOnVPS(vpsUser, vpsHost, vpsAppFolder) {
+  const ora = require('ora');
+
+  const spinner = ora('Pulling images on VPS...').start();
+
+  try {
+    await execAsync(
+      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml pull"`,
+      { timeout: 600000 } // 10 minutes
+    );
+    spinner.succeed('Images pulled on VPS');
+  } catch (error) {
+    spinner.fail('Failed to pull images on VPS');
+    throw new Error(`Failed to pull images: ${error.message}`);
+  }
+}
+
+/**
+ * Restart services on VPS
+ * @param {string} vpsUser - SSH username
+ * @param {string} vpsHost - VPS hostname or IP
+ * @param {string} vpsAppFolder - App folder path on VPS
+ * @returns {Promise<void>}
+ */
+async function restartServicesOnVPS(vpsUser, vpsHost, vpsAppFolder) {
+  const ora = require('ora');
+
+  const spinner = ora('Restarting services...').start();
+
+  try {
+    await execAsync(
+      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d"`,
+      { timeout: 300000 } // 5 minutes
+    );
+    spinner.succeed('Services restarted');
+  } catch (error) {
+    spinner.fail('Failed to restart services');
+    throw new Error(`Failed to restart services: ${error.message}`);
+  }
+}
+
 module.exports = {
   testSSHConnection,
   checkSSHKeys,
@@ -216,5 +264,7 @@ module.exports = {
   copyFileToVPS,
   copyDirectoryToVPS,
   checkRepoPrivacy,
-  showDeployKeyInstructions
+  showDeployKeyInstructions,
+  pullImagesOnVPS,
+  restartServicesOnVPS
 };