devicely 2.2.12 → 2.2.13

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

@@ -0,0 +1,370 @@
+/**
+ * 🚀 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();