vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/InstallationProgressReporter.js

@@ -0,0 +1,372 @@
+/**
+ * Installation Progress Reporter
+ * 
+ * Provides progress reporting for long-running installations.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Installation Progress Reporter class
+ */
+class InstallationProgressReporter {
+  /**
+   * Create progress reporter instance
+   * @param {Object} options - Reporter options
+   */
+  constructor(options = {}) {
+    this.logger = options.logger || null;
+    this.updateInterval = options.updateInterval || 2000; // 2 seconds
+    this.verbose = options.verbose || false;
+    this.progressCallbacks = options.progressCallbacks || [];
+    
+    // Progress tracking
+    this.activeOperations = new Map();
+    this.timers = new Map();
+    this.lastUpdate = new Map();
+  }
+
+  /**
+   * Start tracking installation progress
+   * @param {string} operationId - Unique operation identifier
+   * @param {Object} context - Operation context
+   * @returns {Object} - Progress tracker
+   */
+  startProgress(operationId, context = {}) {
+    const { agentId, installerType, totalSteps = 5, estimatedDuration = 300000 } = context;
+    
+    const progress = {
+      operationId,
+      agentId,
+      installerType,
+      startTime: Date.now(),
+      totalSteps,
+      currentStep: 0,
+      currentStepName: 'Initializing',
+      progressPercent: 0,
+      estimatedDuration,
+      elapsedMs: 0,
+      remainingMs: estimatedDuration,
+      status: 'RUNNING',
+      details: {},
+      logs: []
+    };
+
+    this.activeOperations.set(operationId, progress);
+    
+    // Start periodic updates
+    this.startPeriodicUpdate(operationId);
+    
+    // Log start
+    if (this.logger) {
+      this.logger.info(`Started installation: ${agentId}`, {
+        operationId,
+        agentId,
+        installerType,
+        estimatedDuration
+      });
+    }
+
+    // Notify callbacks
+    this.notifyProgress(operationId, progress);
+    
+    return {
+      updateStep: (stepName, details = {}) => this.updateStep(operationId, stepName, details),
+      setProgress: (percent, details = {}) => this.setProgress(operationId, percent, details),
+      complete: (result = {}) => this.completeProgress(operationId, result),
+      fail: (error) => this.failProgress(operationId, error),
+      getProgress: () => this.getProgress(operationId)
+    };
+  }
+
+  /**
+   * Update current step
+   * @param {string} operationId - Operation identifier
+   * @param {string} stepName - Name of current step
+   * @param {Object} details - Step details
+   */
+  updateStep(operationId, stepName, details = {}) {
+    const progress = this.activeOperations.get(operationId);
+    if (!progress) return;
+
+    progress.currentStep++;
+    progress.currentStepName = stepName;
+    progress.progressPercent = Math.round((progress.currentStep / progress.totalSteps) * 100);
+    progress.details = { ...progress.details, ...details };
+    progress.elapsedMs = Date.now() - progress.startTime;
+    
+    // Estimate remaining time
+    const avgStepTime = progress.elapsedMs / progress.currentStep;
+    const remainingSteps = progress.totalSteps - progress.currentStep;
+    progress.remainingMs = remainingSteps * avgStepTime;
+
+    // Add to log
+    progress.logs.push({
+      timestamp: new Date().toISOString(),
+      step: stepName,
+      details,
+      elapsedMs: progress.elapsedMs
+    });
+
+    this.notifyProgress(operationId, progress);
+    
+    if (this.verbose && this.logger) {
+      this.logger.info(`Progress: ${progress.agentId} - ${stepName}`, {
+        operationId,
+        step: progress.currentStep,
+        totalSteps: progress.totalSteps,
+        progressPercent: progress.progressPercent,
+        elapsedMs: progress.elapsedMs
+      });
+    }
+  }
+
+  /**
+   * Set progress percentage directly
+   * @param {string} operationId - Operation identifier
+   * @param {number} percent - Progress percentage (0-100)
+   * @param {Object} details - Progress details
+   */
+  setProgress(operationId, percent, details = {}) {
+    const progress = this.activeOperations.get(operationId);
+    if (!progress) return;
+
+    progress.progressPercent = Math.max(0, Math.min(100, percent));
+    progress.details = { ...progress.details, ...details };
+    progress.elapsedMs = Date.now() - progress.startTime;
+    
+    // Estimate remaining time
+    if (percent > 0) {
+      const totalTime = (progress.elapsedMs / percent) * 100;
+      progress.remainingMs = Math.max(0, totalTime - progress.elapsedMs);
+    }
+
+    this.notifyProgress(operationId, progress);
+  }
+
+  /**
+   * Complete progress tracking
+   * @param {string} operationId - Operation identifier
+   * @param {Object} result - Completion result
+   */
+  completeProgress(operationId, result = {}) {
+    const progress = this.activeOperations.get(operationId);
+    if (!progress) return;
+
+    progress.status = 'COMPLETED';
+    progress.progressPercent = 100;
+    progress.currentStepName = 'Completed';
+    progress.elapsedMs = Date.now() - progress.startTime;
+    progress.remainingMs = 0;
+    progress.result = result;
+
+    // Add completion log
+    progress.logs.push({
+      timestamp: new Date().toISOString(),
+      step: 'Completed',
+      details: result,
+      elapsedMs: progress.elapsedMs
+    });
+
+    // Stop periodic updates
+    this.stopPeriodicUpdate(operationId);
+
+    // Log completion
+    if (this.logger) {
+      this.logger.info(`Completed installation: ${progress.agentId}`, {
+        operationId,
+        agentId: progress.agentId,
+        duration: progress.elapsedMs,
+        result
+      });
+    }
+
+    this.notifyProgress(operationId, progress);
+    
+    // Remove from active operations after delay
+    setTimeout(() => {
+      this.activeOperations.delete(operationId);
+    }, 5000);
+  }
+
+  /**
+   * Mark progress as failed
+   * @param {string} operationId - Operation identifier
+   * @param {Error} error - Error that caused failure
+   */
+  failProgress(operationId, error) {
+    const progress = this.activeOperations.get(operationId);
+    if (!progress) return;
+
+    progress.status = 'FAILED';
+    progress.currentStepName = 'Failed';
+    progress.elapsedMs = Date.now() - progress.startTime;
+    progress.error = error.message;
+
+    // Add failure log
+    progress.logs.push({
+      timestamp: new Date().toISOString(),
+      step: 'Failed',
+      details: { error: error.message },
+      elapsedMs: progress.elapsedMs
+    });
+
+    // Stop periodic updates
+    this.stopPeriodicUpdate(operationId);
+
+    // Log failure
+    if (this.logger) {
+      this.logger.error(`Failed installation: ${progress.agentId}`, {
+        operationId,
+        agentId: progress.agentId,
+        error: error.message,
+        elapsedMs: progress.elapsedMs
+      });
+    }
+
+    this.notifyProgress(operationId, progress);
+    
+    // Remove from active operations after delay
+    setTimeout(() => {
+      this.activeOperations.delete(operationId);
+    }, 5000);
+  }
+
+  /**
+   * Get current progress
+   * @param {string} operationId - Operation identifier
+   * @returns {Object|null} - Current progress or null
+   */
+  getProgress(operationId) {
+    return this.activeOperations.get(operationId) || null;
+  }
+
+  /**
+   * Get all active operations
+   * @returns {Array} - Array of active operations
+   */
+  getActiveOperations() {
+    return Array.from(this.activeOperations.values());
+  }
+
+  /**
+   * Add progress callback
+   * @param {Function} callback - Progress callback function
+   */
+  addProgressCallback(callback) {
+    this.progressCallbacks.push(callback);
+  }
+
+  /**
+   * Remove progress callback
+   * @param {Function} callback - Progress callback function to remove
+   */
+  removeProgressCallback(callback) {
+    const index = this.progressCallbacks.indexOf(callback);
+    if (index > -1) {
+      this.progressCallbacks.splice(index, 1);
+    }
+  }
+
+  /**
+   * Notify all progress callbacks
+   * @param {string} operationId - Operation identifier
+   * @param {Object} progress - Progress data
+   */
+  notifyProgress(operationId, progress) {
+    const progressData = {
+      ...progress,
+      formattedTime: this.formatDuration(progress.elapsedMs),
+      formattedRemaining: this.formatDuration(progress.remainingMs),
+      progressBar: this.generateProgressBar(progress.progressPercent)
+    };
+
+    this.progressCallbacks.forEach(callback => {
+      try {
+        callback(operationId, progressData);
+      } catch (error) {
+        if (this.logger) {
+          this.logger.warn('Progress callback error', { error: error.message });
+        }
+      }
+    });
+  }
+
+  /**
+   * Start periodic updates
+   * @param {string} operationId - Operation identifier
+   */
+  startPeriodicUpdate(operationId) {
+    const timer = setInterval(() => {
+      const progress = this.activeOperations.get(operationId);
+      if (!progress) {
+        this.stopPeriodicUpdate(operationId);
+        return;
+      }
+
+      progress.elapsedMs = Date.now() - progress.startTime;
+      
+      // Update remaining time estimate
+      if (progress.progressPercent > 0) {
+        const totalTime = (progress.elapsedMs / progress.progressPercent) * 100;
+        progress.remainingMs = Math.max(0, totalTime - progress.elapsedMs);
+      }
+
+      this.notifyProgress(operationId, progress);
+    }, this.updateInterval);
+
+    this.timers.set(operationId, timer);
+  }
+
+  /**
+   * Stop periodic updates
+   * @param {string} operationId - Operation identifier
+   */
+  stopPeriodicUpdate(operationId) {
+    const timer = this.timers.get(operationId);
+    if (timer) {
+      clearInterval(timer);
+      this.timers.delete(operationId);
+    }
+  }
+
+  /**
+   * Format duration in human readable format
+   * @param {number} ms - Duration in milliseconds
+   * @returns {string} - Formatted duration
+   */
+  formatDuration(ms) {
+    if (ms < 1000) return `${ms}ms`;
+    if (ms < 60000) return `${Math.round(ms / 1000)}s`;
+    if (ms < 3600000) return `${Math.round(ms / 60000)}m ${Math.round((ms % 60000) / 1000)}s`;
+    return `${Math.round(ms / 3600000)}h ${Math.round((ms % 3600000) / 60000)}m`;
+  }
+
+  /**
+   * Generate progress bar
+   * @param {number} percent - Progress percentage
+   * @param {number} width - Progress bar width
+   * @returns {string} - Progress bar string
+   */
+  generateProgressBar(percent, width = 20) {
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    return `[${'='.repeat(filled)}${' '.repeat(empty)}] ${percent}%`;
+  }
+
+  /**
+   * Cleanup all active operations and timers
+   */
+  cleanup() {
+    // Clear all timers
+    for (const [operationId, timer] of this.timers) {
+      clearInterval(timer);
+    }
+    
+    // Clear collections
+    this.timers.clear();
+    this.activeOperations.clear();
+    this.lastUpdate.clear();
+  }
+}
+
+module.exports = InstallationProgressReporter;

package/src/agents/InstallationRetryManager.js

@@ -0,0 +1,322 @@
+/**
+ * Installation Retry Manager
+ * 
+ * Handles retry logic for transient network failures during installation.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Installation Retry Manager class
+ */
+class InstallationRetryManager {
+  /**
+   * Create retry manager instance
+   * @param {Object} options - Retry options
+   */
+  constructor(options = {}) {
+    this.logger = options.logger || null;
+    this.maxRetries = options.maxRetries || 3;
+    this.baseDelay = options.baseDelay || 1000; // 1 second
+    this.maxDelay = options.maxDelay || 30000; // 30 seconds
+    this.backoffMultiplier = options.backoffMultiplier || 2;
+    this.jitter = options.jitter || true;
+    
+    // Network error patterns
+    this.networkErrorPatterns = [
+      /network/i,
+      /connection/i,
+      /timeout/i,
+      /unreachable/i,
+      /dns/i,
+      /proxy/i,
+      /firewall/i,
+      /etimedout/i,
+      /enotfound/i,
+      /econnrefused/i,
+      /econnreset/i,
+      /socket/i,
+      /host not found/i,
+      /connection refused/i,
+      /no internet/i,
+      /offline/i
+    ];
+    
+    // Transient HTTP status codes
+    this.transientStatusCodes = [
+      408, // Request Timeout
+      429, // Too Many Requests
+      500, // Internal Server Error
+      502, // Bad Gateway
+      503, // Service Unavailable
+      504, // Gateway Timeout
+      507, // Insufficient Storage
+      509, // Bandwidth Limit Exceeded
+      520, // Unknown Error
+      521, // Web Server Is Down
+      522, // Connection Timed Out
+      523, // Origin Is Unreachable
+      524  // A Timeout Occurred
+    ];
+  }
+
+  /**
+   * Execute operation with retry logic
+   * @param {Function} operation - Operation to execute
+   * @param {Object} context - Operation context
+   * @returns {Promise<Object>} - Operation result
+   */
+  async executeWithRetry(operation, context = {}) {
+    const { operationId, agentId, operationType = 'INSTALLATION' } = context;
+    let lastError = null;
+    let attempt = 0;
+    
+    if (this.logger) {
+      this.logger.info(`Starting operation with retry logic`, {
+        operationId,
+        agentId,
+        operationType,
+        maxRetries: this.maxRetries
+      });
+    }
+
+    while (attempt <= this.maxRetries) {
+      attempt++;
+      
+      try {
+        if (this.logger) {
+          this.logger.info(`Executing operation attempt ${attempt}`, {
+            operationId,
+            agentId,
+            attempt,
+            maxRetries: this.maxRetries + 1
+          });
+        }
+
+        const result = await operation();
+        
+        // Success - log and return
+        if (this.logger) {
+          this.logger.info(`Operation succeeded on attempt ${attempt}`, {
+            operationId,
+            agentId,
+            attempt,
+            duration: result.duration
+          });
+        }
+
+        return {
+          success: true,
+          result,
+          attempts: attempt,
+          operationId,
+          agentId
+        };
+
+      } catch (error) {
+        lastError = error;
+        
+        // Check if error is retryable
+        const isRetryable = this.isRetryableError(error);
+        
+        if (this.logger) {
+          this.logger.warn(`Operation attempt ${attempt} failed`, {
+            operationId,
+            agentId,
+            attempt,
+            error: error.message,
+            isRetryable,
+            remainingRetries: this.maxRetries - attempt + 1
+          });
+        }
+
+        // If not retryable or no more attempts, throw error
+        if (!isRetryable || attempt > this.maxRetries) {
+          const failureMessage = !isRetryable ? 
+            `Non-retryable error: ${error.message}` :
+            `Operation failed after ${attempt} attempts: ${error.message}`;
+            
+          if (this.logger) {
+            this.logger.error(`Operation failed permanently`, {
+              operationId,
+              agentId,
+              attempts: attempt,
+              finalError: error.message,
+              isRetryable
+            });
+          }
+
+          throw new Error(failureMessage);
+        }
+
+        // Calculate delay for next attempt
+        const delay = this.calculateDelay(attempt);
+        
+        if (this.logger) {
+          this.logger.info(`Waiting ${delay}ms before retry`, {
+            operationId,
+            agentId,
+            attempt,
+            delay,
+            nextAttempt: attempt + 1
+          });
+        }
+
+        // Wait before retry
+        await this.sleep(delay);
+      }
+    }
+
+    // Should not reach here, but just in case
+    throw lastError || new Error('Operation failed after all retry attempts');
+  }
+
+  /**
+   * Check if error is retryable
+   * @param {Error} error - Error to check
+   * @returns {boolean} - Whether error is retryable
+   */
+  isRetryableError(error) {
+    const errorMessage = error.message.toLowerCase();
+    
+    // Check network error patterns
+    const isNetworkError = this.networkErrorPatterns.some(pattern => 
+      pattern.test(errorMessage)
+    );
+    
+    if (isNetworkError) {
+      return true;
+    }
+
+    // Check HTTP status codes
+    const statusCodeMatch = errorMessage.match(/status code:? (\d{3})/i);
+    if (statusCodeMatch) {
+      const statusCode = parseInt(statusCodeMatch[1]);
+      return this.transientStatusCodes.includes(statusCode);
+    }
+
+    // Check for specific retryable error messages
+    const retryablePatterns = [
+      /rate limit/i,
+      /too many requests/i,
+      /temporarily unavailable/i,
+      /service unavailable/i,
+      /try again later/i,
+      /quota exceeded/i,
+      /bandwidth limit/i,
+      /connection pool/i,
+      /max connections/i
+    ];
+
+    return retryablePatterns.some(pattern => pattern.test(errorMessage));
+  }
+
+  /**
+   * Calculate delay before next retry
+   * @param {number} attempt - Current attempt number (1-based)
+   * @returns {number} - Delay in milliseconds
+   */
+  calculateDelay(attempt) {
+    // Exponential backoff: delay = baseDelay * (multiplier ^ (attempt - 1))
+    let delay = this.baseDelay * Math.pow(this.backoffMultiplier, attempt - 1);
+    
+    // Cap at maximum delay
+    delay = Math.min(delay, this.maxDelay);
+    
+    // Add jitter to prevent thundering herd
+    if (this.jitter) {
+      const jitterRange = delay * 0.1; // 10% jitter
+      delay = delay + (Math.random() - 0.5) * jitterRange;
+    }
+    
+    // Ensure minimum delay
+    delay = Math.max(delay, 100);
+    
+    return Math.round(delay);
+  }
+
+  /**
+   * Sleep for specified milliseconds
+   * @param {number} ms - Milliseconds to sleep
+   * @returns {Promise<void>} - Sleep promise
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Create retry context for operation
+   * @param {Object} context - Base context
+   * @returns {Object} - Retry context
+   */
+  createRetryContext(context = {}) {
+    return {
+      operationId: context.operationId || `retry-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      agentId: context.agentId,
+      operationType: context.operationType || 'INSTALLATION',
+      startTime: Date.now(),
+      ...context
+    };
+  }
+
+  /**
+   * Get retry statistics
+   * @param {Array} attempts - Array of attempt results
+   * @returns {Object} - Retry statistics
+   */
+  getRetryStatistics(attempts) {
+    const successful = attempts.filter(a => a.success).length;
+    const failed = attempts.length - successful;
+    const totalDuration = attempts.reduce((sum, a) => sum + (a.duration || 0), 0);
+    const averageDuration = attempts.length > 0 ? totalDuration / attempts.length : 0;
+    
+    return {
+      totalAttempts: attempts.length,
+      successful,
+      failed,
+      successRate: attempts.length > 0 ? (successful / attempts.length) * 100 : 0,
+      totalDuration,
+      averageDuration,
+      maxRetriesReached: failed > 0 && attempts[attempts.length - 1].attempts > this.maxRetries
+    };
+  }
+
+  /**
+   * Configure retry settings
+   * @param {Object} config - New configuration
+   */
+  configure(config = {}) {
+    if (config.maxRetries !== undefined) this.maxRetries = config.maxRetries;
+    if (config.baseDelay !== undefined) this.baseDelay = config.baseDelay;
+    if (config.maxDelay !== undefined) this.maxDelay = config.maxDelay;
+    if (config.backoffMultiplier !== undefined) this.backoffMultiplier = config.backoffMultiplier;
+    if (config.jitter !== undefined) this.jitter = config.jitter;
+    
+    if (this.logger) {
+      this.logger.info('Retry configuration updated', {
+        maxRetries: this.maxRetries,
+        baseDelay: this.baseDelay,
+        maxDelay: this.maxDelay,
+        backoffMultiplier: this.backoffMultiplier,
+        jitter: this.jitter
+      });
+    }
+  }
+
+  /**
+   * Get current configuration
+   * @returns {Object} - Current configuration
+   */
+  getConfiguration() {
+    return {
+      maxRetries: this.maxRetries,
+      baseDelay: this.baseDelay,
+      maxDelay: this.maxDelay,
+      backoffMultiplier: this.backoffMultiplier,
+      jitter: this.jitter,
+      networkErrorPatterns: this.networkErrorPatterns.length,
+      transientStatusCodes: this.transientStatusCodes.length
+    };
+  }
+}
+
+module.exports = InstallationRetryManager;