[#1] Implemented branch deployment feature.

README.md

@@ -48,6 +48,7 @@ This will start the interactive mode, which will guide you through:
    - Deleting environments (except protected ones)
    - Generating login links for environments
    - Clearing Drupal caches
+   - Deploying branches to environments
    - Viewing GitHub PR links for PR environments
 
 ## Features
@@ -58,6 +59,8 @@ This will start the interactive mode, which will guide you through:
 - GitHub PR integration for PR environments
 - One-click login link generation for Drupal environments
 - Quick Drupal cache clearing for any environment
+- Branch deployment with autocomplete selection
+- SSH key configuration for Lagoon authentication
 - Comprehensive logging of all operations
 - Extensible architecture for adding new commands
 
@@ -92,6 +95,17 @@ The CLI can clear Drupal caches on any environment:
 - Executes the `drush cr` command on the selected environment
 - Shows the command output in the terminal
 
+## Branch Deployment
+
+The CLI can deploy any branch from a project's git repository:
+- Automatically fetches and lists all available branches with autocomplete search
+- Prioritizes main branches (main, master, develop) at the top of the list
+- Initiates deployment of the selected branch to the Lagoon environment
+- Provides real-time feedback about the deployment status
+- Validates branch names to prevent command injection
+
+Note: Branch deployment is asynchronous and may take several minutes to complete. You can check the status in the Lagoon UI.
+
 ## Logging
 
 All operations performed by the CLI are logged to daily log files in the `.logs` directory:

package.json

@@ -24,6 +24,7 @@
     "eslint-plugin-n": "^17.17.0",
     "globals": "^16.1.0",
     "inquirer": "^9.2.12",
+    "inquirer-autocomplete-prompt": "^3.0.1",
     "js-yaml": "^4.1.0",
     "ora": "^7.0.1"
   }

src/interactive.js

@@ -10,11 +10,21 @@ import {
   generateLoginLink,
   clearDrupalCache,
   gitUrlToGithubUrl,
-  extractPrNumber
+  extractPrNumber,
+  getGitBranches,
+  deployBranch
 } from './lagoon-api';
 import { logAction } from './logger';
 import { configureSshKey } from './lagoon-ssh-key-configurator';
 
+// Register the autocomplete prompt with inquirer
+try {
+  const autocompletePrompt = (await import('inquirer-autocomplete-prompt')).default;
+  inquirer.registerPrompt('autocomplete', autocompletePrompt);
+} catch (error) {
+  console.log(chalk.yellow('Autocomplete prompt not available, falling back to standard list selection.'));
+}
+
 export async function startInteractiveMode() {
   console.log(chalk.green('Welcome to the Lagoon CLI Wrapper!'));
   logAction('Application Start', 'N/A', 'Interactive mode started');
@@ -66,6 +76,9 @@ export async function startInteractiveMode() {
         case 'clearCache':
           await clearCacheFlow(currentInstance, currentProject, githubBaseUrl);
           break;
+        case 'deployBranch':
+          await deployBranchFlow(currentInstance, currentProject, currentProjectDetails);
+          break;
         case 'configureUserSshKey':
           await configureSshKey(currentInstance, currentProject);
           break;
@@ -167,6 +180,7 @@ async function showMainMenu(instance, project) {
         { name: 'Delete Environment', value: 'deleteEnvironment' },
         { name: 'Generate Login Link', value: 'generateLoginLink' },
         { name: 'Clear Drupal Cache', value: 'clearCache' },
+        { name: 'Deploy Branch', value: 'deployBranch' },
         { name: 'Change Project', value: 'changeProject' },
         { name: 'Change Instance', value: 'changeInstance' },
         { name: 'Configure User SSH Key', value: 'configureUserSshKey' },
@@ -440,3 +454,129 @@ async function clearCacheFlow(instance, project, githubBaseUrl) {
     }
   ]);
 }
+
+async function deployBranchFlow(instance, project, projectDetails) {
+  // Check if project has a git URL
+  if (!projectDetails || !projectDetails.giturl) {
+    console.log(chalk.yellow('\nThis project does not have a valid Git URL configured.'));
+    await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'continue',
+        message: 'Press Enter to continue...'
+      }
+    ]);
+    return;
+  }
+
+  console.log(chalk.blue(`\nFetching branches from ${chalk.bold(projectDetails.giturl)}...`));
+
+  const spinner = ora('Loading branches...').start();
+  try {
+    // Get branches from the git repository
+    const branches = await getGitBranches(projectDetails.giturl);
+    spinner.succeed(`Found ${branches.length} branches.`);
+
+    if (branches.length === 0) {
+      console.log(chalk.yellow('\nNo branches found in the git repository.'));
+      await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'continue',
+          message: 'Press Enter to continue...'
+        }
+      ]);
+      return;
+    }
+
+    // Sort the branches to put main/master/develop first, then the rest alphabetically
+    const sortedBranches = branches.sort((a, b) => {
+      const priority = ['main', 'master', 'develop'];
+      const aIndex = priority.indexOf(a);
+      const bIndex = priority.indexOf(b);
+
+      if (aIndex !== -1 && bIndex !== -1) {
+        return aIndex - bIndex;
+      } else if (aIndex !== -1) {
+        return -1;
+      } else if (bIndex !== -1) {
+        return 1;
+      } else {
+        return a.localeCompare(b);
+      }
+    });
+
+    // Allow user to select a branch using autocomplete
+    const { selectedBranch } = await inquirer.prompt([
+      {
+        type: 'autocomplete',
+        name: 'selectedBranch',
+        message: 'Select a branch to deploy:',
+        source: (answersSoFar, input = '') => {
+          return Promise.resolve(
+            sortedBranches.filter(branch => 
+              !input || branch.toLowerCase().includes(input.toLowerCase())
+            )
+          );
+        },
+        // Fallback to regular list if autocomplete is not available
+        when: (answers) => {
+          // If inquirer-autocomplete-prompt is not available, use regular list
+          if (!inquirer.prompt.prompts.autocomplete) {
+            return false;
+          }
+          return true;
+        }
+      },
+      {
+        type: 'list',
+        name: 'selectedBranch',
+        message: 'Select a branch to deploy:',
+        choices: sortedBranches,
+        when: (answers) => {
+          // Use this if autocomplete is not available
+          return !inquirer.prompt.prompts.autocomplete;
+        }
+      }
+    ]);
+
+    // Confirm deployment
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: `Are you sure you want to deploy branch ${chalk.bold(selectedBranch)} to project ${chalk.bold(project)}?`,
+        default: false
+      }
+    ]);
+
+    if (!confirm) {
+      console.log(chalk.yellow('\nDeployment cancelled.'));
+      return;
+    }
+
+    // Deploy the branch
+    const spinner2 = ora(`Deploying branch ${selectedBranch}...`).start();
+    try {
+      const result = await deployBranch(instance, project, selectedBranch);
+      spinner2.succeed('Deployment initiated successfully.');
+
+      console.log(chalk.green('\nDeployment Status:'));
+      console.log(chalk.cyan(result.message || 'Branch deployment initiated.'));
+      console.log(chalk.blue('\nNote: The deployment process runs asynchronously and may take several minutes to complete.'));
+      console.log(chalk.blue('You can check the status of the deployment in the Lagoon UI.'));
+    } catch (error) {
+      spinner2.fail(`Failed to deploy branch: ${error.message}`);
+    }
+  } catch (error) {
+    spinner.fail(`Failed to fetch branches: ${error.message}`);
+  }
+
+  await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'continue',
+      message: 'Press Enter to continue...'
+    }
+  ]);
+}

src/lagoon-api.js

@@ -2,6 +2,9 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import chalk from 'chalk';
 import { logAction, logError } from './logger';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
 
 const execAsync = promisify(exec);
 
@@ -187,3 +190,103 @@ export async function clearDrupalCache(instance, project, environment) {
     throw new Error(`Failed to clear cache for environment ${environment}: ${error.message}`);
   }
 }
+
+// Helper function to create a temporary directory for git operations
+async function createTempDir() {
+  const tempDir = path.join(os.tmpdir(), `lagoon-cli-wrapper-${Date.now()}`);
+  await fs.mkdir(tempDir, { recursive: true });
+  return tempDir;
+}
+
+// Helper function to clone a git repository
+async function cloneRepository(gitUrl, directory) {
+  try {
+    const command = `git clone --bare ${gitUrl} ${directory}`;
+    await execAsync(command);
+    return true;
+  } catch (error) {
+    logError('Clone Repository', command, error);
+    throw new Error(`Failed to clone repository: ${error.message}`);
+  }
+}
+
+// Helper function to list branches in a git repository
+async function listBranches(directory) {
+  try {
+    const command = `cd ${directory} && git branch -r`;
+    const { stdout } = await execAsync(command);
+
+    // Parse the branches from the output
+    return stdout
+      .split('\n')
+      .map(branch => branch.trim())
+      .filter(branch => branch && !branch.includes('HEAD'))
+      .map(branch => branch.replace('origin/', ''));
+  } catch (error) {
+    logError('List Branches', command, error);
+    throw new Error(`Failed to list branches: ${error.message}`);
+  }
+}
+
+// Get all branches from a git repository
+export async function getGitBranches(gitUrl) {
+  try {
+    if (!gitUrl) {
+      throw new Error('Git URL not provided or invalid');
+    }
+
+    // Create a temporary directory
+    const tempDir = await createTempDir();
+
+    try {
+      // Clone the repository
+      await cloneRepository(gitUrl, tempDir);
+
+      // List branches
+      const branches = await listBranches(tempDir);
+
+      // Clean up temporary directory
+      await fs.rm(tempDir, { recursive: true, force: true });
+
+      return branches;
+    } catch (error) {
+      // Make sure to clean up even if an error occurs
+      try {
+        await fs.rm(tempDir, { recursive: true, force: true });
+      } catch (cleanupError) {
+        console.error(`Failed to clean up temporary directory: ${cleanupError.message}`);
+      }
+
+      throw error;
+    }
+  } catch (error) {
+    throw new Error(`Failed to get git branches: ${error.message}`);
+  }
+}
+
+// Deploy a branch to Lagoon
+export async function deployBranch(instance, project, branch) {
+  try {
+    // Validate branch name to prevent command injection
+    if (!/^[a-zA-Z0-9_.-]+$/.test(branch)) {
+      throw new Error('Invalid branch name. Branch names must contain only alphanumeric characters, underscores, hyphens, and periods.');
+    }
+
+    const command = `lagoon -l ${instance} -p ${project} deploy branch --branch ${branch} --output-json`;
+    const { stdout } = await execLagoonCommand(command, `Deploy Branch ${branch} to ${project}`);
+
+    // Parse the JSON response
+    const response = JSON.parse(stdout);
+
+    if (response.result === 'success') {
+      return {
+        success: true,
+        message: `Branch ${branch} is being deployed to ${project}`
+      };
+    } else {
+      throw new Error(`Failed to deploy branch ${branch}: ${JSON.stringify(response)}`);
+    }
+  } catch (error) {
+    throw new Error(`Failed to deploy branch ${branch}: ${error.message}`);
+  }
+}