@dynamicu/chromedebug-mcp 2.2.0

package/src/services/git-safety-service.js

@@ -0,0 +1,675 @@
+/**
+ * Git Safety Service - Provides comprehensive Git safety operations for instrumentation
+ * Follows ChromeDebug MCP service patterns with robust error handling and rollback capabilities
+ * 
+ * Features:
+ * - Git status validation and working directory analysis
+ * - Atomic backup creation with Git stash or file copying
+ * - Branch protection to prevent modifications on protected branches  
+ * - Rollback capabilities for failed operations
+ * - Commit state analysis and validation
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, statSync, mkdirSync, copyFileSync, rmSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { glob } from 'glob';
+
+export class GitSafetyService {
+  constructor(options = {}) {
+    this.options = {
+      timeout: 30000, // 30 seconds for git operations
+      protectedBranches: ['main', 'master', 'production', 'develop'],
+      maxStashEntries: 10, // Limit stash entries to prevent bloat
+      backupRetentionDays: 7,
+      ...options
+    };
+    
+    // Service state tracking
+    this.activeBackups = new Map(); // operationId -> backup info
+    this.operationHistory = [];
+  }
+
+  /**
+   * Validates Git repository status and safety for operations
+   * @param {string} projectPath - Absolute path to project root
+   * @param {Object} options - Validation options
+   * @returns {Promise<Object>} Git validation result
+   */
+  async validateGitSafety(projectPath, options = {}) {
+    try {
+      const validationOptions = {
+        allowUncommittedChanges: false,
+        requireGitRepo: false,
+        protectedBranches: this.options.protectedBranches,
+        ...options
+      };
+
+      // Basic path validation
+      if (!existsSync(projectPath)) {
+        return {
+          valid: false,
+          error: 'Project path does not exist',
+          path: projectPath
+        };
+      }
+
+      // Check if it's a Git repository
+      const gitPath = join(projectPath, '.git');
+      const isGitRepo = existsSync(gitPath);
+      
+      if (!isGitRepo) {
+        if (validationOptions.requireGitRepo) {
+          return {
+            valid: false,
+            error: 'Git repository required but not found',
+            recommendation: 'Initialize git repository with: git init'
+          };
+        }
+        
+        return {
+          valid: true,
+          isGitRepo: false,
+          warning: 'Not a Git repository - manual backup recommended',
+          recommendation: 'Initialize git: git init && git add . && git commit -m "Initial commit"'
+        };
+      }
+
+      // Validate Git status
+      const gitStatus = await this._getGitStatus(projectPath);
+      if (!gitStatus.valid) {
+        return gitStatus;
+      }
+
+      // Check for uncommitted changes
+      if (gitStatus.hasUncommittedChanges && !validationOptions.allowUncommittedChanges) {
+        return {
+          valid: false,
+          error: 'Uncommitted changes detected',
+          details: 'Commit or stash changes before proceeding',
+          uncommittedFiles: gitStatus.uncommittedFiles,
+          recommendation: 'git add . && git commit -m "Pre-instrumentation commit"'
+        };
+      }
+
+      // Check protected branches
+      const branchCheck = await this._checkProtectedBranch(projectPath, validationOptions.protectedBranches);
+      if (!branchCheck.valid) {
+        return branchCheck;
+      }
+
+      // Check for merge conflicts
+      const conflictCheck = await this._checkMergeConflicts(projectPath);
+      if (!conflictCheck.valid) {
+        return conflictCheck;
+      }
+
+      return {
+        valid: true,
+        isGitRepo: true,
+        gitStatus,
+        branchInfo: branchCheck,
+        recommendation: gitStatus.hasUncommittedChanges ? 
+          'Consider committing changes before instrumentation' : 
+          'Git repository is ready for safe operations'
+      };
+
+    } catch (error) {
+      return {
+        valid: false,
+        error: 'Git safety validation failed',
+        details: error.message,
+        stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+      };
+    }
+  }
+
+  /**
+   * Creates a backup using Git stash or file copying
+   * @param {string} projectPath - Project root path
+   * @param {string} operationId - Unique operation identifier
+   * @param {string} strategy - Backup strategy ('git-stash', 'file-copy', 'none')
+   * @returns {Promise<Object>} Backup result
+   */
+  async createBackup(projectPath, operationId, strategy = 'git-stash') {
+    try {
+      if (strategy === 'none') {
+        return {
+          success: true,
+          strategy: 'none',
+          message: 'No backup created as requested'
+        };
+      }
+
+      const backupInfo = {
+        operationId,
+        projectPath: resolve(projectPath),
+        strategy,
+        timestamp: new Date().toISOString(),
+        created: false
+      };
+
+      if (strategy === 'git-stash') {
+        const gitBackup = await this._createGitStashBackup(projectPath, operationId);
+        if (gitBackup.success) {
+          backupInfo.stashRef = gitBackup.stashRef;
+          backupInfo.stashMessage = gitBackup.message;
+          backupInfo.created = true;
+        } else {
+          // Fallback to file copy if git stash fails
+          console.warn('Git stash failed, falling back to file copy:', gitBackup.error);
+          const fileBackup = await this._createFileCopyBackup(projectPath, operationId);
+          backupInfo.strategy = 'file-copy';
+          backupInfo.backupPath = fileBackup.backupPath;
+          backupInfo.created = fileBackup.success;
+        }
+      } else if (strategy === 'file-copy') {
+        const fileBackup = await this._createFileCopyBackup(projectPath, operationId);
+        backupInfo.backupPath = fileBackup.backupPath;
+        backupInfo.created = fileBackup.success;
+      } else {
+        throw new Error(`Unknown backup strategy: ${strategy}`);
+      }
+
+      if (backupInfo.created) {
+        this.activeBackups.set(operationId, backupInfo);
+        this.operationHistory.push({
+          operationId,
+          action: 'backup_created',
+          timestamp: new Date().toISOString(),
+          strategy
+        });
+      }
+
+      return {
+        success: backupInfo.created,
+        operationId,
+        strategy: backupInfo.strategy,
+        backupInfo: backupInfo.created ? backupInfo : null,
+        message: backupInfo.created ? 
+          `Backup created successfully using ${backupInfo.strategy}` :
+          'Backup creation failed'
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Backup creation failed',
+        details: error.message,
+        operationId
+      };
+    }
+  }
+
+  /**
+   * Restores from backup (rollback operation)
+   * @param {string} operationId - Operation to rollback
+   * @returns {Promise<Object>} Rollback result
+   */
+  async rollbackOperation(operationId) {
+    try {
+      const backupInfo = this.activeBackups.get(operationId);
+      if (!backupInfo) {
+        return {
+          success: false,
+          error: 'No backup found for operation',
+          operationId
+        };
+      }
+
+      let rollbackResult;
+      
+      if (backupInfo.strategy === 'git-stash' && backupInfo.stashRef) {
+        rollbackResult = await this._rollbackFromGitStash(backupInfo);
+      } else if (backupInfo.strategy === 'file-copy' && backupInfo.backupPath) {
+        rollbackResult = await this._rollbackFromFileCopy(backupInfo);
+      } else {
+        throw new Error(`Cannot rollback: invalid backup strategy or missing backup data`);
+      }
+
+      if (rollbackResult.success) {
+        this.operationHistory.push({
+          operationId,
+          action: 'rollback_completed',
+          timestamp: new Date().toISOString(),
+          strategy: backupInfo.strategy
+        });
+      }
+
+      return rollbackResult;
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Rollback operation failed',
+        details: error.message,
+        operationId
+      };
+    }
+  }
+
+  /**
+   * Cleans up backup resources for completed operations
+   * @param {string} operationId - Operation to clean up
+   * @returns {Promise<Object>} Cleanup result
+   */
+  async cleanupBackup(operationId) {
+    try {
+      const backupInfo = this.activeBackups.get(operationId);
+      if (!backupInfo) {
+        return {
+          success: true,
+          message: 'No backup to clean up'
+        };
+      }
+
+      let cleanupResult = { success: false };
+
+      if (backupInfo.strategy === 'git-stash' && backupInfo.stashRef) {
+        cleanupResult = await this._cleanupGitStash(backupInfo);
+      } else if (backupInfo.strategy === 'file-copy' && backupInfo.backupPath) {
+        cleanupResult = await this._cleanupFileCopy(backupInfo);
+      }
+
+      if (cleanupResult.success) {
+        this.activeBackups.delete(operationId);
+        this.operationHistory.push({
+          operationId,
+          action: 'backup_cleaned',
+          timestamp: new Date().toISOString(),
+          strategy: backupInfo.strategy
+        });
+      }
+
+      return cleanupResult;
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Cleanup operation failed',
+        details: error.message,
+        operationId
+      };
+    }
+  }
+
+  // Private implementation methods
+
+  /**
+   * Gets comprehensive Git status information
+   * @private
+   */
+  async _getGitStatus(projectPath) {
+    try {
+      // Check git status with porcelain format for parsing
+      const statusOutput = execSync('git status --porcelain', {
+        cwd: projectPath,
+        encoding: 'utf8',
+        timeout: this.options.timeout
+      });
+
+      const uncommittedFiles = statusOutput.trim() ? 
+        statusOutput.trim().split('\n').map(line => line.substring(3)) : [];
+      
+      // Get current branch
+      const branchOutput = execSync('git rev-parse --abbrev-ref HEAD', {
+        cwd: projectPath,
+        encoding: 'utf8',
+        timeout: this.options.timeout
+      });
+      
+      const currentBranch = branchOutput.trim();
+
+      // Check if there are staged changes
+      const stagedOutput = execSync('git diff --cached --name-only', {
+        cwd: projectPath,
+        encoding: 'utf8',
+        timeout: this.options.timeout
+      });
+
+      const stagedFiles = stagedOutput.trim() ? stagedOutput.trim().split('\n') : [];
+
+      return {
+        valid: true,
+        hasUncommittedChanges: uncommittedFiles.length > 0,
+        uncommittedFiles,
+        hasStagedChanges: stagedFiles.length > 0,
+        stagedFiles,
+        currentBranch
+      };
+
+    } catch (error) {
+      return {
+        valid: false,
+        error: 'Failed to get git status',
+        details: error.message
+      };
+    }
+  }
+
+  /**
+   * Checks if current branch is protected
+   * @private
+   */
+  async _checkProtectedBranch(projectPath, protectedBranches) {
+    try {
+      const branchOutput = execSync('git rev-parse --abbrev-ref HEAD', {
+        cwd: projectPath,
+        encoding: 'utf8',
+        timeout: this.options.timeout
+      });
+      
+      const currentBranch = branchOutput.trim();
+      const isProtected = protectedBranches.includes(currentBranch);
+
+      if (isProtected) {
+        return {
+          valid: false,
+          error: 'Protected branch detected',
+          currentBranch,
+          protectedBranches,
+          recommendation: `Switch to a feature branch: git checkout -b instrumentation-${Date.now()}`
+        };
+      }
+
+      return {
+        valid: true,
+        currentBranch,
+        isProtected: false
+      };
+
+    } catch (error) {
+      return {
+        valid: false,
+        error: 'Failed to check branch protection',
+        details: error.message
+      };
+    }
+  }
+
+  /**
+   * Checks for merge conflicts
+   * @private
+   */
+  async _checkMergeConflicts(projectPath) {
+    try {
+      // Check for merge conflict markers in staged files
+      const conflictCheck = execSync('git ls-files -u', {
+        cwd: projectPath,
+        encoding: 'utf8',
+        timeout: this.options.timeout
+      });
+
+      const hasConflicts = conflictCheck.trim().length > 0;
+
+      if (hasConflicts) {
+        return {
+          valid: false,
+          error: 'Merge conflicts detected',
+          recommendation: 'Resolve conflicts before proceeding: git status'
+        };
+      }
+
+      return { valid: true, hasConflicts: false };
+
+    } catch (error) {
+      return {
+        valid: false,
+        error: 'Failed to check merge conflicts',
+        details: error.message
+      };
+    }
+  }
+
+  /**
+   * Creates a Git stash backup
+   * @private
+   */
+  async _createGitStashBackup(projectPath, operationId) {
+    try {
+      const stashMessage = `ChromeDebug MCP instrumentation backup - ${operationId} - ${new Date().toISOString()}`;
+      
+      // Create stash including untracked files
+      execSync(`git stash push -u -m "${stashMessage}"`, {
+        cwd: projectPath,
+        encoding: 'utf8',
+        timeout: this.options.timeout
+      });
+
+      // Get the stash reference
+      const stashList = execSync('git stash list --oneline', {
+        cwd: projectPath,
+        encoding: 'utf8',
+        timeout: this.options.timeout
+      });
+
+      const stashLines = stashList.trim().split('\n');
+      const latestStash = stashLines[0];
+      const stashRef = latestStash ? latestStash.split(':')[0] : 'stash@{0}';
+
+      return {
+        success: true,
+        stashRef,
+        message: stashMessage,
+        operationId
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Git stash creation failed',
+        details: error.message
+      };
+    }
+  }
+
+  /**
+   * Creates a file copy backup
+   * @private
+   */
+  async _createFileCopyBackup(projectPath, operationId) {
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupPath = `${projectPath}-backup-${operationId}-${timestamp}`;
+      
+      // Create backup directory
+      mkdirSync(backupPath, { recursive: true });
+
+      // Copy files (excluding node_modules, .git, etc.)
+      const patterns = ['**/*'];
+      const exclusions = [
+        'node_modules/**',
+        '.git/**',
+        'dist/**',
+        'build/**',
+        '**/*.log',
+        '**/.*cache*/**'
+      ];
+
+      const files = await glob(patterns, {
+        cwd: projectPath,
+        absolute: true,
+        ignore: exclusions,
+        nodir: true
+      });
+
+      for (const file of files) {
+        try {
+          const relativePath = file.replace(projectPath, '');
+          const destPath = join(backupPath, relativePath);
+          const destDir = dirname(destPath);
+          
+          mkdirSync(destDir, { recursive: true });
+          copyFileSync(file, destPath);
+        } catch (copyError) {
+          console.warn(`Failed to copy file ${file}:`, copyError.message);
+        }
+      }
+
+      return {
+        success: true,
+        backupPath,
+        filesCopied: files.length,
+        operationId
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'File copy backup failed',
+        details: error.message
+      };
+    }
+  }
+
+  /**
+   * Rollback from Git stash
+   * @private
+   */
+  async _rollbackFromGitStash(backupInfo) {
+    try {
+      // Reset working directory to clean state
+      execSync('git reset --hard HEAD', {
+        cwd: backupInfo.projectPath,
+        timeout: this.options.timeout
+      });
+
+      // Apply the stash
+      execSync(`git stash apply ${backupInfo.stashRef}`, {
+        cwd: backupInfo.projectPath,
+        timeout: this.options.timeout
+      });
+
+      return {
+        success: true,
+        message: 'Successfully rolled back from Git stash',
+        stashRef: backupInfo.stashRef
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Git stash rollback failed',
+        details: error.message
+      };
+    }
+  }
+
+  /**
+   * Rollback from file copy
+   * @private
+   */
+  async _rollbackFromFileCopy(backupInfo) {
+    try {
+      // Remove current files and restore from backup
+      const files = await glob('**/*', {
+        cwd: backupInfo.backupPath,
+        absolute: true,
+        nodir: true
+      });
+
+      for (const file of files) {
+        const relativePath = file.replace(backupInfo.backupPath, '');
+        const destPath = join(backupInfo.projectPath, relativePath);
+        const destDir = dirname(destPath);
+        
+        mkdirSync(destDir, { recursive: true });
+        copyFileSync(file, destPath);
+      }
+
+      return {
+        success: true,
+        message: 'Successfully rolled back from file copy',
+        filesRestored: files.length
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'File copy rollback failed',
+        details: error.message
+      };
+    }
+  }
+
+  /**
+   * Cleanup Git stash
+   * @private
+   */
+  async _cleanupGitStash(backupInfo) {
+    try {
+      execSync(`git stash drop ${backupInfo.stashRef}`, {
+        cwd: backupInfo.projectPath,
+        timeout: this.options.timeout
+      });
+
+      return {
+        success: true,
+        message: 'Git stash cleaned up successfully'
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Git stash cleanup failed',
+        details: error.message
+      };
+    }
+  }
+
+  /**
+   * Cleanup file copy backup
+   * @private
+   */
+  async _cleanupFileCopy(backupInfo) {
+    try {
+      if (existsSync(backupInfo.backupPath)) {
+        rmSync(backupInfo.backupPath, { recursive: true, force: true });
+      }
+
+      return {
+        success: true,
+        message: 'File copy backup cleaned up successfully'
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: 'File copy cleanup failed',
+        details: error.message
+      };
+    }
+  }
+
+  /**
+   * Gets service status and active operations
+   * @returns {Object} Service status
+   */
+  getServiceStatus() {
+    return {
+      activeBackups: this.activeBackups.size,
+      operationHistory: this.operationHistory.slice(-10), // Last 10 operations
+      options: this.options
+    };
+  }
+
+  /**
+   * Gets backup information for an operation
+   * @param {string} operationId - Operation ID
+   * @returns {Object|null} Backup information
+   */
+  getBackupInfo(operationId) {
+    return this.activeBackups.get(operationId) || null;
+  }
+
+  /**
+   * Cleanup service resources
+   * @returns {Promise<void>}
+   */
+  async cleanup() {
+    // Clean up any temporary resources
+    this.activeBackups.clear();
+    this.operationHistory = [];
+    console.log('GitSafetyService cleanup completed');
+  }
+}