devicely 2.2.13 → 2.2.14

package/lib/.logging-backup/universalSessionManager.js.backup

@@ -1,370 +0,0 @@
-/**
- * 🚀 UNIVERSAL SESSION MANAGER - REVOLUTIONARY APPROACH
- * ====================================================
- * 
- * CORE PRINCIPLE: NEVER STORE SESSIONS, ALWAYS GET LIVE SESSIONS FROM WDA
- * 
- * This eliminates ALL session conflicts, file corruption, and timing issues.
- * Always returns the ACTUAL active session from the running WDA process.
- */
-
-const axios = require('axios');
-const Logger = require('./logger');
-
-class UniversalSessionManager {
-  constructor() {
-    this.logger = new Logger('UniversalSessionManager');
-    
-    // Device port mapping (the ONLY thing we store)
-    this.devicePorts = new Map(); // Map<deviceName, port>
-    
-    // Reference to connected devices (for sync with global session manager)
-    this.connectedDevices = null;
-    
-    this.logger.info('🚀 Universal Session Manager initialized - LIVE SESSION MODE');
-  }
-
-  /**
-   * 🎯 SET CONNECTED DEVICES REFERENCE: For port mapping sync
-   */
-  setConnectedDevices(connectedDevices) {
-    this.connectedDevices = connectedDevices;
-    this.logger.debug(`📝 Connected devices reference set (${connectedDevices ? connectedDevices.length : 0} devices)`);
-  }
-
-  /**
-   * 🎯 CORE METHOD: Get Live Active Session ID
-   * Always fetches from running WDA/UIAutomator2 process, never from storage
-   */
-  async getLiveSessionId(deviceName, port = null) {
-    try {
-      // Get port from mapping or parameter
-      const devicePort = port || this.devicePorts.get(deviceName) || this.guessPortFromName(deviceName);
-      
-      if (!devicePort) {
-        throw new Error(`No port mapping found for device: ${deviceName}`);
-      }
-
-      this.logger.debug(`🔍 Getting live session for ${deviceName}:${devicePort}...`);
-
-      // Determine if this is Android UIAutomator2 (port >= 8200) or iOS WDA (port < 8200)
-      const isUIAutomator2 = devicePort >= 8200;
-
-      if (isUIAutomator2) {
-        // Method 1A: Try UIAutomator2 /wd/hub/sessions endpoint
-        try {
-          const sessionsResponse = await axios.get(`http://localhost:${devicePort}/wd/hub/sessions`, {
-            timeout: 2000 // Reduced from 3000ms to 2000ms for faster response
-          });
-          
-          if (sessionsResponse.data?.value && Array.isArray(sessionsResponse.data.value)) {
-            const activeSessions = sessionsResponse.data.value;
-            
-            if (activeSessions.length > 0) {
-              const sessionId = activeSessions[0].id || activeSessions[0].sessionId;
-              this.logger.debug(`✅ Live UIAutomator2 session found via /wd/hub/sessions: ${sessionId.substring(0, 8)}... for ${deviceName}:${devicePort}`);
-              return {
-                sessionId,
-                port: devicePort,
-                platform: 'android'
-              };
-            }
-          }
-        } catch (sessionsError) {
-          this.logger.debug(`UIAutomator2 /wd/hub/sessions endpoint failed for ${deviceName}:${devicePort}: ${sessionsError.message}`);
-        }
-
-        // Method 2A: Try UIAutomator2 status endpoint
-        try {
-          const statusResponse = await axios.get(`http://localhost:${devicePort}/wd/hub/status`, {
-            timeout: 2000 // Reduced timeout
-          });
-          
-          if (statusResponse.status === 200) {
-            // UIAutomator2 is running, but we need to get session from sessions endpoint
-            this.logger.debug(`UIAutomator2 server is running on ${devicePort}, but no active sessions found`);
-          }
-        } catch (statusError) {
-          this.logger.debug(`UIAutomator2 /wd/hub/status endpoint failed for ${deviceName}:${devicePort}: ${statusError.message}`);
-        }
-      } else {
-        // Method 1B: Try iOS WDA /sessions endpoint (most reliable)
-        try {
-          const sessionsResponse = await axios.get(`http://localhost:${devicePort}/sessions`, {
-            timeout: 2000 // Reduced from 3000ms to 2000ms
-          });
-          
-          if (sessionsResponse.data?.value && Array.isArray(sessionsResponse.data.value)) {
-            const activeSessions = sessionsResponse.data.value;
-            
-            if (activeSessions.length > 0) {
-              const sessionId = activeSessions[0].id;
-              this.logger.debug(`✅ Live WDA session found via /sessions: ${sessionId.substring(0, 8)}... for ${deviceName}:${devicePort}`);
-              return sessionId;
-            }
-          }
-        } catch (sessionsError) {
-          this.logger.debug(`WDA /sessions endpoint failed for ${deviceName}:${devicePort}: ${sessionsError.message}`);
-        }
-
-        // Method 2B: Try iOS WDA status endpoint (alternative)
-        try {
-          const statusResponse = await axios.get(`http://localhost:${devicePort}/status`, {
-            timeout: 3000
-          });
-          
-          if (statusResponse.data?.sessionId) {
-            const sessionId = statusResponse.data.sessionId;
-            this.logger.debug(`✅ Live WDA session found via /status: ${sessionId.substring(0, 8)}... for ${deviceName}:${devicePort}`);
-            return sessionId;
-          }
-        } catch (statusError) {
-          this.logger.debug(`WDA /status endpoint failed for ${deviceName}:${devicePort}: ${statusError.message}`);
-        }
-      }
-
-      // Method 3: Check if WDA is actually running before attempting to create session
-      try {
-        // First, verify WDA is running on this port
-        const healthCheck = await axios.get(`http://localhost:${devicePort}/health`, { 
-          timeout: 2000,
-          validateStatus: () => true 
-        });
-        
-        if (healthCheck.status !== 200) {
-          this.logger.debug(`⚠️ WDA health check failed on port ${devicePort} - WDA may not be running`);
-          throw new Error(`WDA not responding on port ${devicePort}`);
-        }
-        
-        this.logger.info(`🔄 No active session found, creating new session for ${deviceName}:${devicePort}...`);
-        
-        const createResponse = await axios.post(`http://localhost:${devicePort}/session`, {
-          capabilities: {
-            alwaysMatch: {},
-            firstMatch: [{}]
-          }
-        }, { timeout: 10000 });
-
-        if (createResponse.data?.sessionId) {
-          const sessionId = createResponse.data.sessionId;
-          this.logger.info(`✅ Created new session: ${sessionId.substring(0, 8)}... for ${deviceName}:${devicePort}`);
-          return sessionId;
-        }
-
-        // Handle alternative session response format
-        if (createResponse.data?.value?.sessionId) {
-          const sessionId = createResponse.data.value.sessionId;
-          this.logger.info(`✅ Created new session (alt format): ${sessionId.substring(0, 8)}... for ${deviceName}:${devicePort}`);
-          return sessionId;
-        }
-      } catch (createError) {
-        this.logger.warn(`Failed to create session for ${deviceName}:${devicePort}: ${createError.message}`);
-      }
-
-      throw new Error(`No active WDA session available for ${deviceName} on port ${devicePort}`);
-
-    } catch (error) {
-      this.logger.error(`❌ Failed to get live session for ${deviceName}: ${error.message}`);
-      throw error;
-    }
-  }
-
-  /**
-   * 🎯 VALIDATE SESSION: Check if session ID is still valid
-   */
-  async validateSession(sessionId, deviceName, port = null) {
-    try {
-      const devicePort = port || this.devicePorts.get(deviceName) || this.guessPortFromName(deviceName);
-      
-      // Try multiple validation methods - start with lightest
-      
-      // Method 1: Try status endpoint first (lighter)
-      try {
-        const statusResponse = await axios.get(`http://localhost:${devicePort}/status`, {
-          timeout: 1500
-        });
-        
-        if (statusResponse.data && statusResponse.status === 200) {
-          this.logger.debug(`✅ Session ${sessionId.substring(0, 8)}... validated via status for ${deviceName}`);
-          return true;
-        }
-      } catch (statusError) {
-        this.logger.debug(`Status validation failed for ${deviceName}: ${statusError.message}`);
-      }
-      
-      // Method 2: If status fails, try sessions endpoint
-      try {
-        const sessionsResponse = await axios.get(`http://localhost:${devicePort}/sessions`, {
-          timeout: 1500
-        });
-        
-        if (sessionsResponse.data?.value && Array.isArray(sessionsResponse.data.value)) {
-          const activeSessions = sessionsResponse.data.value;
-          const sessionExists = activeSessions.find(s => s.id === sessionId);
-          
-          if (sessionExists) {
-            this.logger.debug(`✅ Session ${sessionId.substring(0, 8)}... validated via sessions for ${deviceName}`);
-            return true;
-          }
-        }
-      } catch (sessionsError) {
-        this.logger.debug(`Sessions validation failed for ${deviceName}: ${sessionsError.message}`);
-      }
-      
-      // Method 3: Last resort - try source endpoint (heaviest)
-      try {
-        await axios.get(`http://localhost:${devicePort}/session/${sessionId}/source`, {
-          timeout: 2000
-        });
-        
-        this.logger.debug(`✅ Session ${sessionId.substring(0, 8)}... validated via source for ${deviceName}`);
-        return true;
-        
-      } catch (sourceError) {
-        this.logger.debug(`Source validation failed for ${deviceName}: ${sourceError.message}`);
-      }
-      
-      return false;
-      
-    } catch (error) {
-      this.logger.debug(`❌ Session ${sessionId?.substring(0, 8) || 'null'}... validation failed for ${deviceName}: ${error.message}`);
-      return false;
-    }
-  }
-
-  /**
-   * 🎯 REGISTER DEVICE PORT: Store port mapping and sync with universal manager
-   */
-  setDevicePort(deviceName, port) {
-    this.devicePorts.set(deviceName, port);
-    this.logger.debug(`📝 Port mapping registered: ${deviceName} → ${port}`);
-    
-    // Also register in global session manager if available
-    if (global.sessionManager) {
-      // Find device by name in connected devices to get UDID
-      let device = null;
-      
-      // Try multiple ways to find the device
-      if (global.connectedDevices) {
-        device = global.connectedDevices.find(d => d.name === deviceName);
-      }
-      
-      // Fallback: check if we have a connected devices reference in the session manager
-      if (!device && this.connectedDevices) {
-        device = this.connectedDevices.find(d => d.name === deviceName);
-      }
-      
-      if (device?.udid) {
-        try {
-          global.sessionManager.updateDevicePort(device.udid, port);
-          this.logger.debug(`📝 Synced port mapping to global session manager: ${deviceName} → ${port}`);
-        } catch (error) {
-          // Non-critical error
-          this.logger.debug(`⚠️ Could not sync to global session manager: ${error.message}`);
-        }
-      } else {
-        this.logger.debug(`⚠️ Could not find device ${deviceName} to sync port mapping`);
-      }
-    }
-  }
-
-  /**
-   * 🎯 REMOVE DEVICE: Clean up port mapping
-   */
-  removeDevice(deviceName) {
-    this.devicePorts.delete(deviceName);
-    this.logger.debug(`🧹 Port mapping removed for ${deviceName}`);
-  }
-
-  /**
-   * 🎯 SMART PORT GUESSING: Guess port based on device name patterns
-   */
-  guessPortFromName(deviceName) {
-    // Common port patterns based on device names
-    if (deviceName.toLowerCase().includes('ipad') && !deviceName.toLowerCase().includes('pro')) {
-      return 8101; // Regular iPads typically on 8101
-    }
-    
-    if (deviceName.toLowerCase().includes('iphone')) {
-      return 8100; // iPhones typically on 8100
-    }
-    
-    // Check if it's likely the second device
-    if (deviceName.toLowerCase().includes('pro') || deviceName.toLowerCase().includes('suresh')) {
-      return 8101; // Second devices typically on 8101
-    }
-    
-    // Default to 8100
-    return 8100;
-  }
-
-  /**
-   * 🎯 GET SESSION WITH AUTO-RETRY: Robust session getter with options
-   */
-  async getSessionWithRetry(deviceName, port = null, maxRetries = 2, skipValidation = false) {
-    let lastError;
-    
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      try {
-        const sessionId = await this.getLiveSessionId(deviceName, port);
-        
-        // Skip validation if requested (for more aggressive session usage)
-        if (skipValidation) {
-          this.logger.debug(`✅ Session acquired (validation skipped): ${sessionId.substring(0, 8)}... for ${deviceName}`);
-          return sessionId;
-        }
-        
-        // Validate the session works
-        const isValid = await this.validateSession(sessionId, deviceName, port);
-        
-        if (isValid) {
-          return sessionId;
-        } else {
-          throw new Error('Session validation failed');
-        }
-        
-      } catch (error) {
-        lastError = error;
-        
-        if (attempt < maxRetries) {
-          this.logger.warn(`⚠️ Session attempt ${attempt} failed for ${deviceName}, retrying... (${error.message})`);
-          
-          // Wait a bit before retry
-          await new Promise(resolve => setTimeout(resolve, 1000));
-        }
-      }
-    }
-    
-    throw new Error(`Failed to get valid session for ${deviceName} after ${maxRetries} attempts: ${lastError.message}`);
-  }
-
-  /**
-   * 🎯 GET ALL ACTIVE SESSIONS: For debugging/monitoring
-   */
-  async getAllActiveSessions() {
-    const activeSessions = {};
-    
-    for (const [deviceName, port] of this.devicePorts.entries()) {
-      try {
-        const sessionId = await this.getLiveSessionId(deviceName, port);
-        activeSessions[deviceName] = {
-          port,
-          sessionId,
-          status: 'active'
-        };
-      } catch (error) {
-        activeSessions[deviceName] = {
-          port,
-          sessionId: null,
-          status: 'inactive',
-          error: error.message
-        };
-      }
-    }
-    
-    return activeSessions;
-  }
-}
-
-// Export singleton instance
-module.exports = new UniversalSessionManager();