devicely 2.2.13 → 2.2.14

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

@@ -1,4427 +0,0 @@
-const Logger = require('./logger');
-const { spawn } = require('child_process');
-const LocatorStrategy = require('./locatorStrategy');
-const IntelligentLocatorService = require('./intelligentLocatorService'); // NEW: Import intelligent locator service
-const universalSessionManager = require('./universalSessionManager'); // REVOLUTIONARY: Universal session management
-const axios = require('axios'); // Add axios at module level
-
-class CommanderService {
-  constructor(wss, connectedDevices = []) {
-    this.wss = wss;
-    this.connectedDevices = connectedDevices; // Reference to global connected devices
-    this.commanderDevice = null;
-    this.followerDevices = new Set();
-    this.isActive = false;
-    this.captureProcess = null;
-    this.logger = new Logger('CommanderService');
-    this.eventQueue = [];
-    this.sessionId = null;
-    this.locatorStrategy = new LocatorStrategy();
-    
-    // GENIUS: Click Queue System for handling rapid clicks
-    this.clickQueue = [];
-    this.processingClick = false;
-    this.maxQueueSize = 3; // Limit queue to prevent overflow
-    
-    // REVOLUTIONARY: Universal Session Management
-    this.sessionManager = universalSessionManager;
-    
-    // 🎯 NEW: Initialize Intelligent Locator Service
-    this.intelligentLocator = new IntelligentLocatorService(connectedDevices);
-    
-    // GENIUS: Inject universal session management into intelligent locator service
-    this.intelligentLocator.getValidWDASession = this.getValidWDASession.bind(this);
-    
-    this.logger.info('🎯 Intelligent Locator Service initialized with Universal Session Management');
-    
-    // Make intelligentLocatorService globally accessible for disconnect cleanup
-    global.intelligentLocatorService = this.intelligentLocator;
-    
-    // GENIUS: Use global session manager instead of local wdaSessionId
-    this.cachedElements = []; // Cache all screen elements
-    this.lastCacheTime = 0; // Track when cache was last updated
-    this.isCaching = false; // Prevent duplicate caching operations
-    this.lastWindowSize = { width: 375, height: 667 };
-    this.commanderDriver = null; // WebDriver-like interface
-    this.deviceSizeCache = new Map(); // Cache device screen sizes for coordinate scaling
-    
-    // Session operation locking to prevent concurrent access
-    this.sessionLocks = new Map(); // Map<deviceName, Promise>
-    
-    // 🎯 NEW: Intelligent Locator Settings
-    this.useIntelligentLocators = true; // Enable intelligent locator mode
-    this.locatorSuccessRate = new Map(); // Track success rate per device
-    this.coordinateFallbackCount = 0;
-    this.locatorSuccessCount = 0;
-  }
-
-  // GENIUS: Get WDA session ID from universal session manager
-  async getWDASessionId() {
-    if (!this.commanderDevice) return null;
-    
-    try {
-      // Use universal session manager to get live session
-      const sessionId = await this.sessionManager.getLiveSessionId(this.commanderDevice.name, this.commanderDevice.port);
-      return sessionId;
-    } catch (error) {
-      this.logger.warn(`⚠️ Could not get WDA session: ${error.message}`);
-      return null;
-    }
-  }
-
-  // Register a WDA session using universal session manager
-  registerSessionGlobally(device, sessionId, port) {
-    if (!device || !sessionId) return;
-    
-    const udid = device.udid || device.serial;
-    const platform = device.platform || 'ios';
-    const deviceName = device.name;
-    
-    // Register device port in universal session manager
-    this.sessionManager.setDevicePort(deviceName, port);
-    this.logger.debug(`📌 Registered port mapping in Universal Session Manager: ${deviceName} -> ${port}`);
-    
-    // Also store in connectedDevices for backward compatibility
-    const globalDevice = this.connectedDevices.find(d => 
-      d.name === deviceName || d.udid === udid
-    );
-    
-    if (globalDevice) {
-      if (platform === 'ios') {
-        globalDevice.wdaSessionId = sessionId;
-      } else {
-        globalDevice.sessionId = sessionId;
-      }
-      globalDevice.port = port;
-      this.logger.debug(`📌 Registered session in connectedDevices: ${deviceName}`);
-    }
-  }
-
-  // REVOLUTIONARY: Universal Session Management - Always Live WDA Lookup
-  async getValidWDASession(deviceName, port) {
-    try {
-      // Register the port mapping if provided
-      if (port) {
-        this.sessionManager.setDevicePort(deviceName, port);
-      }
-      
-      // Get live session with retry logic
-      const sessionId = await this.sessionManager.getSessionWithRetry(deviceName, port);
-      
-      this.logger.debug(`✅ Live session acquired: ${sessionId.substring(0, 8)}... for ${deviceName}`);
-      return sessionId;
-      
-    } catch (error) {
-      this.logger.error(`❌ Failed to get live session for ${deviceName}: ${error.message}`);
-      throw error;
-    }
-  }
-
-
-
-  async withSessionLock(deviceName, operation) {
-    const lockKey = `${deviceName}_wda_session`;
-    
-    // If there's already an operation in progress, wait for it
-    if (this.sessionLocks.has(lockKey)) {
-      this.logger.debug(`⏳ Waiting for existing session operation on ${deviceName}...`);
-      try {
-        await this.sessionLocks.get(lockKey);
-      } catch (err) {
-        // Previous operation failed, continue with ours
-      }
-    }
-    
-    // Create new lock
-    const operationPromise = this.executeWithLock(operation, deviceName);
-    this.sessionLocks.set(lockKey, operationPromise);
-    
-    try {
-      const result = await operationPromise;
-      this.sessionLocks.delete(lockKey);
-      return result;
-    } catch (error) {
-      this.sessionLocks.delete(lockKey);
-      throw error;
-    }
-  }
-  
-  async executeWithLock(operation, deviceName) {
-    this.logger.debug(`🔒 Acquired session lock for ${deviceName}`);
-    try {
-      const result = await operation();
-      this.logger.debug(`🔓 Released session lock for ${deviceName}`);
-      return result;
-    } catch (error) {
-      this.logger.debug(`🔓 Released session lock for ${deviceName} (error: ${error.message})`);
-      throw error;
-    }
-  }
-
-  // Determine if an element is likely to be interactive vs layout/informational
-  isElementInteractive(elementType, rect, label) {
-    // Always include actual interactive elements
-    if (elementType.includes('Button') || elementType.includes('TextField') || 
-        elementType.includes('Switch') || elementType.includes('Link')) {
-      return true;
-    }
-    
-    // Filter out StaticText and Cells that are likely layout elements
-    if (elementType.includes('StaticText')) {
-      // Include if it's a reasonable clickable size and has meaningful label
-      if (rect.width > 40 && rect.height > 20 && label && 
-          !label.match(/^\d+$/) && // Not just numbers
-          !label.includes('Label') && // Not generic labels
-          label.length > 1) {
-        return true;
-      }
-      return false;
-    }
-    
-    if (elementType.includes('Cell')) {
-      // Only include cells that are reasonably sized (not massive containers)
-      if (rect.width < 600 && rect.height < 200 && rect.height > 30) {
-        return true;
-      }
-      return false;
-    }
-    
-    if (elementType.includes('Image')) {
-      // Only include images that might be clickable (reasonable size, has label)
-      if (rect.width < 200 && rect.height < 200 && rect.width > 20 && rect.height > 20 && label) {
-        return true;
-      }
-      return false;
-    }
-    
-    // Exclude Other elements (containers)
-    if (elementType.includes('Other')) {
-      return false;
-    }
-    
-    return false; // Default to exclude
-  }
-
-  // More permissive filtering for element caching (used for speed)
-  isElementRelevant(elementType, rect, label, enabled = true) {
-    // Always include truly interactive elements
-    if (elementType.includes('Button') || elementType.includes('TextField') || 
-        elementType.includes('Switch') || elementType.includes('Link')) {
-      return enabled;
-    }
-    
-    // Include StaticText if it could be clickable
-    if (elementType.includes('StaticText')) {
-      // More permissive - include if decent size
-      if (rect.width > 20 && rect.height > 15 && enabled) {
-        return true;
-      }
-      return false;
-    }
-    
-    // Include reasonable cells
-    if (elementType.includes('Cell')) {
-      if (rect.width < 500 && rect.height < 150 && rect.height > 20 && enabled) {
-        return true;
-      }
-      return false;
-    }
-    
-    // Include images that might be clickable
-    if (elementType.includes('Image')) {
-      if (rect.width < 150 && rect.height < 150 && rect.width > 15 && rect.height > 15 && enabled) {
-        return true;
-      }
-      return false;
-    }
-    
-    // Include Other elements if they're reasonable sized (might be custom controls)
-    if (elementType.includes('Other')) {
-      if (rect.width > 20 && rect.height > 20 && rect.width < 300 && rect.height < 100 && enabled) {
-        return true;
-      }
-      return false;
-    }
-    
-    return false;
-  }
-
-  // Create a simple driver interface for app control
-  async createDriverInterface() {
-    if (!this.commanderDevice) {
-      return null;
-    }
-
-    const device = this.commanderDevice;
-    
-    if (device.platform === 'ios') {
-      // iOS WebDriverAgent interface
-      const wdaSessionId = await this.getWDASessionId();
-      if (!wdaSessionId) return null;
-      
-      const port = device.port || 8100;
-      const sessionId = wdaSessionId;
-      const baseUrl = `http://localhost:${port}`;
-      
-      return {
-        execute: async (command, params = {}) => {
-          const axios = require('axios');
-          
-          try {
-            switch (command) {
-              case 'mobile: launchApp':
-                return await axios.post(`${baseUrl}/session/${sessionId}/wda/apps/launch`, {
-                  bundleId: params.bundleId
-                });
-                
-              case 'mobile: terminateApp':
-                return await axios.post(`${baseUrl}/session/${sessionId}/wda/apps/terminate`, {
-                  bundleId: params.bundleId
-                });
-                
-              case 'mobile: activateApp':
-                return await axios.post(`${baseUrl}/session/${sessionId}/wda/apps/activate`, {
-                  bundleId: params.bundleId
-                });
-                
-              default:
-                throw new Error(`Unsupported iOS command: ${command}`);
-            }
-          } catch (error) {
-            this.logger.error(`iOS driver command failed: ${error.message}`);
-            throw error;
-          }
-        },
-        
-        getWindowSize: async () => {
-          return this.lastWindowSize;
-        }
-      };
-    } 
-    else if (device.platform === 'android') {
-      // Android - use ADB commands via shell
-      return {
-        execute: async (command, params = {}) => {
-          const { spawn } = require('child_process');
-          
-          try {
-            switch (command) {
-              case 'mobile: launchApp':
-                return new Promise((resolve, reject) => {
-                  const adb = spawn('adb', ['-s', device.serial || device.udid, 'shell', 'am', 'start', '-n', `${params.bundleId}/.MainActivity`]);
-                  
-                  adb.on('close', (code) => {
-                    if (code === 0) {
-                      resolve({ success: true });
-                    } else {
-                      // Try alternative launch method
-                      const adb2 = spawn('adb', ['-s', device.serial || device.udid, 'shell', 'monkey', '-p', params.bundleId, '-c', 'android.intent.category.LAUNCHER', '1']);
-                      adb2.on('close', (code2) => {
-                        resolve({ success: code2 === 0 });
-                      });
-                      adb2.on('error', () => resolve({ success: false }));
-                    }
-                  });
-                  adb.on('error', (error) => reject(error));
-                });
-                
-              case 'mobile: terminateApp':
-                return new Promise((resolve, reject) => {
-                  const adb = spawn('adb', ['-s', device.serial || device.udid, 'shell', 'am', 'force-stop', params.bundleId]);
-                  
-                  adb.on('close', (code) => {
-                    resolve({ success: code === 0 });
-                  });
-                  adb.on('error', (error) => reject(error));
-                });
-                
-              case 'mobile: activateApp':
-                // Same as launch for Android
-                return this.execute('mobile: launchApp', params);
-                
-              default:
-                throw new Error(`Unsupported Android command: ${command}`);
-            }
-          } catch (error) {
-            this.logger.error(`Android driver command failed: ${error.message}`);
-            throw error;
-          }
-        },
-        
-        getWindowSize: async () => {
-          return this.lastWindowSize;
-        }
-      };
-    }
-    
-    return null;
-  }
-
-  /**
-   * Get UIAutomator2 session ID from universal session manager
-   * This ensures session ID is always in sync across all operations
-   */
-  async getAndroidSession(device) {
-    if (!device || device.platform !== 'android') return null;
-    
-    try {
-      // Use universal session manager to get live session for Android
-      const sessionId = await this.sessionManager.getLiveSessionId(device.name, device.port);
-      return sessionId;
-    } catch (error) {
-      this.logger.warn(`⚠️ Could not get Android session for ${device.name}: ${error.message}`);
-      
-      // Fallback: Try different possible keys for Android session lookup
-      const possibleKeys = [
-        device.udid,
-        device.serial,
-        device.name
-      ].filter(Boolean);
-      
-      for (const key of possibleKeys) {
-        const session = global.androidSessions?.get(key);
-        if (session && session.sessionId && session.port) {
-          // Cache session info on device object for faster access
-          device.sessionId = session.sessionId;
-          device.port = session.port;
-          return session;
-        }
-      }
-      
-      return null;
-    }
-  }
-
-  async setCommander(deviceName, deviceInfo) {
-    if (this.isActive && this.commanderDevice && this.commanderDevice.name === deviceName) {
-      // Same device - commander mode is already active, just return success
-      this.logger.info(`Commander mode already active on ${deviceName}`);
-      return {
-        success: true,
-        commanderDevice: this.commanderDevice,
-        sessionId: this.sessionId,
-        message: 'Commander mode already active'
-      };
-    }
-
-    if (this.isActive && this.commanderDevice && this.commanderDevice.name !== deviceName) {
-      // Different device - preserve sessions during commander switch
-      this.logger.info(`Switching commander from ${this.commanderDevice.name} to ${deviceName}`);
-      
-      // CRITICAL: Preserve WDA session of outgoing commander for potential follower role
-      const outgoingCommander = this.commanderDevice;
-      if (outgoingCommander) {
-        this.logger.info(`📝 Preserving WDA session for outgoing commander: ${outgoingCommander.name}`);
-        
-        // Add outgoing commander as follower to preserve its WDA session
-        const followerDevice = {
-          name: outgoingCommander.name,
-          udid: outgoingCommander.udid,
-          platform: outgoingCommander.platform,
-          port: outgoingCommander.port,
-          sessionId: this.sessionId, // Preserve the current session
-          wdaSessionId: this.sessionId,
-          wasCommander: true // Mark this as a former commander
-        };
-        
-        this.followerDevices.add(followerDevice);
-        this.logger.info(`📝 Former commander ${outgoingCommander.name} automatically added as follower to preserve WDA session`);
-        
-        // Only stop touch monitoring, keep WDA alive and preserve followers
-        this.stopTouchMonitoring();
-        this.commanderDevice = null;
-        this.sessionId = null;
-      }
-    }
-
-    this.commanderDevice = {
-      ...deviceInfo,
-      name: deviceName  // CRITICAL: Ensure deviceName overrides deviceInfo.name
-    };
-    this.isActive = true;
-    this.sessionId = `commander_${Date.now()}`;
-    
-    // CRITICAL: Track if this device was recently a follower
-    this.wasRecentlyFollower = deviceInfo.wasRecentlyFollower || false;
-    
-    // Debug device name handling
-    this.logger.info(`📱 Commander device set: "${deviceName}" (platform: ${deviceInfo.platform})`);
-    this.logger.info(`📊 Device info name: "${deviceInfo.name}", used name: "${this.commanderDevice.name}"`);
-    
-    if (this.wasRecentlyFollower) {
-      this.logger.info(`🔄 Device ${deviceName} was recently a follower - will reuse existing WDA session`);
-    }
-    
-    // CRITICAL: Ensure we use the passed deviceName, not deviceInfo.name
-    if (deviceInfo.name && deviceInfo.name !== deviceName) {
-      this.logger.warn(`⚠️ Name mismatch detected and corrected: deviceInfo.name="${deviceInfo.name}" → using "${deviceName}"`);
-    }
-    
-    // For Android devices, get UIAutomator2 session info using global helper
-    if (deviceInfo.platform === 'android') {
-      const session = await this.getAndroidSession(this.commanderDevice);
-      
-      if (session) {
-        this.logger.info(`✅ Android UIAutomator2 session found: port ${session.port}, sessionId ${session.sessionId.substring(0, 8)}...`);
-        this.commanderDriver = await this.createDriverInterface();
-      } else {
-        this.logger.warn(`⚠️  No UIAutomator2 session found, will look up on first screenshot`);
-        // Still create the driver interface - it will check for session when needed
-        this.commanderDriver = await this.createDriverInterface();
-      }
-    }
-    // For iOS devices, ONLY check for existing WDA session - DON'T create new one
-    else if (deviceInfo.platform === 'ios') {
-      await this.checkExistingWDASession();
-    }
-    
-    // Start real-time touch event monitoring
-    this.startTouchMonitoring();
-    
-    this.broadcastCommanderStatus();
-    
-    return {
-      success: true,
-      commanderDevice: this.commanderDevice,
-      sessionId: this.sessionId
-    };
-  }
-
-  async checkExistingWDASession() {
-    const axios = require('axios');
-    const device = this.commanderDevice;
-    const port = device.port || 8100;
-    
-    try {
-      // Check for existing WDA session first - ALWAYS, even for promoted followers
-      this.logger.info('Checking for existing WDA session...');
-      
-      const wasRecentFollower = this.wasRecentlyFollower || false;
-      if (wasRecentFollower) {
-        this.logger.info(`🔄 Device ${device.name} was recently a follower - attempting to reuse existing WDA session`);
-      }
-      
-      // ALWAYS try to find and reuse existing sessions first
-      try {
-        const existingSessionId = await this.sessionManager.getActiveSession(device.name, device.port || 8100);
-        
-        if (existingSessionId) {
-          this.logger.info(`✅ Found existing WDA session: ${existingSessionId.substring(0, 8)}... - testing viability`);
-          
-          // Test if the session actually works
-          const sessionWorks = await this.validateSessionWorking(device.port || 8100);
-          if (sessionWorks) {
-            this.commanderDriver = this.createDriverInterface();
-            this.logger.info(`✅ Reusing healthy existing WDA session for ${wasRecentFollower ? 'promoted follower' : 'commander'}`);
-            await this.getDeviceWindowSize(device.port || 8100);
-            return;
-          } else {
-            this.logger.warn(`⚠️ Existing session found but not responding - will create fresh session`);
-          }
-        } else {
-          this.logger.info('No existing session found - will create new one');
-        }
-      } catch (sessionCheckError) {
-        this.logger.warn(`Session check failed: ${sessionCheckError.message} - will create new session`);
-      }
-      
-      // GENIUS: First check global session manager
-      const existingSession = global.sessionManager?.getByName(device.name);
-      if (existingSession && existingSession.platform === 'ios') {
-        this.logger.info(`✅ Found global WDA session: ${existingSession.sessionId}`);
-        
-        // CRITICAL: Test if this session actually works for screenshots before using it
-        const sessionWorks = await this.validateSessionWorking(port);
-        if (sessionWorks) {
-          this.commanderDriver = this.createDriverInterface();
-          this.logger.info(`✅ Using validated global WDA session: ${existingSession.sessionId}`);
-          await this.getDeviceWindowSize(port);
-          return;
-        } else {
-          this.logger.warn(`⚠️ Global session found but screenshot test failed - creating fresh session`);
-          await this.createWDASession();
-          return;
-        }
-      }
-      
-      // Fallback: check connectedDevices for backward compatibility
-      const globalDevice = this.connectedDevices.find(d => d.name === device.name || d.udid === device.udid);
-      if (globalDevice && globalDevice.sessionId) {
-        // FIXED: Use safe session registration (don't override for Quick actions)
-        global.sessionManager?.getOrRegisterSession(device.udid, globalDevice.sessionId, port, device.name, null, 'ios');
-        this.commanderDriver = this.createDriverInterface();
-        this.logger.info(`✅ Registered and using WDA session: ${globalDevice.sessionId}`);
-        await this.getDeviceWindowSize(port);
-        return;
-      }
-      
-      // If no global session, check /status endpoint for existing session
-      try {
-        const statusResponse = await axios.get(`http://localhost:${port}/status`, { timeout: 5000 });
-        const sessionId = statusResponse.data?.sessionId || statusResponse.data?.value?.sessionId;
-        
-        if (sessionId) {
-          // Register globally to ensure it's available everywhere
-          this.registerSessionGlobally(device, sessionId, port);
-          this.commanderDriver = this.createDriverInterface();
-          this.logger.info(`✅ Found and registered WDA session: ${sessionId.substring(0, 8)}...`);
-          await this.getDeviceWindowSize(port);
-          return;
-        }
-      } catch (statusError) {
-        this.logger.debug(`WDA /status endpoint check failed: ${statusError.message}`);
-      }
-      
-      // Try to get existing session from /sessions endpoint
-      try {
-        const sessionsResponse = await axios.get(`http://localhost:${port}/sessions`, { timeout: 3000 });
-        const sessions = sessionsResponse.data?.value;
-        
-        if (sessions && Array.isArray(sessions) && sessions.length > 0) {
-          const sessionId = sessions[0].id;
-          // Register globally
-          this.registerSessionGlobally(device, sessionId, port);
-          this.commanderDriver = this.createDriverInterface();
-          this.logger.info(`✅ Found and registered session from /sessions: ${sessionId.substring(0, 8)}...`);
-          await this.getDeviceWindowSize(port);
-          return;
-        }
-      } catch (e) {
-        this.logger.debug('No sessions found at /sessions endpoint');
-      }
-      
-      // If no existing session found, create a new one (this should work since we validated WDA availability)
-      this.logger.info('⚠️  No existing WDA session found - creating new session for commander mode');
-      
-      // CRITICAL DEBUG: Log the complete device state for troubleshooting
-      this.logger.info(`🔍 Device promotion debug info:`, {
-        name: device.name,
-        udid: device.udid,
-        port: device.port,
-        platform: device.platform
-      });
-      
-      // Check if this device was recently a follower
-      const wasFollower = this.followerDevices && Array.from(this.followerDevices).some(f => f.name === device.name);
-      if (wasFollower) {
-        this.logger.info(`🔄 Device ${device.name} was recently a follower, ensuring clean session setup`);
-      }
-      
-      try {
-        await this.createWDASession();
-        this.commanderDriver = this.createDriverInterface();
-        this.logger.info('✅ New WDA session created for commander mode');
-        
-        // CRITICAL: Force immediate session validation after creation
-        await this.validateSessionWorking(device.port || 8100);
-        
-      } catch (createError) {
-        this.logger.error(`❌ Failed to create WDA session: ${createError.message}`);
-        this.logger.warn('💡 Commander mode will work with limited functionality');
-        
-        // EMERGENCY FALLBACK: Try one more time after a delay
-        setTimeout(async () => {
-          try {
-            this.logger.info(`🔧 Emergency retry: Creating WDA session for ${device.name}`);
-            await this.createWDASession();
-            this.commanderDriver = this.createDriverInterface();
-            this.logger.info('✅ Emergency retry successful');
-          } catch (retryError) {
-            this.logger.error(`❌ Emergency retry failed: ${retryError.message}`);
-          }
-        }, 2000);
-      }
-      
-    } catch (error) {
-      this.logger.error(`❌ Failed to check WDA status: ${error.message}`);
-      this.logger.warn('💡 Commander mode will continue with limited functionality');
-      // Continue anyway - since WDA was validated before we got here, this is likely a temporary issue
-    }
-  }
-
-  // CRITICAL: Validate that a WDA session is actually working for screenshots
-  async validateSessionWorking(port) {
-    const axios = require('axios');
-    
-    try {
-      this.logger.info(`🧪 Fast validating WDA session on port ${port}...`);
-      
-      // Test screenshot endpoint with faster timeout
-      const screenshotResponse = await axios.get(`http://localhost:${port}/screenshot`, {
-        timeout: 4000, // Reduced from 8000ms to 4000ms for faster validation
-        validateStatus: () => true // Don't throw on any status
-      });
-      
-      if (screenshotResponse.status === 200) {
-        const imageData = screenshotResponse.data;
-        if (imageData && (typeof imageData === 'string' && imageData.length > 100)) {
-          this.logger.info(`✅ WDA session validation successful - screenshot working`);
-          return true;
-        } else {
-          this.logger.warn(`⚠️ WDA session responds but image data invalid (length: ${imageData?.length || 0})`);
-          return false;
-        }
-      } else {
-        this.logger.warn(`⚠️ WDA session validation failed - status ${screenshotResponse.status}`);
-        return false;
-      }
-      
-    } catch (error) {
-      this.logger.warn(`⚠️ WDA session validation failed: ${error.message}`);
-      return false;
-    }
-  }
-
-  async startTouchMonitoring() {
-    if (this.touchMonitorInterval) {
-      clearInterval(this.touchMonitorInterval);
-    }
-    
-    this.logger.info('🎯 Starting optimized screen mirroring and touch monitoring');
-    
-    // Pre-warm sessions for faster startup
-    await this.preWarmSessions();
-    
-    // Start screen streaming (2 FPS for responsive interaction)
-    this.startScreenStreaming();
-  }
-
-  /**
-   * Pre-warm sessions to reduce initial mirroring delay
-   */
-  async preWarmSessions() {
-    try {
-      this.logger.info('⚡ Pre-warming sessions for instant mirroring...');
-      
-      // Pre-warm commander device session
-      if (this.commanderDevice) {
-        if (this.commanderDevice.platform === 'android') {
-          await this.getAndroidSession(this.commanderDevice);
-        } else if (this.commanderDevice.platform === 'ios') {
-          const port = this.commanderDevice.port || 8100;
-          try {
-            await this.sessionManager.getLiveSessionId(this.commanderDevice.name, port);
-            this.logger.info(`✅ Pre-warmed iOS session for ${this.commanderDevice.name}:${port}`);
-          } catch (error) {
-            this.logger.debug(`Pre-warm failed for ${this.commanderDevice.name}, will discover during streaming`);
-          }
-        }
-      }
-      
-      // Pre-warm follower device sessions and cache screenshot URLs
-      if (this.followerDevices && this.followerDevices.size > 0) {
-        for (const follower of this.followerDevices) {
-          try {
-            if (follower.platform === 'android') {
-              const session = await this.getAndroidSession(follower);
-              if (session) {
-                // Pre-cache screenshot URL for faster streaming
-                follower._cachedPort = session.port;
-                follower._cachedScreenshotUrl = `http://localhost:${session.port}/wd/hub/session/${session.sessionId}/screenshot`;
-                this.logger.info(`✅ Pre-cached Android follower: ${follower.name}:${session.port}`);
-              }
-            } else if (follower.platform === 'ios') {
-              const port = follower.port || 8100;
-              try {
-                await this.sessionManager.getLiveSessionId(follower.name, port);
-                // Pre-cache screenshot URL for faster streaming
-                follower._cachedPort = port;
-                follower._cachedScreenshotUrl = `http://localhost:${port}/screenshot`;
-                this.logger.info(`✅ Pre-cached iOS follower: ${follower.name}:${port}`);
-              } catch (error) {
-                // Try alternative port for iOS
-                const altPort = port === 8100 ? 8101 : 8100;
-                try {
-                  await this.sessionManager.getLiveSessionId(follower.name, altPort);
-                  follower.port = altPort;
-                  follower._cachedPort = altPort;
-                  follower._cachedScreenshotUrl = `http://localhost:${altPort}/screenshot`;
-                  this.logger.info(`✅ Pre-cached iOS follower on alt port: ${follower.name}:${altPort}`);
-                } catch (altError) {
-                  this.logger.debug(`Pre-warm failed for follower ${follower.name} on both ports`);
-                }
-              }
-            }
-          } catch (error) {
-            this.logger.debug(`Pre-warm failed for follower ${follower.name}, will discover during streaming`);
-          }
-        }
-      }
-      
-      this.logger.info('⚡ Session pre-warming complete');
-    } catch (error) {
-      this.logger.warn(`Pre-warming failed: ${error.message}, continuing with normal startup`);
-    }
-  }
-
-  async createWDASession() {
-    const axios = require('axios');
-    const device = this.commanderDevice;
-    const port = device.port || 8100;
-    
-    try {
-      this.logger.info('No existing session found, creating new one...');
-      
-      // Create new session
-      const createResponse = await axios.post(`http://localhost:${port}/session`, {
-        capabilities: {
-          alwaysMatch: {},
-          firstMatch: [{}]
-        }
-      }, { timeout: 10000 });
-      
-      const newSessionId = createResponse.data?.sessionId || createResponse.data?.value?.sessionId;
-      
-      if (newSessionId) {
-        // Register globally to ensure it's available everywhere
-        this.registerSessionGlobally(device, newSessionId, port);
-        this.logger.info(`✅ WDA session created and registered: ${newSessionId.substring(0, 8)}...`);
-        await this.getDeviceWindowSize(port);
-      } else {
-        throw new Error('Failed to create WDA session - no session ID returned');
-      }
-      
-    } catch (error) {
-      this.logger.error(`❌ WDA session creation failed: ${error.message}`);
-      throw error;
-    }
-  }
-
-  async startScreenStreaming() {
-    if (this.screenStreamInterval) {
-      clearInterval(this.screenStreamInterval);
-    }
-    
-    const axios = require('axios');
-    this.logger.info('📺 Starting optimized screen streaming at 2 FPS');
-    
-    // CRITICAL DEBUG: Check device state before starting streaming
-    if (!this.commanderDevice) {
-      this.logger.error('❌ Cannot start screen streaming: no commander device set');
-      return;
-    }
-    
-    this.logger.info(`📱 Starting screen streaming for: "${this.commanderDevice.name}" on port ${this.commanderDevice.port}`);
-    
-    // Pre-validate session and cache endpoint URL for faster streaming
-    const device = this.commanderDevice;
-    let cachedScreenshotUrl = null;
-    let cachedPort = null;
-    
-    try {
-      if (device.platform === 'android') {
-        const session = await this.getAndroidSession(device);
-        if (session) {
-          cachedPort = session.port;
-          cachedScreenshotUrl = `http://localhost:${cachedPort}/wd/hub/session/${session.sessionId}/screenshot`;
-          this.logger.info(`✅ Pre-cached Android screenshot URL: ${cachedScreenshotUrl.substring(0, 80)}...`);
-        }
-      } else if (device.platform === 'ios') {
-        cachedPort = device.port || 8100;
-        try {
-          const sessionId = await this.sessionManager.getLiveSessionId(device.name, cachedPort);
-          cachedScreenshotUrl = `http://localhost:${cachedPort}/screenshot`;
-          this.logger.info(`✅ Pre-validated iOS WDA session on port ${cachedPort}`);
-        } catch (error) {
-          this.logger.info(`⚡ Will try session discovery during first screenshot - continuing optimistically`);
-          cachedScreenshotUrl = `http://localhost:${cachedPort}/screenshot`;
-        }
-      }
-    } catch (error) {
-      this.logger.warn(`⚠️ Session pre-validation failed, will discover during streaming: ${error.message}`);
-    }
-    
-    let lastScreenHash = null;
-    let frameCount = 0;
-    let consecutiveErrors = 0;
-    
-    // Stream at 2 FPS (every 500ms) with optimized error handling
-    this.screenStreamInterval = setInterval(async () => {
-      try {
-        const device = this.commanderDevice;
-        
-        if (!device) {
-          this.logger.error('❌ Commander device is null during streaming');
-          return;
-        }
-        
-        // Use cached screenshot URL first, or fallback to session discovery
-        let screenshotUrl = cachedScreenshotUrl;
-        let port = cachedPort;
-        
-        // If we don't have cached URL, do fast session lookup
-        if (!screenshotUrl) {
-          if (device.platform === 'android') {
-            // For Android UIAutomator2, use session-based endpoint with global session manager
-            const session = await this.getAndroidSession(device);
-            
-            if (!session) {
-              consecutiveErrors++;
-              if (consecutiveErrors <= 3) { // Only log for first few errors
-                this.logger.warn(`⚠️ No Android UIAutomator2 session found for ${device.name} (attempt ${consecutiveErrors})`);
-              }
-              return;
-            }
-            
-            port = session.port;
-            screenshotUrl = `http://localhost:${port}/wd/hub/session/${session.sessionId}/screenshot`;
-            // Cache for future use
-            cachedPort = port;
-            cachedScreenshotUrl = screenshotUrl;
-            
-          } else if (device.platform === 'ios') {
-            // iOS WDA uses simple screenshot endpoint with faster port detection
-            port = device.port || cachedPort || 8100;
-            screenshotUrl = `http://localhost:${port}/screenshot`;
-            
-            // Only do session validation if we haven't cached it yet
-            if (!cachedScreenshotUrl) {
-              try {
-                // Quick session check with reduced timeout
-                const sessionId = await this.sessionManager.getLiveSessionId(device.name, port);
-                // Cache successful session info
-                cachedPort = port;
-                cachedScreenshotUrl = screenshotUrl;
-              } catch (error) {
-                // Try one alternative port quickly
-                const altPort = port === 8100 ? 8101 : 8100;
-                try {
-                  await this.sessionManager.getLiveSessionId(device.name, altPort);
-                  port = altPort;
-                  screenshotUrl = `http://localhost:${altPort}/screenshot`;
-                  // Cache successful session info
-                  cachedPort = port;
-                  cachedScreenshotUrl = screenshotUrl;
-                  device.port = altPort; // Update device port
-                } catch (altError) {
-                  consecutiveErrors++;
-                  if (consecutiveErrors <= 3) {
-                    this.logger.warn(`⚠️ No WDA session found for ${device.name} on ports ${port} or ${altPort} (attempt ${consecutiveErrors})`);
-                  }
-                  return;
-                }
-              }
-            }
-          }
-        }
-        
-        // Get screenshot from WDA/UIAutomator2 with optimized timeout
-        const response = await axios.get(screenshotUrl, {
-          timeout: 3000, // Reduced timeout for faster response 
-          validateStatus: () => true // Don't throw on any status
-        });
-        
-        if (response.status !== 200) {
-          consecutiveErrors++;
-          // Clear cache if we have errors - might be stale
-          if (consecutiveErrors >= 2) {
-            cachedScreenshotUrl = null;
-            cachedPort = null;
-          }
-          
-          if (consecutiveErrors <= 3) { // Only log for first few errors
-            this.logger.warn(`⚠️ Screenshot failed with status ${response.status} for ${device.name} (attempt ${consecutiveErrors})`);
-            if (response.status === 404) {
-              this.logger.debug(`Session might be expired - will retry session discovery`);
-            } else if (response.status === 500) {
-              this.logger.debug(`Device might be locked or disconnected`);
-            }
-          }
-          return;
-        }
-        
-        // Reset error counter on success
-        consecutiveErrors = 0;
-        
-        const base64Image = response.data?.value || response.data;
-        
-        if (!base64Image || typeof base64Image !== 'string' || base64Image.length < 100) {
-          this.logger.debug(`❌ Invalid image data from ${device.name}: length=${base64Image?.length}`);
-          return;
-        }
-        
-        // Detect screen changes for auto-refresh
-        const currentHash = base64Image.substring(0, 100); // Simple hash using first 100 chars
-        const screenChanged = lastScreenHash && lastScreenHash !== currentHash;
-        lastScreenHash = currentHash;
-        frameCount++;
-        
-        // Get device window size for coordinate scaling
-        const windowSize = await this.getDeviceWindowSize(port);
-        
-        // Broadcast commander screen to all connected clients
-        this.broadcast({
-          type: 'screen_frame',
-          image: `data:image/png;base64,${base64Image}`,
-          deviceName: device.name,
-          windowSize: windowSize
-        });
-        
-        // Stream follower devices screens
-        this.streamFollowerScreens();
-        
-        // DISABLED: Auto-refresh locators on screen change (too aggressive)
-        // Only refresh manually or after user clicks
-        // if (screenChanged && frameCount > 5) { // Wait for 5 frames before detecting changes
-        //   this.logger.info('📍 Screen changed - auto-refreshing locators...');
-        //   this.broadcast({
-        //     type: 'locators_reloading',
-        //     message: 'Locators are reloading...'
-        //   });
-        //   this.cachedElements = [];
-        //   this.lastCacheTime = 0;
-        //   this.cacheAllElements().catch(err => 
-        //     this.logger.warn(`Auto-refresh failed: ${err.message}`)
-        //   );
-        // }
-        
-        // DISABLED: Load locators only once after first frame (too aggressive)
-        // Only load locators manually when user requests via UI
-        // if (this.cachedElements.length === 0 && !this.isCaching && Date.now() - this.lastCacheTime > 5000) {
-        //   this.broadcast({
-        //     type: 'locators_loading',
-        //     message: 'Loading locators...'
-        //   });
-        //   this.cacheAllElements().catch(err => 
-        //     this.logger.warn(`Background locator loading failed: ${err.message}`)
-        //   );
-        // }
-        
-      } catch (error) {
-        // CRITICAL: Better error handling for commander screen streaming
-        if (error.message.includes('socket hang up')) {
-          this.logger.error(`❌ Commander WDA connection lost (socket hang up) - attempting recovery`);
-          
-          // Try to recover the session
-          setTimeout(async () => {
-            try {
-              this.logger.info('🔧 Attempting commander session recovery...');
-              await this.checkExistingWDASession();
-            } catch (recoveryError) {
-              this.logger.error(`❌ Session recovery failed: ${recoveryError.message}`);
-            }
-          }, 2000);
-          
-        } else if (error.code === 'ECONNREFUSED') {
-          this.logger.error(`❌ Commander WDA not responding - connection refused`);
-        } else {
-          this.logger.error(`❌ Commander screenshot error: ${error.message}`);
-        }
-      }
-    }, 500);
-  }
-
-  async streamFollowerScreens() {
-    if (!this.followerDevices || this.followerDevices.size === 0) return;
-    
-    const axios = require('axios');
-    
-    // Stream each follower device screen with optimized session handling
-    for (const follower of this.followerDevices) {
-      try {
-        // Use cached screenshot URL if available, otherwise do fast discovery
-        let screenshotUrl = follower._cachedScreenshotUrl;
-        let port = follower._cachedPort;
-        
-        if (!screenshotUrl) {
-          // Fast session discovery for followers
-          if (follower.platform === 'android') {
-            const session = await this.getAndroidSession(follower);
-            
-            if (!session || !session.port || !session.sessionId) {
-              follower._consecutiveErrors = (follower._consecutiveErrors || 0) + 1;
-              if (follower._consecutiveErrors <= 2) { // Reduced error logging
-                this.logger.debug(`⚠️  No UIAutomator2 session for follower: ${follower.name} (attempt ${follower._consecutiveErrors})`);
-              }
-              continue;
-            }
-            
-            port = session.port;
-            screenshotUrl = `http://localhost:${port}/wd/hub/session/${session.sessionId}/screenshot`;
-            
-            // Cache for future use
-            follower._cachedPort = port;
-            follower._cachedScreenshotUrl = screenshotUrl;
-            
-          } else if (follower.platform === 'ios') {
-            port = follower.port || 8100;
-            screenshotUrl = `http://localhost:${port}/screenshot`;
-            
-            // Quick session validation for iOS followers (only if not cached)
-            if (!follower._cachedScreenshotUrl) {
-              try {
-                await this.sessionManager.getLiveSessionId(follower.name, port);
-                // Cache successful session info
-                follower._cachedPort = port;
-                follower._cachedScreenshotUrl = screenshotUrl;
-              } catch (error) {
-                // Try one alternative port quickly
-                const altPort = port === 8100 ? 8101 : 8100;
-                try {
-                  await this.sessionManager.getLiveSessionId(follower.name, altPort);
-                  port = altPort;
-                  screenshotUrl = `http://localhost:${altPort}/screenshot`;
-                  follower.port = altPort;
-                  follower._cachedPort = port;
-                  follower._cachedScreenshotUrl = screenshotUrl;
-                } catch (altError) {
-                  follower._consecutiveErrors = (follower._consecutiveErrors || 0) + 1;
-                  if (follower._consecutiveErrors <= 2) {
-                    this.logger.debug(`⚠️  No WDA session for follower ${follower.name} on ports ${port} or ${altPort}`);
-                  }
-                  continue;
-                }
-              }
-            }
-          }
-        }
-        
-        // Get screenshot with optimized timeout
-        const response = await axios.get(screenshotUrl, {
-          timeout: 3000, // Reduced from 5000ms to 3000ms for faster follower streaming
-          validateStatus: () => true // Don't throw on any status
-        });
-        
-        if (response.status !== 200) {
-          follower._consecutiveErrors = (follower._consecutiveErrors || 0) + 1;
-          
-          // Clear cache if we have persistent errors
-          if (follower._consecutiveErrors >= 2) {
-            follower._cachedScreenshotUrl = null;
-            follower._cachedPort = null;
-          }
-          
-          if (follower._consecutiveErrors <= 2) {
-            this.logger.debug(`⚠️  Follower ${follower.name} returned status ${response.status} (attempt ${follower._consecutiveErrors})`);
-          }
-          continue;
-        }
-        
-        // Reset error counter on success
-        follower._consecutiveErrors = 0;
-        
-        const base64Image = response.data?.value || response.data;
-        
-        if (base64Image && typeof base64Image === 'string' && base64Image.length > 100) {
-          this.broadcast({
-            type: 'follower_screen',
-            deviceId: follower.name,
-            image: `data:image/png;base64,${base64Image}`
-          });
-          this.logger.debug(`📸 Streamed follower screen: ${follower.name}`);
-        } else {
-          this.logger.warn(`⚠️  No image data for follower: ${follower.name}`);
-        }
-      } catch (error) {
-        if (error.message.includes('socket hang up')) {
-          this.logger.warn(`⚠️  Follower ${follower.name} WDA connection lost - session may need refresh`);
-          
-          // For followers, try to refresh their session
-          if (follower.platform === 'ios') {
-            setTimeout(async () => {
-              try {
-                this.logger.info(`🔧 Refreshing WDA session for follower ${follower.name}...`);
-                await this.checkFollowerWDASession(follower);
-              } catch (refreshError) {
-                this.logger.warn(`⚠️ Failed to refresh follower session: ${refreshError.message}`);
-              }
-            }, 3000);
-          }
-          
-        } else {
-          this.logger.warn(`⚠️  Follower ${follower.name} screenshot error: ${error.message}`);
-        }
-      }
-    }
-  }
-
-  async getDeviceWindowSize(port) {
-    try {
-      const axios = require('axios');
-      let size = null;
-
-      // Try dedicated window size endpoint first (most reliable for logical points)
-      const wdaSessionId = await this.getWDASessionId();
-      if (wdaSessionId) {
-        try {
-          const res = await axios.get(`http://localhost:${port}/session/${wdaSessionId}/window/size`, { timeout: 1000 });
-          if (res.data?.value) {
-            size = res.data.value;
-            this.logger.debug(`Window size from /window/size: ${size.width}x${size.height}`);
-          }
-        } catch (e) { /* ignore */ }
-      }
-
-      // Fallback to /status if session endpoint failed
-      if (!size) {
-        const response = await axios.get(`http://localhost:${port}/status`, { timeout: 1000 });
-        if (response.data?.value?.screenSize) {
-          size = response.data.value.screenSize;
-          this.logger.debug(`Window size from /status: ${size.width}x${size.height}`);
-        }
-      }
-
-      if (size && size.width > 0) {
-        this.lastWindowSize = {
-          width: size.width,
-          height: size.height
-        };
-      }
-
-      return this.lastWindowSize;
-    } catch (error) {
-      return this.lastWindowSize;
-    }
-  }
-
-  async handleScreenClick(x, y, windowSize) {
-    // GENIUS: Queue system for handling rapid clicks
-    return new Promise((resolve, reject) => {
-      const clickRequest = { x, y, windowSize, resolve, reject, timestamp: Date.now() };
-      
-      // Limit queue size to prevent memory issues
-      if (this.clickQueue.length >= this.maxQueueSize) {
-        this.logger.warn(`⚠️ Click queue full (${this.maxQueueSize}), dropping oldest click`);
-        const dropped = this.clickQueue.shift();
-        dropped.reject(new Error('Click dropped due to queue overflow'));
-      }
-      
-      this.clickQueue.push(clickRequest);
-      this.processClickQueue();
-    });
-  }
-
-  async processClickQueue() {
-    if (this.processingClick || this.clickQueue.length === 0) {
-      return;
-    }
-    
-    this.processingClick = true;
-    
-    try {
-      while (this.clickQueue.length > 0) {
-        const clickRequest = this.clickQueue.shift();
-        const age = Date.now() - clickRequest.timestamp;
-        
-        // Skip very old clicks (>2 seconds)
-        if (age > 2000) {
-          this.logger.warn(`⚠️ Skipping stale click (${age}ms old)`);
-          clickRequest.reject(new Error('Click too old'));
-          continue;
-        }
-        
-        try {
-          this.logger.info(`🔄 Processing queued click (${this.clickQueue.length} remaining)`);
-          const result = await this._handleScreenClickInternal(clickRequest.x, clickRequest.y, clickRequest.windowSize);
-          clickRequest.resolve(result);
-        } catch (error) {
-          clickRequest.reject(error);
-        }
-        
-        // Small delay between clicks to prevent overwhelming the system
-        if (this.clickQueue.length > 0) {
-          await new Promise(resolve => setTimeout(resolve, 200));
-        }
-      }
-    } finally {
-      this.processingClick = false;
-    }
-  }
-
-  async _handleScreenClickInternal(x, y, windowSize) {
-    if (!this.isActive) {
-      throw new Error('Commander mode not active');
-    }
-
-    if (!this.commanderDevice) {
-      throw new Error('No commander device available');
-    }
-
-    this.logger.info('');
-    this.logger.info('═══════════════════════════════════════════════════════');
-    this.logger.info(`🖱️ CLICK RECEIVED: (${x}, ${y})`);
-    this.logger.info('═══════════════════════════════════════════════════════');
-    
-    // Determine if incoming coordinates are physical or logical
-    // windowSize parameter is what the frontend THINKS is the total size
-    let logicalX = x;
-    let logicalY = y;
-
-    // If the windowSize provided by frontend is physical resolution, convert to logical
-    if (windowSize && windowSize.width > 600) { // Likely physical
-      const scaleX = this.lastWindowSize.width / windowSize.width;
-      const scaleY = this.lastWindowSize.height / windowSize.height;
-      logicalX = Math.round(x * scaleX);
-      logicalY = Math.round(y * scaleY);
-      this.logger.info(`📐 Converting physical (${x}, ${y}) to logical (${logicalX}, ${logicalY})`);
-      this.logger.info(`📏 Scale factors: X=${scaleX.toFixed(3)}, Y=${scaleY.toFixed(3)}`);
-      this.logger.info(`📱 Frontend size: ${windowSize.width}x${windowSize.height}, Device size: ${this.lastWindowSize.width}x${this.lastWindowSize.height}`);
-    } else {
-      this.logger.info(`📍 Using logical coordinates: (${logicalX}, ${logicalY})`);
-      this.logger.info(`📏 Frontend size: ${windowSize?.width || 'unknown'}x${windowSize?.height || 'unknown'}`);
-    }
-
-    this.logger.info(`🎯 Target: ${this.commanderDevice.name}`);
-    
-    // 🚀 SIMPLE APP LAUNCH DETECTION: Check home screen FIRST
-    const port = this.commanderDevice.port || 8100;
-    
-    // REVOLUTIONARY: Get live session ID for pre-checks
-    let liveSessionId = null;
-    let isOnHomeScreen = false;
-    
-    try {
-      liveSessionId = await this.sessionManager.getSessionWithRetry(this.commanderDevice.name, port);
-      
-      try {
-        const preAppRes = await axios.get(`http://localhost:${port}/session/${liveSessionId}/wda/activeAppInfo`, { timeout: 2000 });
-        const preAppId = preAppRes.data?.value?.bundleId;
-        isOnHomeScreen = preAppId === 'com.apple.springboard';
-        this.logger.info(`🏠 SIMPLE CHECK: ${preAppId} ${isOnHomeScreen ? '(HOME SCREEN - WILL SKIP FOLLOWER COORDS)' : '(IN APP - NORMAL FLOW)'}`);
-      } catch (preAppError) {
-        this.logger.debug(`🏠 Pre-check failed: ${preAppError.message}`);
-        isOnHomeScreen = false;
-      }
-    } catch (sessionError) {
-      this.logger.warn(`⚠️ Failed to get live session for pre-check: ${sessionError.message}`);
-      isOnHomeScreen = false;
-    }
-    
-    try {
-      // ===============================
-      // STEP -1: REVOLUTIONARY SESSION MANAGEMENT
-      // ===============================
-      
-      // ALWAYS get fresh live session ID - no more stored sessions!
-      const liveSession = await this.sessionManager.getSessionWithRetry(this.commanderDevice.name, port);
-      this.logger.info(`🎯 Using live WDA session: ${liveSession.substring(0, 8)}... for ${this.commanderDevice.name}`);
-      
-      let isSessionHealthy = false;
-      
-      // Quick health check using window size (fast and reliable)
-      try {
-        const windowRes = await axios.get(`http://localhost:${port}/session/${liveSession}/window/size`, { timeout: 2000 });
-        if (windowRes.data?.value) {
-          this.logger.info(`✅ Session healthy: ${liveSession.substring(0, 8)}...`);
-          isSessionHealthy = true;
-          // Store window size for coordinate scaling
-          this.lastWindowSize = windowRes.data.value;
-        }
-      } catch (healthError) {
-        this.logger.warn(`⚠️ Session health check failed: ${healthError.message}`);
-        
-        // For 404 errors, try getting a fresh session
-        if (healthError.response?.status === 404) {
-          this.logger.warn(`🔄 Session expired (404), getting fresh session...`);
-          try {
-            const freshSession = await this.sessionManager.getSessionWithRetry(this.commanderDevice.name, port);
-            
-            // Test the fresh session
-            const windowRes = await axios.get(`http://localhost:${port}/session/${freshSession}/window/size`, { timeout: 2000 });
-            if (windowRes.data?.value) {
-              this.logger.info(`✅ Fresh session healthy: ${freshSession.substring(0, 8)}...`);
-              isSessionHealthy = true;
-              this.lastWindowSize = windowRes.data.value;
-            }
-          } catch (recoveryError) {
-            this.logger.error(`❌ Session recovery failed: ${recoveryError.message}`);
-          }
-        }
-      }
-      
-      // If no session is healthy, use default window size
-      if (!isSessionHealthy) {
-        this.logger.warn(`⚠️ No healthy session found, using default window size`);
-        this.lastWindowSize = { width: 414, height: 896 };
-      }
-    
-      // ===============================
-      // STEP 0: NO AUTO LOCATOR CACHING - MANUAL ONLY
-      // ===============================
-      // Cache age checking disabled - only manual refresh via UI
-      // const cacheAge = Date.now() - this.lastCacheTime;
-      // const needsRefresh = this.cachedElements.length === 0 || cacheAge > 30000;
-      
-      // DISABLED: Auto-refresh on clicks - use existing cache or user can manually refresh
-      // if (needsRefresh && !this.isCaching && this.cachedElements.length < 3) {
-      //   this.logger.info(`🔄 Refreshing locators before click (${this.cachedElements.length} cached, ${cacheAge}ms old)`);
-      //   await this.fastCacheAllElements();
-      // } else if (this.cachedElements.length > 0) {
-      //   this.logger.debug(`⚡ Skipping cache refresh for speed (${this.cachedElements.length} elements, ${cacheAge}ms old)`);
-      // }
-      
-      // ===============================
-      // 🎯 STEP 1: INTELLIGENT LOCATOR DETECTION (NEW GENIUS METHOD)
-      // ===============================
-      let intelligentLocator = null;
-      
-      if (isOnHomeScreen) {
-        // 🚀 SIMPLE: Skip intelligent locator for app launches, use coordinates directly
-        this.logger.info(`🚀 SIMPLE: Skipping intelligent locator - home screen app launch, using coordinates`);
-        intelligentLocator = { method: 'coordinates', x: logicalX, y: logicalY };
-      } else {
-        this.logger.info(`🎯 INTELLIGENT LOCATOR: Finding smart locator for (${logicalX}, ${logicalY})...`);
-        
-        if (this.useIntelligentLocators) {
-        try {
-          // CRITICAL FIX: Ensure cache is fresh for current screen state
-          // Check cache age and refresh if it's older than a few seconds
-          // PERFORMANCE: Optimize cache management for commander speed - SAFER VERSION
-          const cacheAge = this.intelligentLocator.getCacheAge(this.commanderDevice.name);
-          
-          // More conservative cache strategy to prevent issues
-          const hasValidCache = cacheAge !== null && cacheAge < 15000; // REDUCED: 15 seconds (was 20)
-          const needsRefresh = !hasValidCache;
-          
-          if (needsRefresh) {
-            this.logger.info(`🔄 Cache is stale (age: ${cacheAge}ms) - refreshing before locator search...`);
-          } else {
-            this.logger.debug(`⚡ Using existing cache (age: ${cacheAge}ms) for commander speed`);
-          }
-          
-          // Get intelligent locator - only force refresh if truly needed
-          intelligentLocator = await this.intelligentLocator.getIntelligentLocator(
-            this.commanderDevice.name, 
-            logicalX, 
-            logicalY,
-            needsRefresh // Force refresh if cache is stale
-          );
-          
-          if (intelligentLocator.method === 'locator') {
-            this.logger.info(`✅ INTELLIGENT: Found ${intelligentLocator.locator.strategy} locator with ${(intelligentLocator.confidence * 100).toFixed(1)}% confidence`);
-            this.logger.info(`   Strategy: ${intelligentLocator.locator.strategy} = "${intelligentLocator.locator.selector}"`);
-            this.logger.info(`   Element: ${intelligentLocator.element.elementType} "${intelligentLocator.element.text || intelligentLocator.element.accessibilityLabel || 'No text'}"`);
-          } else {
-            this.logger.warn(`⚠️ INTELLIGENT: Falling back to coordinates (${intelligentLocator.method})`);
-            this.coordinateFallbackCount++;
-          }
-          
-        } catch (error) {
-          this.logger.error(`❌ INTELLIGENT: Locator detection failed: ${error.message}`);
-          intelligentLocator = { method: 'coordinates', x: logicalX, y: logicalY };
-          this.coordinateFallbackCount++;
-        }
-      } else {
-        // Traditional method for compatibility
-        this.logger.info(`🔍 TRADITIONAL: Finding element at target location...`);
-        const preClickElement = this.findClosestElement(logicalX, logicalY);
-        
-        if (preClickElement) {
-          intelligentLocator = {
-            method: 'locator',
-            locator: {
-              strategy: 'accessibility_id',
-              selector: preClickElement.accessibilityId || preClickElement.label || preClickElement.name
-            },
-            fallbackCoords: { x: logicalX, y: logicalY },
-            element: preClickElement
-          };
-          this.logger.info(`✅ TRADITIONAL: Found element: ${preClickElement.label}`);
-        } else {
-          intelligentLocator = { method: 'coordinates', x: logicalX, y: logicalY };
-          this.logger.warn(`⚠️ TRADITIONAL: No element found, using coordinates`);
-        }
-      }
-      } // Close the else block for non-home screen processing
-      
-      // ===============================
-      // STEP 2: EXECUTE CLICK ON COMMANDER  
-      // ===============================
-      // Get fresh live session using universal session manager
-      const device = this.commanderDevice;
-      
-      // REVOLUTIONARY: Always get current live session
-      let currentSession;
-      try {
-        currentSession = await this.sessionManager.getSessionWithRetry(device.name, port);
-        this.logger.info(`📱 Using WDA session: ${currentSession.substring(0, 8)}... on port ${port}`);
-      } catch (sessionError) {
-        throw new Error(`No valid WDA session found for ${device.name}`);
-      }
-      
-      let retryAttempted = false;
-      
-      // Execute tap on commander using LOGICAL coordinates - AWAIT to ensure it completes
-      try {
-        this.logger.info(`⏳ Executing tap on commander device...`);
-        this.logger.info(`📍 Final tap coordinates: (${logicalX}, ${logicalY})`);
-        
-        // Simple coordinate validation - only prevent obviously dangerous coordinates
-        let safeX = Math.round(logicalX);
-        let safeY = Math.round(logicalY);
-        
-        const deviceHeight = this.lastWindowSize?.height || 896;
-        const deviceWidth = this.lastWindowSize?.width || 414;
-        
-        // Basic bounds checking only (don't modify unless clearly outside device bounds)
-        if (safeX < 0 || safeX > deviceWidth || safeY < 0 || safeY > deviceHeight) {
-          this.logger.warn(`⚠️ Coordinates outside device bounds, clamping: (${safeX}, ${safeY})`);
-          safeX = Math.max(10, Math.min(safeX, deviceWidth - 10));
-          safeY = Math.max(50, Math.min(safeY, deviceHeight - 100)); // Avoid control center
-        }
-        
-        // CRITICAL FIX: Use current session from above
-        await axios.post(
-          `http://localhost:${port}/session/${currentSession}/actions`,
-          {
-            actions: [{
-              type: 'pointer',
-              id: 'finger1',
-              parameters: { pointerType: 'touch' },
-              actions: [
-                { type: 'pointerMove', duration: 0, x: safeX, y: safeY },
-                { type: 'pointerDown', button: 0 },
-                { type: 'pause', duration: 100 },
-                { type: 'pointerUp', button: 0 }
-              ]
-            }]
-          },
-          { timeout: 15000 }
-        );
-        this.logger.info(`✅ Tap executed on commander: ${this.commanderDevice.name}`);
-        
-        // 🚀 SIMPLE APP LAUNCH DETECTION: Check if app changed after tap
-        setTimeout(async () => {
-          // Only check for app launch if we were originally on home screen
-          if (!isOnHomeScreen) {
-            this.logger.debug('📱 Skipping app detection - was not on home screen');
-            return;
-          }
-          
-          try {
-            const currentAppRes = await axios.get(`http://localhost:${port}/session/${currentSession}/wda/activeAppInfo`, { timeout: 3000 });
-            const currentAppId = currentAppRes.data?.value?.bundleId;
-            
-            if (currentAppId && currentAppId !== 'com.apple.springboard') {
-              this.logger.info(`🚀 SIMPLE: App launched on commander: ${currentAppId} - launching on followers...`);
-              
-              // Launch same app on all followers immediately
-              for (const follower of this.followerDevices) {
-                if (follower.platform === 'ios') {
-                  try {
-                    const followerPort = follower.port || 8100;
-                    
-                    // Get fresh session ID using universal session manager
-                    let followerSessionId = null;
-                    try {
-                      followerSessionId = await this.sessionManager.getSessionWithRetry(follower.name, followerPort);
-                    } catch (sessionError) {
-                      this.logger.warn(`⚠️ Could not get session for follower ${follower.name}: ${sessionError.message}`);
-                      continue; // Skip this follower
-                    }
-                    
-                    if (followerSessionId) {
-                      this.logger.info(`🚀 Auto-launching ${currentAppId} on follower: ${follower.name}`);
-                      await axios.post(`http://localhost:${followerPort}/session/${followerSessionId}/wda/apps/launch`, {
-                        bundleId: currentAppId
-                      }, { timeout: 15000 });
-                      this.logger.info(`✅ App ${currentAppId} launched on ${follower.name}`);
-                    } else {
-                      this.logger.warn(`⚠️ No valid session found for ${follower.name}`);
-                    }
-                  } catch (launchError) {
-                    this.logger.warn(`⚠️ Failed to launch ${currentAppId} on ${follower.name}: ${launchError.message}`);
-                  }
-                }
-              }
-              
-              // 🚀 REFRESH CACHE AFTER APP LAUNCH: Now that app is launched, refresh locators for new app
-              setTimeout(() => {
-                this.logger.info('🔄 Refreshing locators after successful app launch...');
-                this.intelligentLocator.invalidateCache(this.commanderDevice.name);
-                // Refresh in background for next interactions in the new app
-                this.intelligentLocator.getCachedLocators(this.commanderDevice.name, true).catch(() => {});
-                for (const follower of this.followerDevices) {
-                  this.intelligentLocator.getCachedLocators(follower.name, true).catch(() => {});
-                }
-              }, 2000); // Wait 2s for app to fully load
-              
-            }
-          } catch (appCheckError) {
-            // Ignore errors in app detection - not critical
-            this.logger.debug(`📱 App check failed: ${appCheckError.message}`);
-          }
-        }, 1000); // Wait 1 second for app to launch (reduced from 2s)
-        
-        // 🎯 OPTIMIZED CACHE INVALIDATION: Less aggressive, smarter cache management
-        if (!isOnHomeScreen) {
-          this.logger.info('🔄 Invalidating locator cache after successful tap to ensure fresh screen state');
-          this.intelligentLocator.invalidateCache(this.commanderDevice.name);
-          
-          // PERFORMANCE: Make background refresh safer with better error handling  
-          setImmediate(() => {
-            // Safer async background refresh
-            (async () => {
-              try {
-                this.logger.debug('🔄 Background refresh of locators after regular tap...');
-                
-                // Refresh commander cache with timeout protection
-                const refreshCommander = this.intelligentLocator.getCachedLocators(this.commanderDevice.name, true)
-                  .catch(err => {
-                    this.logger.debug(`Commander refresh failed: ${err.message}`);
-                    return null;
-                  });
-                
-                await refreshCommander;
-                
-                // Also refresh follower caches in background with individual error handling
-                if (this.followerDevices && this.followerDevices.size > 0) {
-                  const refreshPromises = Array.from(this.followerDevices).map(async (follower) => {
-                    try {
-                      await this.intelligentLocator.getCachedLocators(follower.name, true);
-                    } catch (err) {
-                      this.logger.debug(`Background refresh failed for ${follower.name}: ${err.message}`);
-                    }
-                  });
-                  
-                  await Promise.allSettled(refreshPromises);
-                }
-                
-                this.logger.debug('✅ Background locator refresh completed');
-              } catch (refreshErr) {
-                this.logger.debug(`Background refresh error: ${refreshErr.message}`);
-              }
-            })().catch(err => {
-              // Final safety net to prevent unhandled promise rejections
-              this.logger.debug(`Background refresh async error: ${err.message}`);
-            });
-          });
-        } else {
-          this.logger.info('🚀 Skipping cache refresh - app launch detected, will refresh after app stabilizes');
-        }
-      } catch (err) {
-        // GENIUS: Smarter session handling - avoid recreating sessions that just need a status sync
-        if (err.response && err.response.status === 404 && !retryAttempted) {
-          this.logger.warn(`⚠️ Session might be expired (404), attempting smart recovery...`);
-          
-          // First, try to get a valid session from WDA status
-          let sessionRecovered = false;
-          try {
-            const port = this.commanderDevice.port || 8100;
-            const statusRes = await axios.get(`http://localhost:${port}/status`, { timeout: 5000 });
-            const activeSession = statusRes.data?.sessionId;
-            
-            if (activeSession && activeSession !== currentSession) {
-              // WDA has an active session, just update our reference
-              this.logger.info(`🔄 Found active WDA session: ${activeSession.substring(0, 8)}...`);
-              this.sessionManager.updateSession(this.commanderDevice.name, activeSession);
-              currentSession = activeSession;
-              sessionRecovered = true;
-              this.logger.info(`✅ Session recovered without recreation`);
-            }
-          } catch (statusError) {
-            this.logger.debug(`Status check failed: ${statusError.message}`);
-          }
-          
-          // Only recreate if we couldn't recover an existing session
-          if (!sessionRecovered) {
-            // Before recreating, try one more recovery approach - check if device is still responsive
-            try {
-              const port = this.commanderDevice.port || 8100;
-              const healthRes = await axios.get(`http://localhost:${port}/wda/healthcheck`, { timeout: 2000 });
-              if (healthRes.status === 200) {
-                // WDA is healthy, just create a new session without full recreation
-                this.logger.info(`🔄 WDA is healthy, creating new session without full restart...`);
-                const newSessionRes = await axios.post(`http://localhost:${port}/session`, {
-                  capabilities: {
-                    alwaysMatch: {},
-                    firstMatch: [{}]
-                  }
-                }, { timeout: 10000 });
-                
-                const newSessionId = newSessionRes.data?.sessionId || newSessionRes.data?.value?.sessionId;
-                if (newSessionId) {
-                  this.logger.info(`✅ New session created: ${newSessionId.substring(0, 8)}...`);
-                  this.commanderDevice.sessionId = newSessionId;
-                  if (global.sessionManager) {
-                    global.sessionManager.updateSession(this.commanderDevice.udid, newSessionId);
-                  }
-                  currentSession = newSessionId;
-                  sessionRecovered = true;
-                }
-              }
-            } catch (healthError) {
-              this.logger.debug(`Health check failed: ${healthError.message}`);
-            }
-          }
-          
-          // If session recovery failed, use universal session manager as last resort
-          if (!sessionRecovered) {
-            this.logger.warn(`⚠️ No active session found, getting fresh session...`);
-            try {
-              currentSession = await this.sessionManager.getSessionWithRetry(device.name, port); 
-              sessionRecovered = true;
-            } catch (recreateError) {
-              this.logger.error(`❌ Session recovery failed: ${recreateError.message}`);
-              throw new Error(`Commander tap failed: ${err.message}`);
-            }
-          }
-            
-          // Retry the tap with recovered/new session
-          if (sessionRecovered) {
-            // Retry the tap with new session - use simple coordinate validation
-            try {
-              await axios.post(
-                `http://localhost:${port}/session/${currentSession}/actions`,
-                {
-                  actions: [{
-                    type: 'pointer',
-                    id: 'finger1',
-                    parameters: { pointerType: 'touch' },
-                    actions: [
-                      { type: 'pointerMove', duration: 0, x: safeX, y: safeY },
-                      { type: 'pointerDown', button: 0 },
-                      { type: 'pause', duration: 100 },
-                      { type: 'pointerUp', button: 0 }
-                    ]
-                  }]
-                },
-                { timeout: 15000 }
-              );
-              this.logger.info(`✅ Tap executed on commander: ${this.commanderDevice.name} (after session recovery)`);
-              
-              // 🎯 CACHE INVALIDATION: Force fresh locators after successful recovery tap
-              this.logger.info('🔄 Invalidating locator cache after successful recovery tap');
-              this.intelligentLocator.invalidateCache(this.commanderDevice.name);
-              
-              // 🎯 OPTIMIZED CACHE REFRESH: Schedule refresh but don't block execution
-              setTimeout(async () => {
-                try {
-                  this.logger.info('🔄 Background refresh after recovery tap...');
-                  await this.intelligentLocator.getCachedLocators(this.commanderDevice.name, true);
-                  
-                  // Background refresh for followers
-                  // OPTIMIZATION: Skip duplicate follower refresh - already handled in intelligent actions
-                  this.logger.info('ℹ️  Follower caches managed in intelligent actions - skipping duplicate refresh');
-                  
-                  this.logger.info('✅ Background refresh completed (recovery)');
-                } catch (refreshErr) {
-                  // Ignore background refresh errors
-                }
-              }, 500);
-            } catch (retryErr) {
-              this.logger.error(`❌ Commander tap failed even after session recovery: ${retryErr.message}`);
-              throw new Error(`Commander tap failed: ${retryErr.message}`);
-            }
-          } else {
-            this.logger.error(`❌ Could not recover WDA session for commander`);
-            throw new Error(`Commander tap failed: ${err.message}`);
-          }
-        } else {
-          this.logger.error(`❌ Commander tap failed: ${err.message}`);
-          throw new Error(`Commander tap failed: ${err.message}`);
-        }
-      }
-      
-      // ===============================
-      // 🎯 STEP 4: BROADCAST INTELLIGENT LOCATORS TO FOLLOWERS (NEW GENIUS METHOD)
-      // ===============================
-      const followerDevices = Array.from(this.followerDevices);
-      if (followerDevices.length > 0) {
-        
-        if (isOnHomeScreen) {
-          this.logger.info('🏠 SIMPLE: On home screen - skipping follower broadcast, will detect app launch instead...');
-          // Skip immediate coordinate broadcast, let app detection handle it
-        } else {
-          this.logger.info('');
-          this.logger.info(`📡 Broadcasting INTELLIGENT locators to ${followerDevices.length} follower(s):`);
-          for (const follower of followerDevices) {
-            this.logger.info(`   • ${follower.name} (${follower.platform})`);
-            this.executeIntelligentActionOnFollower(follower, intelligentLocator, logicalX, logicalY)
-              .catch(e => this.logger.error(`Follower ${follower.name} intelligent action failed: ${e.message}`));
-          }
-        }
-      } else {
-        this.logger.info('ℹ️  No followers connected');
-      }
-      
-      // Log performance metrics
-      const metrics = this.intelligentLocator.getPerformanceMetrics();
-      this.logger.info(`📊 Intelligent Locator Metrics: ${metrics.accuracyRate} accuracy, ${metrics.cacheHitRate} cache hit rate`);
-      
-      this.logger.info('═══════════════════════════════════════════════════════');
-      this.logger.info('');
-      return { 
-        success: true, 
-        devicesCount: 1 + followerDevices.length, 
-        intelligentLocator: intelligentLocator,
-        method: intelligentLocator.method,
-        metrics: metrics
-      };
-    } catch (error) {
-      this.logger.error('Screen click handling error:', error.message);
-      throw error;
-    }
-  }
-
-  // Faster caching method that avoids heavy API calls
-  async fastCacheAllElements() {
-    const wdaSessionId = await this.getWDASessionId();
-    if (!wdaSessionId || !this.commanderDevice) return;
-    if (this.isCaching) return;
-    
-    this.isCaching = true;
-    const startTime = Date.now();
-    
-    try {
-      const device = this.commanderDevice;
-      const port = device.port || 8100;
-      const sessionId = wdaSessionId;
-
-      this.logger.info('🔍 Starting fast locator detection...');
-
-      // Try page source first (fastest method)
-      try {
-        const sourceRes = await axios.get(
-          `http://localhost:${port}/session/${sessionId}/source`,
-          { timeout: 3000 } // Reduced timeout for speed
-        );
-        
-        if (sourceRes.data?.value) {
-          const pageSource = sourceRes.data.value;
-          const allElements = this.parsePageSourceFast(pageSource);
-          
-          if (allElements.length > 0) {
-            this.cachedElements = allElements;
-            this.lastCacheTime = Date.now();
-            
-            const elapsed = Date.now() - startTime;
-            this.logger.info(`✅ Fast cached ${allElements.length} elements in ${elapsed}ms`);
-            return;
-          }
-        }
-      } catch (pageSourceErr) {
-        this.logger.warn(`Page source method failed, falling back to element query`);
-        
-        // Fallback: Quick element query for essential elements only - SPEED OPTIMIZED
-        const elementTypes = ['XCUIElementTypeButton']; // Only buttons for speed
-        const allElements = [];
-        
-        for (const elementType of elementTypes) {
-          try {
-            const query = { using: 'class name', value: elementType };
-            const elementsRes = await axios.post(
-              `http://localhost:${port}/session/${sessionId}/elements`,
-              query,
-              { timeout: 2000 } // Quick timeout
-            );
-
-            if (elementsRes.data?.value && Array.isArray(elementsRes.data.value)) {
-              const elements = elementsRes.data.value.slice(0, 10); // Further reduced for speed
-              
-              for (const elem of elements) {
-                const elementId = elem.ELEMENT || elem['element-6066-11e4-a52e-4f735466cecf'];
-                if (!elementId) continue;
-                
-                try {
-                  const rectRes = await axios.get(`http://localhost:${port}/session/${sessionId}/element/${elementId}/rect`, { timeout: 500 });
-                  
-                  if (rectRes.data?.value) {
-                    const rect = rectRes.data.value;
-                    if (rect.width > 5 && rect.height > 5) { // Skip tiny elements
-                      allElements.push({
-                        type: elementType,
-                        label: 'Unlabeled', // Skip label for speed
-                        name: 'Unlabeled',
-                        accessibilityId: 'Unlabeled',
-                        x: Math.round(rect.x),
-                        y: Math.round(rect.y),
-                        width: Math.round(rect.width),
-                        height: Math.round(rect.height),
-                        centerX: Math.round(rect.x + rect.width / 2),
-                        centerY: Math.round(rect.y + rect.height / 2)
-                      });
-                    }
-                  }
-                } catch (err) { 
-                  // Skip this element, continue with others
-                  continue; 
-                }
-              }
-            }
-          } catch (queryErr) {
-            this.logger.warn(`Query ${elementType} failed: ${queryErr.message}`);
-            continue;
-          }
-        }
-        
-        this.cachedElements = allElements;
-        this.lastCacheTime = Date.now();
-        
-        const elapsed = Date.now() - startTime;
-        this.logger.info(`✅ Cached ${allElements.length} elements in ${elapsed}ms`);
-      }
-    } catch (error) {
-      this.logger.error(`Fast cache failed: ${error.message}`);
-    } finally {
-      this.isCaching = false;
-    }
-  }
-
-  async cacheAllElements() {
-    const wdaSessionId = await this.getWDASessionId();
-    if (!wdaSessionId || !this.commanderDevice) return;
-    if (this.isCaching) return;
-    
-    this.isCaching = true;
-    const startTime = Date.now();
-    
-    try {
-      const axios = require('axios');
-      const device = this.commanderDevice;
-      const port = device.port || 8100;
-      const sessionId = wdaSessionId;
-
-      this.logger.info('🔍 Starting fast locator detection...');
-
-      // Use page source for MUCH faster element detection
-      try {
-        const sourceRes = await axios.get(
-          `http://localhost:${port}/session/${sessionId}/source`,
-          { timeout: 8000 }
-        );
-        
-        if (sourceRes.data?.value) {
-          const pageSource = sourceRes.data.value;
-          const allElements = this.parsePageSourceFast(pageSource);
-          
-          if (allElements.length > 0) {
-            this.cachedElements = allElements;
-            this.lastCacheTime = Date.now();
-            
-            const elapsed = Date.now() - startTime;
-            this.logger.info(`✅ Fast cached ${allElements.length} elements in ${elapsed}ms`);
-
-            // Send all at once from page source (fastest method)
-            this.broadcast({
-              type: 'cached_elements',
-              elements: allElements.map(e => ({
-                label: e.label || e.name,
-                type: e.type.replace('XCUIElementType', ''),
-                x: e.x,
-                y: e.y,
-                width: e.width,
-                height: e.height
-              })),
-              total: allElements.length,
-              timestamp: Date.now()
-            });
-            
-            // Broadcast completion
-            this.broadcast({
-              type: 'locators_loaded',
-              total: allElements.length
-            });
-            
-            this.isCaching = false;
-            return;
-          }
-        }
-      } catch (err) {
-        this.logger.warn('Page source method failed, falling back to element query');
-      }
-
-      // Optimized queries - focus on most important element types only
-      const queries = [
-        { using: 'class name', value: 'XCUIElementTypeButton' },
-        { using: 'class name', value: 'XCUIElementTypeStaticText' }
-      ];
-      
-      const allElements = [];
-      const MAX_ELEMENTS = 20; // Further reduced for speed
-      
-      // Process queries sequentially with timeout protection
-      for (const query of queries) {
-        if (allElements.length >= MAX_ELEMENTS) break;
-        
-        try {
-          const elementsRes = await axios.post(
-            `http://localhost:${port}/session/${sessionId}/elements`,
-            query,
-            { timeout: 3000 } // Reduced timeout
-          );
-
-          if (elementsRes.data?.value && Array.isArray(elementsRes.data.value)) {
-            const elements = elementsRes.data.value.slice(0, MAX_ELEMENTS - allElements.length);
-            
-            // Process elements in smaller batches to reduce session load
-            const chunkSize = 5; // Smaller chunks for better performance
-            for (let i = 0; i < elements.length && allElements.length < MAX_ELEMENTS; i += chunkSize) {
-              const chunk = elements.slice(i, i + chunkSize);
-              const chunkPromises = chunk.map(async (elem) => {
-                const elementId = elem.ELEMENT || elem['element-6066-11e4-a52e-4f735466cecf'];
-                if (!elementId) return null;
-                
-                try {
-                  // Only get rect - skip label to reduce API calls
-                  const rectRes = await axios.get(`http://localhost:${port}/session/${sessionId}/element/${elementId}/rect`, { timeout: 800 });
-                  
-                  if (rectRes.data?.value) {
-                    const rect = rectRes.data.value;
-                    
-                    // Skip very small elements that are not useful
-                    if (rect.width < 10 || rect.height < 10) return null;
-                    
-                    // Get label only for buttons (most important)
-                    let label = 'Unlabeled';
-                    if (query.value === 'XCUIElementTypeButton') {
-                      try {
-                        const labelRes = await axios.get(`http://localhost:${port}/session/${sessionId}/element/${elementId}/attribute/label`, { timeout: 500 });
-                        label = labelRes.data?.value || 'Unlabeled';
-                      } catch (labelErr) {
-                        // Skip this element if we can't get its label for buttons
-                        return null;
-                      }
-                    }
-                    
-                    return {
-                      type: query.value,
-                      label: label,
-                      name: label || 'Unlabeled',
-                      accessibilityId: label,
-                      x: Math.round(rect.x),
-                      y: Math.round(rect.y),
-                      width: Math.round(rect.width),
-                      height: Math.round(rect.height),
-                      centerX: Math.round(rect.x + rect.width / 2),
-                      centerY: Math.round(rect.y + rect.height / 2)
-                    };
-                  }
-                } catch (err) { return null; }
-                return null;
-              });
-              
-              const chunkResults = await Promise.all(chunkPromises);
-              const validElements = chunkResults.filter(e => e !== null);
-              
-              if (validElements.length > 0) {
-                typeElements.push(...validElements);
-                allElements.push(...validElements);
-                
-                // Broadcast incrementally for instant UI feedback
-                this.broadcast({
-                  type: 'cached_elements',
-                  elements: validElements.map(e => ({
-                    label: e.label || e.name,
-                    type: e.type.replace('XCUIElementType', ''),
-                    x: e.x,
-                    y: e.y,
-                    width: e.width,
-                    height: e.height
-                  })),
-                  total: allElements.length,
-                  timestamp: Date.now()
-                });
-              }
-            }
-          }
-        } catch (err) { 
-          this.logger.warn(`Query ${query.value} failed: ${err.message}`);
-        }
-      }
-      
-      this.cachedElements = allElements;
-      this.lastCacheTime = Date.now();
-
-      const elapsed = Date.now() - startTime;
-      this.logger.info(`✅ Cached ${allElements.length} elements in ${elapsed}ms`);
-      
-      // Broadcast completion
-      this.broadcast({
-        type: 'locators_loaded',
-        total: allElements.length
-      });
-      
-    } finally {
-      this.isCaching = false;
-    }
-  }
-
-  // GENIUS: Enhanced session recovery with minimal disruption
-  async recoverOrCreateSession(device, originalSessionId = null) {
-    const port = device.port || 8100;
-    
-    this.logger.info(`🔍 Smart session recovery for ${device.name}...`);
-    
-    // STEP 1: Check if WDA server itself is responsive
-    try {
-      const statusRes = await axios.get(`http://localhost:${port}/status`, { timeout: 2000 });
-      const serverSessionId = statusRes.data?.sessionId;
-      
-      if (serverSessionId && serverSessionId !== originalSessionId) {
-        // WDA has a VALID session that's different from ours - use it!
-        this.logger.info(`✅ Found active WDA session: ${serverSessionId.substring(0, 8)}...`);
-        
-        // Test the session works
-        try {
-          await axios.get(`http://localhost:${port}/session/${serverSessionId}/window/size`, { timeout: 2000 });
-          
-          // Update our references
-          device.sessionId = serverSessionId;
-          if (global.sessionManager) {
-            global.sessionManager.updateSession(device.udid, serverSessionId);
-          }
-          
-          this.logger.info(`✅ Session recovered without recreation`);
-          return serverSessionId;
-        } catch (testErr) {
-          this.logger.debug(`Found session ${serverSessionId} doesn't work: ${testErr.message}`);
-        }
-      }
-    } catch (statusErr) {
-      this.logger.debug(`WDA status check failed: ${statusErr.message}`);
-    }
-    
-    // STEP 2: Try creating a NEW session without killing existing ones
-    try {
-      this.logger.info(`🔄 Creating fresh WDA session (keeping WDA running)...`);
-      const sessionRes = await axios.post(`http://localhost:${port}/session`, {
-        capabilities: {
-          alwaysMatch: {},
-          firstMatch: [{}]
-        }
-      }, { timeout: 15000 });
-      
-      const newSessionId = sessionRes.data?.sessionId || sessionRes.data?.value?.sessionId;
-      if (newSessionId) {
-        this.logger.info(`✅ Fresh session created: ${newSessionId.substring(0, 8)}...`);
-        
-        // Update references
-        device.sessionId = newSessionId;
-        if (global.sessionManager) {
-          global.sessionManager.updateSession(device.udid, newSessionId);
-        }
-        
-        return newSessionId;
-      }
-    } catch (createErr) {
-      this.logger.warn(`⚠️ Fresh session creation failed: ${createErr.message}`);
-    }
-    
-    // STEP 3: Last resort - full WDA restart (only if nothing else worked)
-    this.logger.warn(`🔄 All gentle approaches failed, doing full session recreation...`);
-    await this.recreateWDASession();
-    return this.getWDASessionId();
-  }
-
-  async recreateWDASession() {
-    if (!this.commanderDevice) {
-      throw new Error('No commander device set');
-    }
-    
-    this.logger.info(`🔄 Recreating WDA session for ${this.commanderDevice.name}...`);
-    
-    try {
-      const device = this.commanderDevice;
-      const port = device.port || 8100;
-      
-      // Store current app before session recreation
-      let currentAppId = null;
-      try {
-        const oldSessionId = this.getWDASessionId();
-        if (oldSessionId) {
-          const appRes = await axios.get(`http://localhost:${port}/session/${oldSessionId}/wda/activeAppInfo`, { timeout: 2000 });
-          currentAppId = appRes.data?.value?.bundleId;
-          this.logger.info(`📱 Current app before session recreation: ${currentAppId || 'unknown'}`);
-        }
-      } catch (appCheckError) {
-        this.logger.warn(`⚠️ Could not detect current app: ${appCheckError.message}`);
-      }
-      
-      // Remove the old session from global manager
-      if (global.sessionManager) {
-        global.sessionManager.deleteSession(device.udid);
-        this.logger.info('🗑️ Removed stale session from global manager');
-      }
-      
-      // Create a completely new WDA session
-      await this.createWDASession();
-      
-      // Verify the new session works
-      const newSessionId = this.getWDASessionId();
-      if (newSessionId) {
-        // Test the session with a simple status call
-        await axios.get(`http://localhost:${port}/session/${newSessionId}/window/size`, { timeout: 3000 });
-        
-        // Smart app restoration - restore the ACTUAL app that was running
-        if (currentAppId && currentAppId !== 'com.apple.springboard') {
-          try {
-            this.logger.info(`🔄 Restoring original app: ${currentAppId}`);
-            await axios.post(`http://localhost:${port}/session/${newSessionId}/wda/apps/launch`, {
-              bundleId: currentAppId
-            }, { timeout: 10000 }); // Increased from 5s to 10s for app restoration
-            
-            // Wait longer for app to fully stabilize after session recreation
-            await new Promise(resolve => setTimeout(resolve, 4000)); // Increased from 2.5s to 4s
-            this.logger.info(`✅ Original app restored: ${currentAppId}`);
-            
-            // Verify app actually launched
-            const verifyRes = await axios.get(`http://localhost:${port}/session/${newSessionId}/wda/activeAppInfo`, { timeout: 3000 });
-            const actualApp = verifyRes.data?.value?.bundleId;
-            if (actualApp === currentAppId) {
-              this.logger.info(`✅ App restoration verified: ${actualApp}`);
-            } else {
-              this.logger.warn(`⚠️ App restoration failed: expected ${currentAppId}, got ${actualApp}`);
-            }
-          } catch (appRestoreError) {
-            this.logger.warn(`⚠️ Could not restore original app ${currentAppId}: ${appRestoreError.message}`);
-            // Don't try to restore anything else - leave in home screen
-          }
-        } else {
-          this.logger.info(`ℹ️  No specific app to restore (was in: ${currentAppId || 'home screen'})`);
-        }
-        
-        this.logger.info(`✅ WDA session recreated successfully: ${newSessionId.substring(0, 8)}...`);
-        return true;
-      }
-    } catch (error) {
-      this.logger.error(`❌ Failed to recreate WDA session: ${error.message}`);
-      throw error;
-    }
-    
-    return false;
-  }
-
-  parsePageSourceFast(pageSource) {
-    // Parse XML page source quickly - focus on truly interactive elements
-    const elements = [];
-    // Focus on most reliable interactive elements for speed and accuracy
-    const xmlRegex = /<XCUIElementType(Button|TextField|Switch|Link|StaticText)[^>]*>/g;
-    
-    let match;
-    while ((match = xmlRegex.exec(pageSource)) !== null) {
-      const elementTag = match[0];
-      
-      // Extract attributes
-      const xMatch = elementTag.match(/x="([^"]+)"/);
-      const yMatch = elementTag.match(/y="([^"]+)"/);
-      const widthMatch = elementTag.match(/width="([^"]+)"/);
-      const heightMatch = elementTag.match(/height="([^"]+)"/);
-      const labelMatch = elementTag.match(/label="([^"]+)"/);
-      const nameMatch = elementTag.match(/name="([^"]+)"/);
-      const enabledMatch = elementTag.match(/enabled="([^"]+)"/);
-      
-      if (xMatch && yMatch && widthMatch && heightMatch) {
-        const x = parseFloat(xMatch[1]);
-        const y = parseFloat(yMatch[1]);
-        const width = parseFloat(widthMatch[1]);
-        const height = parseFloat(heightMatch[1]);
-        const label = labelMatch?.[1] || nameMatch?.[1] || `${match[1]}_${Math.round(x)}_${Math.round(y)}`;
-        const enabled = enabledMatch?.[1] !== 'false';
-        const elementType = `XCUIElementType${match[1]}`;
-        
-        // Fast filtering - keep it simple for speed
-        if (width > 8 && height > 8 && enabled) {
-          // Quick relevance check for speed
-          if (elementType.includes('Button') || elementType.includes('TextField') || 
-              elementType.includes('Switch') || elementType.includes('Link')) {
-            // Always include truly interactive elements
-            elements.push({
-              type: elementType,
-              label: label,
-              name: label,
-              accessibilityId: label,
-              x: Math.round(x),
-              y: Math.round(y),
-              width: Math.round(width),
-              height: Math.round(height),
-              centerX: Math.round(x + width / 2),
-              centerY: Math.round(y + height / 2)
-            });
-          } else if (elementType.includes('StaticText') && width > 30 && height > 15 && label && label.length > 2) {
-            // Only include meaningful StaticText elements
-            elements.push({
-              type: elementType,
-              label: label,
-              name: label,
-              accessibilityId: label,
-              x: Math.round(x),
-              y: Math.round(y),
-              width: Math.round(width),
-              height: Math.round(height),
-              centerX: Math.round(x + width / 2),
-              centerY: Math.round(y + height / 2)
-            });
-          }
-        }
-      }
-    }
-    
-    return elements;
-  }
-
-  findClosestElement(x, y) {
-    if (this.cachedElements.length === 0) return null;
-    
-    // FAST STRATEGY: Find elements containing the click point
-    const containingElements = this.cachedElements.filter(elem => {
-      return x >= elem.x && x <= elem.x + elem.width &&
-             y >= elem.y && y <= elem.y + elem.height;
-    });
-    
-    // If we found elements containing the point, return the smallest one (most specific)
-    if (containingElements.length > 0) {
-      // Sort by area (smallest first = most specific element)
-      containingElements.sort((a, b) => (a.width * a.height) - (b.width * b.height));
-      const bestElement = containingElements[0];
-      
-      // Build strategies quickly - defer sibling detection
-      bestElement.locatorStrategies = [];
-      this.buildFastLocatorStrategies(bestElement);
-      
-      return bestElement;
-    }
-    
-    // ENHANCED STRATEGY: Search for nearby elements with expanded tolerance
-    const nearbyElements = this.cachedElements.filter(elem => {
-      const dx = elem.centerX - x;
-      const dy = elem.centerY - y;
-      const distance = Math.sqrt(dx * dx + dy * dy);
-      return distance <= 80; // Increased from 60px for better coverage
-    });
-    
-    if (nearbyElements.length > 0) {
-      // Enhanced sorting with sibling text detection
-      nearbyElements.forEach(elem => {
-        const dx = elem.centerX - x;
-        const dy = elem.centerY - y;
-        elem.distance = Math.sqrt(dx * dx + dy * dy);
-        
-        // Smart priority boosts
-        if (elem.label && elem.label !== 'Unlabeled' && elem.label.length > 2) {
-          elem.distance *= 0.7; // Strong preference for labeled elements
-        }
-        if (elem.type.includes('Button')) {
-          elem.distance *= 0.8; // Prefer buttons
-        }
-        if (elem.type.includes('Cell')) {
-          elem.distance *= 0.85; // Table cells are often clickable
-        }
-        
-        // GENIUS: Look for nearby text elements that could describe this element
-        const nearbyText = this.cachedElements.find(textElem => {
-          if (textElem.type === 'XCUIElementTypeStaticText' && textElem.label && textElem.label !== 'Unlabeled') {
-            const textDistance = Math.sqrt(
-              Math.pow(textElem.centerX - elem.centerX, 2) + 
-              Math.pow(textElem.centerY - elem.centerY, 2)
-            );
-            return textDistance < 60; // Text within 60px could be related
-          }
-          return false;
-        });
-        
-        if (nearbyText) {
-          elem.associatedText = nearbyText.label;
-          elem.distance *= 0.6; // Big boost for elements with associated text
-        }
-      });
-      
-      nearbyElements.sort((a, b) => a.distance - b.distance);
-      const bestNearby = nearbyElements[0];
-      
-      // Build enhanced strategies with sibling info
-      bestNearby.locatorStrategies = [];
-      this.buildEnhancedLocatorStrategies(bestNearby);
-      
-      return bestNearby;
-    }
-    
-    return null;
-  }
-
-  // Enhanced strategy building with sibling detection for better accuracy
-  buildEnhancedLocatorStrategies(element) {
-    const strategies = [];
-    
-    // Strategy 1: Direct element locators (highest priority)
-    if (element.accessibilityId && element.accessibilityId !== 'Unlabeled') {
-      strategies.push({
-        strategy: 'accessibility id',
-        value: element.accessibilityId,
-        priority: 1
-      });
-    }
-    
-    if (element.label && element.label !== 'Unlabeled' && element.label !== element.accessibilityId) {
-      strategies.push({
-        strategy: 'name',
-        value: element.label,
-        priority: 2
-      });
-    }
-    
-    // Strategy 2: Use associated text if available (very good accuracy)
-    if (element.associatedText) {
-      strategies.push({
-        strategy: 'name',
-        value: element.associatedText,
-        priority: 1.5 // Between accessibility id and direct label
-      });
-      
-      // Also try accessibility id with associated text
-      strategies.push({
-        strategy: 'accessibility id',
-        value: element.associatedText,
-        priority: 1.5
-      });
-    }
-    
-    // Strategy 3: Class name (lower priority)
-    if (element.type) {
-      strategies.push({
-        strategy: 'class name',
-        value: element.type,
-        priority: 5
-      });
-    }
-    
-    // Sort by priority (lower number = higher priority)
-    strategies.sort((a, b) => a.priority - b.priority);
-    
-    // Store the locator strategies on the element
-    element.locatorStrategies = strategies;
-    
-    return strategies;
-  }
-
-  // Enhanced strategy building with sibling detection for better accuracy
-  buildFastLocatorStrategies(element) {
-    const strategies = [];
-    
-    // Strategy 1: Direct element locators
-    
-    // Strategy 1: Direct element locators
-    if (element.accessibilityId && element.accessibilityId !== 'Unlabeled') {
-      strategies.push({
-        strategy: 'accessibility id',
-        value: element.accessibilityId,
-        priority: 1
-      });
-    }
-    
-    if (element.label && element.label !== 'Unlabeled' && element.label !== element.accessibilityId) {
-      strategies.push({
-        strategy: 'name',
-        value: element.label,
-        priority: 2
-      });
-    }
-    
-    // Strategy 2: Class name (lower priority)
-    if (element.type) {
-      strategies.push({
-        strategy: 'class name',
-        value: element.type,
-        priority: 5
-      });
-    }
-    
-    // Strategy 3: Sibling-based strategies for better accuracy
-    const siblingStrategies = this.buildSiblingStrategies(element);
-    strategies.push(...siblingStrategies);
-    
-    element.locatorStrategies = strategies;
-  }
-  
-  // Build sibling-based locator strategies
-  buildSiblingStrategies(element) {
-    const strategies = [];
-    
-    // Find nearby labeled elements that can help identify this element
-    const nearbyElements = this.cachedElements.filter(elem => {
-      if (elem === element) return false;
-      
-      const dx = Math.abs(elem.centerX - element.centerX);
-      const dy = Math.abs(elem.centerY - element.centerY);
-      const distance = Math.sqrt(dx * dx + dy * dy);
-      
-      // Look for nearby elements with good labels
-      return distance <= 100 && elem.label && elem.label !== 'Unlabeled' && elem.label.length > 2;
-    });
-    
-    // Create sibling-based strategies
-    for (const sibling of nearbyElements.slice(0, 3)) { // Limit to 3 for performance
-      if (sibling.accessibilityId && sibling.accessibilityId !== 'Unlabeled') {
-        // Create XPath strategy using sibling
-        const xpath = this.buildSiblingXPath(element, sibling);
-        if (xpath) {
-          strategies.push({
-            strategy: 'xpath',
-            value: xpath,
-            priority: 3,
-            siblingBased: true,
-            siblingLabel: sibling.label
-          });
-        }
-      }
-    }
-    
-    return strategies;
-  }
-  
-  // Build XPath using sibling elements
-  buildSiblingXPath(targetElement, siblingElement) {
-    try {
-      // Simple sibling-based XPath strategies
-      if (siblingElement.accessibilityId) {
-        // Target element following sibling
-        const siblingClass = siblingElement.type.replace('XCUIElementType', '');
-        const targetClass = targetElement.type.replace('XCUIElementType', '');
-        
-        // Try "following" axis
-        return `//XCUIElementType${siblingClass}[@name="${siblingElement.accessibilityId}"]/following::XCUIElementType${targetClass}[1]`;
-      }
-    } catch (error) {
-      this.logger.debug(`Sibling XPath creation failed: ${error.message}`);
-    }
-    
-    return null;
-  }
-
-  // Enhanced strategy building with siblings - called only when broadcasting to followers
-  buildEnhancedLocatorStrategies(element, clickX, clickY) {
-    // Start with fast strategies
-    this.buildFastLocatorStrategies(element);
-    
-    // Add sibling strategies only if we don't have good direct strategies
-    const hasGoodDirectStrategy = element.locatorStrategies.some(s => 
-      s.strategy === 'accessibility id' || (s.strategy === 'name' && s.value.length > 3)
-    );
-    
-    if (!hasGoodDirectStrategy) {
-      // Only do expensive sibling detection when needed
-      const siblings = this.findSiblingElements(element, clickX, clickY);
-      
-      siblings.forEach((sibling, index) => {
-        const siblingLabel = sibling.element.label;
-        if (siblingLabel && siblingLabel !== 'Unlabeled' && siblingLabel.length > 2) {
-          
-          // Simple sibling strategies (avoid complex XPath)
-          element.locatorStrategies.push({
-            strategy: 'accessibility id',
-            value: siblingLabel,
-            priority: 4 + index,
-            siblingBased: true,
-            siblingLabel: siblingLabel
-          });
-          
-          // Only add XPath for very short, common labels
-          if (siblingLabel.length < 15) {
-            element.locatorStrategies.push({
-              strategy: 'xpath',
-              value: `//*[contains(@label, '${siblingLabel}')]`,
-              priority: 6 + index,
-              siblingBased: true,
-              siblingLabel: siblingLabel
-            });
-          }
-        }
-      });
-      
-      // Log sibling enhancement
-      const siblingStrategies = element.locatorStrategies.filter(s => s.siblingBased);
-      if (siblingStrategies.length > 0) {
-        this.logger.info(`🔗 Enhanced with ${siblingStrategies.length} sibling strategies: ${siblingStrategies.map(s => s.siblingLabel).join(', ')}`);
-      }
-    }
-    
-    // Limit to top 4 strategies for speed
-    element.locatorStrategies = element.locatorStrategies
-      .sort((a, b) => a.priority - b.priority)
-      .slice(0, 4);
-  }
-
-  // Find sibling elements that might provide better locators
-  findSiblingElements(element, clickX, clickY) {
-    const siblings = [];
-    const searchRadius = 100; // Search area around the element
-    
-    // Look for text elements near the clicked element
-    this.cachedElements.forEach(candidate => {
-      if (candidate === element) return; // Skip self
-      
-      // Calculate distance between elements (not click point)
-      const dx = Math.abs(candidate.centerX - element.centerX);
-      const dy = Math.abs(candidate.centerY - element.centerY);
-      const distance = Math.sqrt(dx * dx + dy * dy);
-      
-      if (distance <= searchRadius) {
-        // Prefer StaticText elements with meaningful labels
-        if (candidate.type.includes('StaticText') && 
-            candidate.label && 
-            candidate.label !== 'Unlabeled' && 
-            candidate.label.length > 2) {
-          
-          // Check if it's likely a label for this element (vertical or horizontal alignment)
-          const isVerticallyAligned = Math.abs(candidate.centerX - element.centerX) < 30;
-          const isHorizontallyAligned = Math.abs(candidate.centerY - element.centerY) < 20;
-          const isNearby = distance < 60;
-          
-          if ((isVerticallyAligned || isHorizontallyAligned) && isNearby) {
-            siblings.push({
-              element: candidate,
-              distance: distance,
-              relationship: isVerticallyAligned ? 'vertical' : 'horizontal'
-            });
-          }
-        }
-      }
-    });
-    
-    // Sort siblings by distance and return best ones
-    return siblings.sort((a, b) => a.distance - b.distance).slice(0, 3);
-  }
-
-  async executeOnFollowerWithLocators(follower, locators, fallbackX, fallbackY) {
-    // Use session lock to prevent concurrent WDA access
-    return this.withSessionLock(follower.name, async () => {
-      return this._executeOnFollowerWithLocators(follower, locators, fallbackX, fallbackY);
-    });
-  }
-
-  async _executeOnFollowerWithLocators(follower, locators, fallbackX, fallbackY) {
-    const axios = require('axios');
-    const followerPort = follower.port || 8100;
-    
-    // OPTIMIZATION: Build enhanced strategies with siblings only when needed for followers
-    if (locators && locators.element) {
-      // Start with fast strategies only
-      this.buildFastLocatorStrategies(locators.element);
-      // Update locators with basic strategies first
-      locators.locatorStrategies = locators.element.locatorStrategies;
-    }
-    
-    this.logger.info('');
-    this.logger.info(`   📲 Processing follower: ${follower.name}`);
-    
-    // GENIUS: Use global session approach - get session from connectedDevices
-    let followerSessionId = null;
-    
-    // First, try to get sessionId from the follower object itself (may be wdaSessionId for iOS)
-    if (follower.wdaSessionId) {
-      followerSessionId = follower.wdaSessionId;
-      this.logger.info(`      ✓ Session found on follower object: ${followerSessionId.substring(0, 8)}...`);
-    } else if (follower.sessionId) {
-      followerSessionId = follower.sessionId;
-      this.logger.info(`      ✓ Session found on follower object: ${followerSessionId.substring(0, 8)}...`);
-    }
-    
-    // If not found on follower object, find the follower in global connectedDevices array
-    if (!followerSessionId) {
-      this.logger.info(`      - Checking global connectedDevices...`);
-      const globalDevice = this.connectedDevices.find(d => d.name === follower.name || d.udid === follower.udid);
-      if (globalDevice) {
-        // Check both sessionId (Android) and wdaSessionId (iOS)
-        followerSessionId = globalDevice.wdaSessionId || globalDevice.sessionId;
-        if (followerSessionId) {
-          this.logger.info(`      ✓ Session found in global devices: ${followerSessionId.substring(0, 8)}...`);
-        }
-      }
-    }
-    
-    // If no global session, try to get from WDA status endpoint
-    if (!followerSessionId) {
-      this.logger.info(`      - Querying WDA /status endpoint on port ${followerPort}...`);
-      try {
-        const followerStatusRes = await axios.get(`http://localhost:${followerPort}/status`, { timeout: 2000 });
-        followerSessionId = followerStatusRes.data?.sessionId || followerStatusRes.data?.value?.sessionId;
-        
-        // If we found a session, store it globally for reuse
-        if (followerSessionId) {
-          this.logger.info(`      ✓ Session obtained from /status: ${followerSessionId.substring(0, 8)}...`);
-          const globalDevice = this.connectedDevices.find(d => d.name === follower.name);
-          if (globalDevice) {
-            if (follower.platform === 'ios') {
-              globalDevice.wdaSessionId = followerSessionId;
-            } else {
-              globalDevice.sessionId = followerSessionId;
-            }
-          }
-        }
-      } catch (error) {
-        this.logger.error(`      ✗ Failed to get session from /status: ${error.message}`);
-        return;
-      }
-    }
-    
-    if (!followerSessionId) {
-      this.logger.warn(`      ⚠️  No active session for follower ${follower.name}, attempting to create one...`);
-      
-      // Last resort: Try to create a new session for the follower
-      try {
-        this.logger.info(`      🔧 Creating new WDA session for follower ${follower.name}...`);
-        const sessionResponse = await axios.post(`http://localhost:${followerPort}/session`, {
-          capabilities: {
-            alwaysMatch: {},
-            firstMatch: [{}]
-          }
-        }, { timeout: 10000 });
-        
-        followerSessionId = sessionResponse.data?.sessionId || sessionResponse.data?.value?.sessionId;
-        if (followerSessionId) {
-          this.logger.info(`      ✅ Created new session for follower: ${followerSessionId.substring(0, 8)}...`);
-          
-          // Store the session
-          if (follower.platform === 'ios') {
-            follower.wdaSessionId = followerSessionId;
-          } else {
-            follower.sessionId = followerSessionId;
-          }
-          
-          // Store in global connectedDevices and session manager
-          const globalDevice = this.connectedDevices.find(d => d.name === follower.name);
-          if (globalDevice) {
-            if (follower.platform === 'ios') {
-              globalDevice.wdaSessionId = followerSessionId;
-            } else {
-              globalDevice.sessionId = followerSessionId;
-            }
-          }
-          
-          // Register with global session manager if available
-          if (global.sessionManager && follower.udid) {
-            global.sessionManager.registerSession(follower.udid, followerSessionId, followerPort, follower.name, null, follower.platform);
-          }
-        } else {
-          this.logger.error(`      ✗ Failed to create session - no sessionId in response`);
-          return;
-        }
-      } catch (createError) {
-        this.logger.error(`      ✗ Failed to create session for follower: ${createError.message}`);
-        return;
-      }
-    }
-    
-    this.logger.info(`      📱 Using WDA session: ${followerSessionId.substring(0, 8)}... on port ${followerPort}`);
-    
-    // Validate session is still active before trying locators
-    try {
-      this.logger.info(`      ✓ Validating WDA session is active...`);
-      const statusCheck = await axios.get(`http://localhost:${followerPort}/status`, { timeout: 2000 });
-      if (statusCheck.data?.sessionId !== followerSessionId) {
-        this.logger.warn(`      ⚠️  Session ID mismatch - WDA has different session now`);
-        this.logger.warn(`         Expected: ${followerSessionId.substring(0, 8)}...`);
-        this.logger.warn(`         Current:  ${statusCheck.data?.sessionId?.substring(0, 8)}...`);
-        
-        // Update to the current active session
-        followerSessionId = statusCheck.data?.sessionId;
-        if (follower.platform === 'ios') {
-          follower.wdaSessionId = followerSessionId;
-        } else {
-          follower.sessionId = followerSessionId;
-        }
-        this.logger.info(`      ✓ Updated to current session: ${followerSessionId.substring(0, 8)}...`);
-        
-        // Try to sync follower to same app as commander
-        try {
-          // Get commander's current app
-          const commanderPort = this.commanderDevice.port || 8100;
-          const commanderSessionId = this.getWDASessionId();
-          
-          if (commanderSessionId) {
-            const commanderAppRes = await axios.get(`http://localhost:${commanderPort}/session/${commanderSessionId}/wda/activeAppInfo`, { timeout: 3000 });
-            const commanderAppId = commanderAppRes.data?.value?.bundleId;
-            
-            if (commanderAppId && commanderAppId !== 'com.apple.springboard') {
-              this.logger.info(`      🔄 Syncing follower to commander app: ${commanderAppId}`);
-              await axios.post(`http://localhost:${followerPort}/session/${followerSessionId}/wda/apps/launch`, {
-                bundleId: commanderAppId
-              }, { timeout: 20000 }); // Increased from 15s to 20s for app launch
-              
-              // Wait longer for app to load and stabilize
-              await new Promise(resolve => setTimeout(resolve, 3000)); // Increased from 1.5s to 3s
-              this.logger.info(`      ✅ Follower synced to ${commanderAppId}`);
-            } else {
-              this.logger.info(`      ℹ️  Commander in home screen, not syncing follower app`);
-            }
-          }
-        } catch (syncError) {
-          this.logger.warn(`      ⚠️ Could not sync follower app: ${syncError.message}`);
-        }
-      }
-    } catch (statusErr) {
-      this.logger.warn(`      ⚠️  Could not validate session: ${statusErr.message}`);
-      // Continue anyway - maybe the /status endpoint is not available
-    }
-    
-    let tapExecuted = false;
-    let sessionInvalid = false;
-    
-    // Try locator strategies in priority order
-    if (locators?.locatorStrategies && locators.locatorStrategies.length > 0) {
-      // Sort by priority
-      const strategies = [...locators.locatorStrategies].sort((a, b) => a.priority - b.priority);
-      
-      this.logger.info(`      🔎 Trying ${strategies.length} locator strategies:`);
-      
-      for (const strategy of strategies) {
-        if (tapExecuted) break;
-        
-        try {
-          const strategyDesc = strategy.siblingBased ? 
-            `${strategy.strategy}="${strategy.value}" (sibling: "${strategy.siblingLabel}")` : 
-            `${strategy.strategy}="${strategy.value}"`;
-          this.logger.info(`         [${strategy.priority}] Trying: ${strategyDesc}`);
-          
-          const elementRes = await axios.post(`http://localhost:${followerPort}/session/${followerSessionId}/element`, {
-            using: strategy.strategy,
-            value: strategy.value
-          }, { timeout: 4000 }); // Slightly increased for XPath queries
-
-          if (elementRes.data?.value) {
-            const elementId = elementRes.data.value.ELEMENT || elementRes.data.value['element-6066-11e4-a52e-4f735466cecf'];
-            const successMsg = strategy.siblingBased ? 
-              `Element found via sibling "${strategy.siblingLabel}": ${elementId.substring(0, 16)}...` :
-              `Element found: ${elementId.substring(0, 16)}...`;
-            this.logger.info(`             ✓ ${successMsg}`);
-            
-            this.logger.info(`             ⏳ Executing click...`);
-            await axios.post(`http://localhost:${followerPort}/session/${followerSessionId}/element/${elementId}/click`, {}, { timeout: 3000 });
-            
-            const clickSuccessMsg = strategy.siblingBased ?
-              `SUCCESS: Follower ${follower.name} tapped using sibling strategy (${strategy.siblingLabel})` :
-              `SUCCESS: Follower ${follower.name} tapped using ${strategy.strategy}`;
-            this.logger.info(`      ✅ ${clickSuccessMsg}`);
-            tapExecuted = true;
-          }
-        } catch (error) {
-          // Check if session is invalid (404)
-          if (error.response?.status === 404) {
-            sessionInvalid = true;
-            this.logger.warn(`         ✗ Session invalid (404 error)`);
-            this.logger.warn(`         ✗ WDA endpoint returned 404 - session may have expired`);
-            this.logger.debug(`         Response: ${JSON.stringify(error.response?.data)?.substring(0, 200)}`);
-            break; // Stop trying strategies, move to fallback
-          } else if (error.response?.status === 400) {
-            // Bad request - strategy/value might be invalid
-            this.logger.warn(`         ✗ Bad request (400) - strategy or value format invalid`);
-            this.logger.debug(`         Response: ${JSON.stringify(error.response?.data)?.substring(0, 200)}`);
-          } else if (error.code === 'ECONNREFUSED') {
-            // Can't reach WDA server
-            this.logger.error(`         ✗ ECONNREFUSED - WDA server not responding on port ${followerPort}`);
-            sessionInvalid = true;
-            break;
-          } else {
-            this.logger.debug(`         ✗ ${strategy.strategy} strategy failed: ${error.message}`);
-          }
-        }
-      }
-    } else if (locators && (locators.accessibilityId || locators.label)) {
-      // Fallback for old format
-      const strategy = locators.accessibilityId ? 'accessibility id' : 'name';
-      const value = locators.accessibilityId || locators.label;
-      
-      this.logger.info(`      🔎 Using fallback locator: ${strategy}="${value}"`);
-      
-      try {
-        const elementRes = await axios.post(`http://localhost:${followerPort}/session/${followerSessionId}/element`, {
-          using: strategy,
-          value: value
-        }, { timeout: 3000 });
-
-        if (elementRes.data?.value) {
-          const elementId = elementRes.data.value.ELEMENT || elementRes.data.value['element-6066-11e4-a52e-4f735466cecf'];
-          this.logger.info(`         ✓ Element found: ${elementId.substring(0, 16)}...`);
-          
-          this.logger.info(`         ⏳ Executing click...`);
-          await axios.post(`http://localhost:${followerPort}/session/${followerSessionId}/element/${elementId}/click`, {}, { timeout: 3000 });
-          this.logger.info(`         ✅ Tap executed!`);
-          this.logger.info(`      ✅ SUCCESS: Follower ${follower.name} tapped using ${strategy}`);
-          tapExecuted = true;
-        }
-      } catch (error) {
-        // Check if session is invalid (404)
-        if (error.response?.status === 404) {
-          sessionInvalid = true;
-          this.logger.warn(`      ✗ Session invalid (404), will use coordinate fallback`);
-        } else {
-          this.logger.debug(`      ✗ Locator-based tap failed: ${error.message}`);
-        }
-      }
-    } else {
-      this.logger.info(`      ℹ️  No locator strategies available, will use coordinate fallback`);
-    }
-    
-    // FALLBACK: If no locator worked and we have element context, try enhanced strategies
-    if (!tapExecuted && !sessionInvalid && locators?.element && locators.locatorStrategies && locators.locatorStrategies.length > 0) {
-      this.logger.info(`      🔄 Primary locators failed, trying enhanced sibling strategies...`);
-      
-      // Build enhanced strategies with siblings
-      this.buildEnhancedLocatorStrategies(locators.element, fallbackX, fallbackY);
-      const enhancedStrategies = locators.element.locatorStrategies.filter(s => s.siblingBased);
-      
-      if (enhancedStrategies.length > 0) {
-        this.logger.info(`      🔗 Trying ${enhancedStrategies.length} sibling-based strategies...`);
-        
-        for (const strategy of enhancedStrategies.slice(0, 2)) { // Limit to 2 for speed
-          if (tapExecuted) break;
-          
-          try {
-            const elementRes = await axios.post(`http://localhost:${followerPort}/session/${followerSessionId}/element`, {
-              using: strategy.strategy,
-              value: strategy.value
-            }, { timeout: 3000 });
-
-            if (elementRes.data?.value) {
-              const elementId = elementRes.data.value.ELEMENT || elementRes.data.value['element-6066-11e4-a52e-4f735466cecf'];
-              this.logger.info(`      ✅ Sibling strategy worked: ${strategy.siblingLabel}`);
-              
-              await axios.post(`http://localhost:${followerPort}/session/${followerSessionId}/element/${elementId}/click`, {}, { timeout: 3000 });
-              this.logger.info(`      ✅ SUCCESS: Enhanced locator tap executed on ${follower.name}`);
-              tapExecuted = true;
-            }
-          } catch (enhancedErr) {
-            this.logger.debug(`      ✗ Enhanced strategy failed: ${enhancedErr.message}`);
-          }
-        }
-      }
-    }
-    
-    if (!tapExecuted) {
-      try {
-        // GENIUS: Smart session recovery - avoid recreating sessions unless absolutely necessary  
-        if (sessionInvalid) {
-          this.logger.info(`      🔄 Session was invalid (404) - MUST recover before coordinate tap`);
-          
-          // Step 1: Check if WDA has any active session we can use
-          try {
-            const statusRes = await axios.get(`http://localhost:${followerPort}/status`, { timeout: 2000 });
-            const activeSession = statusRes.data?.sessionId;
-            
-            if (activeSession && activeSession !== followerSessionId) {
-              // WDA has a different session - update our reference
-              this.logger.info(`      ✅ Found active WDA session: ${activeSession.substring(0, 8)}...`);
-              followerSessionId = activeSession;
-              
-              // Update follower object  
-              if (follower.platform === 'ios') {
-                follower.wdaSessionId = activeSession;
-              } else {
-                follower.sessionId = activeSession;
-              }
-              
-              // Update global session manager
-              if (global.sessionManager) {
-                global.sessionManager.updateSession(follower.udid, activeSession);
-              }
-              
-              this.logger.info(`      ✅ Session recovered without recreation: ${activeSession.substring(0, 8)}...`);
-              
-              // Quick test to make sure it works
-              await axios.get(`http://localhost:${followerPort}/session/${activeSession}/window/size`, { timeout: 2000 });
-              this.logger.debug(`      ✓ Session validated and ready`);
-              
-            } else if (!activeSession) {
-              this.logger.error(`      ✗ Cannot proceed - WDA has no active session and creation would close apps`);
-              this.logger.warn(`      🚫 Skipping ${follower.name} to prevent app disruption`);
-              return;
-            } else {
-              this.logger.debug(`      ℹ️  Session ID matches, session should be valid now`);
-            }
-          } catch (statusError) {
-            this.logger.error(`      ✗ Cannot proceed - session is still invalid and WDA status failed`);
-            this.logger.warn(`      🚫 Skipping ${follower.name} to prevent further issues`);
-            return;
-          }
-        }
-        
-        // Coordinate fallback after session recovery
-        if (!tapExecuted && followerSessionId) {
-          // Simple coordinate validation for follower
-          let safeFallbackX = Math.round(fallbackX);
-          let safeFallbackY = Math.round(fallbackY);
-          
-          const deviceHeight = 896; // iPhone default
-          const deviceWidth = 414;
-          
-          // Basic bounds checking only
-          if (safeFallbackX < 0 || safeFallbackX > deviceWidth || safeFallbackY < 0 || safeFallbackY > deviceHeight) {
-            this.logger.warn(`⚠️ FOLLOWER: Coordinates outside device bounds, clamping: (${safeFallbackX}, ${safeFallbackY})`);
-            safeFallbackX = Math.max(10, Math.min(safeFallbackX, deviceWidth - 10));
-            safeFallbackY = Math.max(50, Math.min(safeFallbackY, deviceHeight - 100));
-          }
-          
-          this.logger.info(`      🎯 Fallback: Using coordinate-based tap at (${safeFallbackX}, ${safeFallbackY})`);
-          this.logger.info(`         Session: ${followerSessionId.substring(0, 8)}...`);
-          
-          try {
-            await axios.post(`http://localhost:${followerPort}/session/${followerSessionId}/actions`, {
-              actions: [{
-                type: 'pointer',
-                id: 'finger1',
-                parameters: { pointerType: 'touch' },
-                actions: [
-                  { type: 'pointerMove', duration: 0, x: safeFallbackX, y: safeFallbackY },
-                  { type: 'pointerDown', button: 0 },
-                  { type: 'pause', duration: 100 },
-                  { type: 'pointerUp', button: 0 }
-                ]
-              }]
-            }, { timeout: 15000 });
-            this.logger.info(`      ✅ SUCCESS: Fallback tap executed on ${follower.name}`);
-          } catch (fallbackErr) {
-            if (fallbackErr.response?.status === 404) {
-              this.logger.error(`      ✗ FAILED: Coordinate tap got 404 - session is still invalid`);
-              this.logger.error(`         Port: ${followerPort}, Session: ${followerSessionId.substring(0, 8)}...`);
-            } else {
-              this.logger.error(`      ✗ FAILED: Coordinate tap failed: ${fallbackErr.message}`);
-            }
-          }
-        }
-      } catch (error) {
-        this.logger.error(`      ✗ FAILED: Follower ${follower.name} tap execution failed: ${error.message}`);
-      }
-    }
-  }
-
-  async addFollower(deviceName, deviceInfo) {
-    if (!this.isActive) {
-      throw new Error('Commander mode is not active');
-    }
-
-    // FIXED: Prevent duplicate followers - check if follower already exists
-    const existingFollower = Array.from(this.followerDevices).find(f => f.name === deviceName);
-    if (existingFollower) {
-      this.logger.info(`✓ Follower ${deviceName} already exists, skipping duplicate addition`);
-      return {
-        success: true,
-        follower: deviceName,
-        totalFollowers: this.followerDevices.size,
-        isDuplicate: true
-      };
-    }
-
-    const followerDevice = {
-      name: deviceName,
-      ...deviceInfo
-    };
-
-    // For Android devices, ensure session info is loaded and cache screenshot URL
-    if (deviceInfo.platform === 'android') {
-      // GENIUS: Use sessionManager for reliable session lookup
-      const session = global.sessionManager?.getSession(followerDevice) || global.androidSessions?.get(deviceInfo.udid);
-      
-      if (session && session.port && session.sessionId) {
-        followerDevice.port = session.port;
-        followerDevice.sessionId = session.sessionId;
-        
-        // Pre-cache screenshot URL for instant mirroring
-        followerDevice._cachedPort = session.port;
-        followerDevice._cachedScreenshotUrl = `http://localhost:${session.port}/wd/hub/session/${session.sessionId}/screenshot`;
-        
-        this.logger.info(`✅ Android follower session found and cached: port ${session.port}, sessionId ${session.sessionId.substring(0, 8)}...`);
-      } else {
-        this.logger.warn(`⚠️  No UIAutomator2 session found for Android follower ${deviceName}`);
-      }
-    }
-    // For iOS devices, check for existing WDA session and cache screenshot URL
-    else if (deviceInfo.platform === 'ios') {
-      await this.checkFollowerWDASession(followerDevice);
-      
-      // Pre-cache iOS screenshot URL if port is available
-      if (followerDevice.port) {
-        followerDevice._cachedPort = followerDevice.port;
-        followerDevice._cachedScreenshotUrl = `http://localhost:${followerDevice.port}/screenshot`;
-        this.logger.info(`✅ iOS follower screenshot URL cached: ${followerDevice.name}:${followerDevice.port}`);
-      }
-    }
-
-    this.followerDevices.add(followerDevice);
-    this.logger.info(`Follower added: ${deviceName} (${deviceInfo.platform})`);
-    this.broadcastCommanderStatus();
-
-    return {
-      success: true,
-      follower: deviceName,
-      totalFollowers: this.followerDevices.size
-    };
-  }
-
-  async checkFollowerWDASession(followerDevice) {
-    const axios = require('axios');
-    const port = followerDevice.port || 8100;
-    
-    try {
-      this.logger.info(`Fast checking WDA session on follower ${followerDevice.name}...`);
-      
-      // Check /status for existing session with reduced timeout
-      const statusResponse = await axios.get(`http://localhost:${port}/status`, { timeout: 3000 }); // Reduced from 5000ms
-      const sessionId = statusResponse.data?.sessionId || statusResponse.data?.value?.sessionId;
-      
-      if (sessionId) {
-        followerDevice.wdaSessionId = sessionId;
-        followerDevice.port = port; // Ensure port is set
-        this.logger.info(`✅ Follower using existing session: ${sessionId}`);
-        return;
-      }
-      
-      // Try to get existing session from /sessions endpoint with reduced timeout
-      try {
-        const sessionsResponse = await axios.get(`http://localhost:${port}/sessions`, { timeout: 2000 }); // Reduced from 3000ms
-        const sessions = sessionsResponse.data?.value;
-        
-        if (sessions && Array.isArray(sessions) && sessions.length > 0) {
-          followerDevice.wdaSessionId = sessions[0].id;
-          followerDevice.port = port; // Ensure port is set
-          this.logger.info(`✅ Follower found session from /sessions: ${followerDevice.wdaSessionId}`);
-          return;
-        }
-      } catch (e) {
-        this.logger.debug('No sessions found at /sessions endpoint for follower');
-      }
-      
-      // Try alternative port quickly if first port failed
-      if (port === 8100) {
-        const altPort = 8101;
-        try {
-          this.logger.debug(`Trying alternative port ${altPort} for follower ${followerDevice.name}...`);
-          const altStatusResponse = await axios.get(`http://localhost:${altPort}/status`, { timeout: 2000 });
-          const altSessionId = altStatusResponse.data?.sessionId || altStatusResponse.data?.value?.sessionId;
-          
-          if (altSessionId) {
-            followerDevice.wdaSessionId = altSessionId;
-            followerDevice.port = altPort;
-            this.logger.info(`✅ Follower found session on alternative port ${altPort}: ${altSessionId}`);
-            return;
-          }
-        } catch (altError) {
-          this.logger.debug(`Alternative port ${altPort} also failed for follower`);
-        }
-      }
-      
-      this.logger.warn(`⚠️  No existing WDA session found for follower ${followerDevice.name}`);
-      
-      // OPTIMIZATION: Create session in background to avoid blocking UI
-      this.createFollowerSessionInBackground(followerDevice, port);
-      
-      this.logger.warn(`💡 Follower will work for screen mirroring when WDA becomes available`);
-      
-    } catch (error) {
-      this.logger.warn(`⚠️  Error checking follower WDA session: ${error.message}`);
-      this.logger.warn(`💡 Follower will work for screen mirroring when session becomes available`);
-    }
-  }
-
-  /**
-   * Create follower WDA session in background without blocking startup
-   */
-  async createFollowerSessionInBackground(followerDevice, port) {
-    // Don't block the main thread - create session asynchronously
-    setTimeout(async () => {
-      try {
-        this.logger.info(`🔧 Creating WDA session for follower ${followerDevice.name} in background...`);
-        
-        const axios = require('axios');
-        const device = this.connectedDevices.find(d => d.name === followerDevice.name);
-        if (!device) {
-          throw new Error('Device not found');
-        }
-        
-        const sessionResponse = await axios.post(`http://localhost:${port}/session`, {
-          capabilities: {
-            alwaysMatch: {},
-            firstMatch: [{}]
-          }
-        }, { timeout: 10000 });
-        
-        const sessionId = sessionResponse.data?.sessionId || sessionResponse.data?.value?.sessionId;
-        if (!sessionId) {
-          throw new Error('No sessionId in response');
-        }
-        
-        // Update follower device with new session
-        followerDevice.wdaSessionId = sessionId;
-        followerDevice.port = port;
-        
-        // Pre-cache screenshot URL for instant mirroring
-        followerDevice._cachedPort = port;
-        followerDevice._cachedScreenshotUrl = `http://localhost:${port}/screenshot`;
-        
-        // Register with global session manager if available
-        if (global.sessionManager) {
-          global.sessionManager.registerSession(device.udid, sessionId, port, followerDevice.name, null, 'ios');
-        }
-        
-        // Store in global connectedDevices for persistence
-        const globalDevice = this.connectedDevices.find(d => d.name === followerDevice.name);
-        if (globalDevice) {
-          globalDevice.wdaSessionId = sessionId;
-        }
-        
-        this.logger.info(`✅ Background session created for follower: ${followerDevice.name} (${sessionId.substring(0, 8)}...)`);
-        
-        // Notify UI that follower is now fully ready
-        this.broadcast({
-          type: 'follower_session_ready',
-          deviceName: followerDevice.name,
-          sessionId: sessionId.substring(0, 8) + '...'
-        });
-        
-      } catch (sessionError) {
-        this.logger.warn(`⚠️ Background session creation failed for follower ${followerDevice.name}: ${sessionError.message}`);
-        // Retry once after 5 seconds
-        setTimeout(() => {
-          this.createFollowerSessionInBackground(followerDevice, port);
-        }, 5000);
-      }
-    }, 1000); // Start after 1 second delay to not block initial setup
-  }
-
-  removeFollower(deviceName, preserveSession = true) {
-    const follower = Array.from(this.followerDevices).find(f => f.name === deviceName);
-    if (follower) {
-      this.followerDevices.delete(follower);
-      
-      // CRITICAL: Clear any follower-specific state that might conflict with commander role
-      this.logger.info(`🧹 Removing follower: ${deviceName} (clearing follower state)`);
-      
-      // Only preserve session info if explicitly requested (for role changes, not disconnects)
-      if (preserveSession && (follower.sessionId || follower.wdaSessionId)) {
-        this.logger.info(`📝 Preserving session info from follower ${deviceName} for potential commander use`);
-        
-        // Update the device in connectedDevices with session info
-        const globalDevice = this.connectedDevices.find(d => d.name === deviceName);
-        if (globalDevice) {
-          if (follower.sessionId) globalDevice.sessionId = follower.sessionId;
-          if (follower.wdaSessionId) globalDevice.wdaSessionId = follower.wdaSessionId;
-          if (follower.port) globalDevice.port = follower.port;
-          
-          this.logger.info(`📝 Session preserved: ${globalDevice.sessionId || globalDevice.wdaSessionId}`);
-        }
-      } else if (!preserveSession) {
-        this.logger.info(`🧹 Device ${deviceName} disconnecting - not preserving session`);
-      }
-      
-      this.broadcastCommanderStatus();
-      return { success: true };
-    }
-    return { success: false, error: 'Follower not found' };
-  }
-
-  stopTouchMonitoring() {
-    this.logger.info('🛑 Stopping touch monitoring and screen streaming...');
-    
-    // Stop screen streaming
-    if (this.screenStreamInterval) {
-      clearInterval(this.screenStreamInterval);
-      this.screenStreamInterval = null;
-    }
-    
-    // Stop touch monitoring
-    if (this.touchMonitorInterval) {
-      clearInterval(this.touchMonitorInterval);
-      this.touchMonitorInterval = null;
-    }
-    
-    this.logger.info('✅ Touch monitoring stopped');
-  }
-
-  stopCommanderMode() {
-    if (!this.isActive) return { success: false };
-    
-    this.logger.info('🛑 Stopping commander mode and cleaning up...');
-    
-    this.stopTouchMonitoring();
-    
-    // Clear commander device
-    const commanderName = this.commanderDevice?.name;
-    this.commanderDevice = null;
-    
-    // Clear all followers
-    this.followerDevices.clear();
-    
-    // Reset state
-    this.isActive = false;
-    // Note: We don't reset wdaSessionId anymore - it's managed globally
-    this.cachedElements = [];
-    this.lastCacheTime = 0;
-    this.sessionId = null;
-    
-    this.broadcastCommanderStatus();
-    
-    this.logger.info(`✅ Commander mode stopped. Removed device: ${commanderName}`);
-    
-    return { 
-      success: true, 
-      removedCommander: commanderName,
-      removedFollowers: 0
-    };
-  }
-
-  async refreshLocators(fullScan = false) {
-    if (!this.isActive) {
-      throw new Error('Commander mode not active');
-    }
-    
-    this.logger.info(`🔄 ${fullScan ? 'Full' : 'Fast'} locator refresh requested`);
-    this.cachedElements = [];
-    this.lastCacheTime = 0;
-    
-    if (fullScan) {
-      await this.cacheAllElementsFullScan();
-    } else {
-      await this.cacheAllElements();
-    }
-    
-    return { 
-      success: true, 
-      elementsCount: this.cachedElements.length 
-    };
-  }
-
-  /**
-   * Background locator refresh - runs in a separate thread after locator is found
-   * This ensures UI elements stay current without blocking the current click operation
-   */
-  async refreshLocatorsInBackground() {
-    if (!this.isActive || !this.commanderDevice) {
-      this.logger.debug('⚠️ Commander not active, skipping background refresh');
-      return;
-    }
-
-    try {
-      this.logger.info('🔄 Background: Starting automatic locator refresh...');
-      
-      // Add a small delay to avoid interfering with the current operation
-      await new Promise(resolve => setTimeout(resolve, 250));
-      
-      // Check if we're not in the middle of another caching operation
-      if (this.isCaching) {
-        this.logger.debug('⚠️ Background: Caching already in progress, skipping');
-        return;
-      }
-
-      // Perform a fast refresh (not full scan) to keep it lightweight
-      const previousCount = this.cachedElements.length;
-      await this.fastCacheAllElements();
-      const newCount = this.cachedElements.length;
-      
-      this.logger.info(`✅ Background: Locators refreshed (${previousCount} → ${newCount} elements)`);
-      
-      // Broadcast refresh completion to UI if there are significant changes
-      const elementCountDiff = Math.abs(newCount - previousCount);
-      if (elementCountDiff > 5) {
-        this.broadcast({
-          type: 'locators_auto_refreshed',
-          message: `Locators auto-refreshed: ${newCount} elements available`,
-          elementsCount: newCount,
-          changeCount: elementCountDiff
-        });
-        this.logger.info(`📡 Background: Notified UI of significant changes (+/- ${elementCountDiff} elements)`);
-      }
-      
-    } catch (error) {
-      this.logger.warn(`⚠️ Background: Auto-refresh failed: ${error.message}`);
-      // Don't throw error since this is background operation
-    }
-  }
-
-  /**
-   * Schedule a background refresh - safer approach than setImmediate
-   */
-  scheduleBackgroundRefresh() {
-    if (this._refreshTimeout) {
-      clearTimeout(this._refreshTimeout);
-    }
-    
-    this.logger.info('🔄 Near locator found - scheduling auto-refresh...');
-    
-    this._refreshTimeout = setTimeout(() => {
-      this.refreshLocatorsInBackground()
-        .catch(error => {
-          this.logger.warn(`Background locator refresh failed: ${error.message}`);
-        });
-    }, 500); // Wait 500ms to avoid interfering with current click
-  }
-
-  async getAllLocatorsForInspector() {
-    // Use session lock to prevent concurrent access with click operations
-    return this.withSessionLock(this.commanderDevice?.name || 'commander', async () => {
-      return this._getAllLocatorsForInspector();
-    });
-  }
-
-  async _getAllLocatorsForInspector() {
-    // Reset session recovery flag for this call
-    this._sessionRecoveryAttempted = false;
-    
-    // Independent locator fetch for inspector - doesn't use cache
-    if (!this.isActive || !this.commanderDevice) {
-      throw new Error('Commander mode not active');
-    }
-    
-    let wdaSessionId = this.getWDASessionId();
-    
-    // If session ID is not available, try to get it from the status endpoint
-    if (!wdaSessionId && this.commanderDevice.platform === 'ios') {
-      try {
-        const axios = require('axios');
-        const port = this.commanderDevice.port || 8100;
-        const statusRes = await axios.get(`http://localhost:${port}/status`, { timeout: 3000 });
-        
-        if (statusRes.data?.sessionId) {
-          wdaSessionId = statusRes.data.sessionId;
-          this.logger.debug(`🔍 Inspector: Retrieved WDA session from /status: ${wdaSessionId}`);
-          
-          // Register this session for future use
-          global.sessionManager?.getOrRegisterSession(
-            this.commanderDevice.udid,
-            wdaSessionId,
-            port,
-            this.commanderDevice.name,
-            null,
-            'ios'
-          );
-        }
-      } catch (err) {
-        this.logger.debug(`Could not get WDA session from /status: ${err.message}`);
-      }
-    }
-    
-    // If still no session ID, we'll try to proceed anyway - the endpoint may not require it
-    if (!wdaSessionId && this.commanderDevice.platform === 'ios') {
-      this.logger.warn('⚠️  No WDA session ID available, will attempt without it');
-    }
-    
-    const startTime = Date.now();
-    this.logger.info('🔍 Inspector: Starting independent locator fetch...');
-    
-    try {
-      const axios = require('axios');
-      const device = this.commanderDevice;
-      const port = device.port || 8100;
-      const sessionId = wdaSessionId;
-
-      // Try page source method first (fastest)
-      try {
-        // Skip page source method if no session ID - it won't work
-        if (!sessionId) {
-          this.logger.debug('Skipping page source method (no session ID), will try element finding');
-          throw new Error('No session ID available');
-        }
-        
-        const sourceRes = await axios.get(
-          `http://localhost:${port}/session/${sessionId}/source`,
-          { timeout: 8000 }
-        );
-        
-        if (sourceRes.data?.value) {
-          const pageSource = sourceRes.data.value;
-          const allElements = this.parsePageSourceFast(pageSource);
-          
-          if (allElements.length > 0) {
-            const elapsed = Date.now() - startTime;
-            this.logger.info(`✅ Inspector: Loaded ${allElements.length} elements in ${elapsed}ms (page source)`);
-            
-            return {
-              success: true,
-              elements: allElements
-                .filter(e => {
-                  // Filter out overly large background elements that cover entire screen
-                  const isEntireScreen = (e.width >= 350 && e.height >= 700); // Most of screen
-                  const isContainer = e.type?.includes('View') || e.type?.includes('ScrollView') || e.type?.includes('CollectionView') || e.type?.includes('TableView');
-                  const hasNoText = !e.label && !e.name && !e.value;
-                  
-                  // Exclude large containers without useful labels
-                  if (isEntireScreen && isContainer && hasNoText) {
-                    return false;
-                  }
-                  
-                  // Exclude elements smaller than 10x10 pixels (too small to click)
-                  if (e.width < 10 || e.height < 10) {
-                    return false;
-                  }
-                  
-                  return true;
-                })
-                .map(e => ({
-                  label: e.label || e.name,
-                  type: e.type.replace('XCUIElementType', ''),
-                  x: e.x,
-                  y: e.y,
-                  width: e.width,
-                  height: e.height,
-                  centerX: e.centerX,
-                  centerY: e.centerY
-                })),
-              method: 'page_source'
-            };
-          }
-        }
-      } catch (err) {
-        // If no session ID or 404 error, session is invalid - try to recover once
-        if ((err.message === 'No session ID available' || (err.response && err.response.status === 404)) && !this._sessionRecoveryAttempted) {
-          this.logger.warn(`⚠️ Inspector: Page source failed (${err.message || 'status ' + err.response.status}), attempting recovery...`);
-          this._sessionRecoveryAttempted = true;
-          
-          try {
-            // Use smart recovery instead of full recreation 
-            const newSessionId = await this.recoverOrCreateSession(this.commanderDevice, wdaSessionId);
-            
-            if (newSessionId && newSessionId !== sessionId) {
-              this.logger.info(`✅ Inspector: Session recovered, retrying with ${newSessionId.substring(0, 8)}...`);
-              
-              // Retry page source with new session
-              const retryRes = await axios.get(
-                `http://localhost:${port}/session/${newSessionId}/source`,
-                { timeout: 8000 }
-              );
-              
-              if (retryRes.data?.value) {
-                const pageSource = retryRes.data.value;
-                const allElements = this.parsePageSourceFast(pageSource);
-                
-                if (allElements.length > 0) {
-                  const elapsed = Date.now() - startTime;
-                  this.logger.info(`✅ Inspector: Recovered ${allElements.length} elements in ${elapsed}ms (page source after recovery)`);
-                  
-                  return {
-                    success: true,
-                    elements: allElements.map(e => ({
-                      label: e.label || e.name,
-                      type: e.type.replace('XCUIElementType', ''),
-                      x: e.x,
-                      y: e.y,
-                      width: e.width,
-                      height: e.height,
-                      centerX: e.centerX,
-                      centerY: e.centerY
-                    })),
-                    method: 'page_source_recovered'
-                  };
-                }
-              }
-            }
-          } catch (recoveryErr) {
-            this.logger.error(`❌ Inspector: Page source session recovery failed: ${recoveryErr.message}`);
-          }
-        }
-        
-        this.logger.warn('Inspector: Page source failed, using element query');
-      }
-
-      // Fallback: Full element query (comprehensive)
-      const queries = [
-        { using: 'class name', value: 'XCUIElementTypeButton' },
-        { using: 'class name', value: 'XCUIElementTypeStaticText' },
-        { using: 'class name', value: 'XCUIElementTypeTextField' },
-        { using: 'class name', value: 'XCUIElementTypeCell' },
-        { using: 'class name', value: 'XCUIElementTypeImage' },
-        { using: 'class name', value: 'XCUIElementTypeSwitch' },
-        { using: 'class name', value: 'XCUIElementTypeLink' }
-      ];
-      
-      const allElements = [];
-      const MAX_ELEMENTS = 50;
-      
-      for (const query of queries) {
-        try {
-          const elementsRes = await axios.post(
-            `http://localhost:${port}/session/${sessionId}/elements`,
-            query,
-            { timeout: 5000 }
-          );
-
-          if (elementsRes.data?.value && Array.isArray(elementsRes.data.value)) {
-            const elements = elementsRes.data.value.slice(0, MAX_ELEMENTS);
-            
-            const chunkSize = 15;
-            for (let i = 0; i < elements.length; i += chunkSize) {
-              const chunk = elements.slice(i, i + chunkSize);
-              const chunkPromises = chunk.map(async (elem) => {
-                const elementId = elem.ELEMENT || elem['element-6066-11e4-a52e-4f735466cecf'];
-                if (!elementId) return null;
-                
-                try {
-                  const [rectRes, labelRes] = await Promise.all([
-                    axios.get(`http://localhost:${port}/session/${sessionId}/element/${elementId}/rect`, { timeout: 1000 }),
-                    axios.get(`http://localhost:${port}/session/${sessionId}/element/${elementId}/attribute/label`, { timeout: 1000 }).catch(() => ({ data: { value: null } }))
-                  ]);
-                  
-                  if (rectRes.data?.value) {
-                    const rect = rectRes.data.value;
-                    const label = labelRes.data?.value;
-                    
-                    if (rect.width > 3 && rect.height > 3) {
-                      return {
-                        type: query.value,
-                        label: label || 'Unlabeled',
-                        name: label || 'Unlabeled',
-                        x: Math.round(rect.x),
-                        y: Math.round(rect.y),
-                        width: Math.round(rect.width),
-                        height: Math.round(rect.height),
-                        centerX: Math.round(rect.x + rect.width / 2),
-                        centerY: Math.round(rect.y + rect.height / 2)
-                      };
-                    }
-                  }
-                } catch (err) { return null; }
-                return null;
-              });
-              
-              const chunkResults = await Promise.all(chunkPromises);
-              const validElements = chunkResults.filter(e => e !== null);
-              allElements.push(...validElements);
-            }
-          }
-        } catch (err) {
-          // If 404 error, session is invalid - try to recover once
-          if (err.response && err.response.status === 404 && !this._sessionRecoveryAttempted) {
-            this.logger.warn(`⚠️ Inspector: Session expired (404), attempting recovery...`);
-            this._sessionRecoveryAttempted = true;
-            
-            try {
-              // Use smart recovery instead of full recreation
-              const newSessionId = await this.recoverOrCreateSession(this.commanderDevice, sessionId);
-              
-              if (newSessionId && newSessionId !== sessionId) {
-                this.logger.info(`✅ Inspector: Session recovered, retrying with ${newSessionId.substring(0, 8)}...`);
-                
-                // Retry the query with new session
-                const retryRes = await axios.post(
-                  `http://localhost:${port}/session/${newSessionId}/elements`,
-                  query,
-                  { timeout: 5000 }
-                );
-                
-                if (retryRes.data?.value && Array.isArray(retryRes.data.value)) {
-                  // Process the retry results - simplified version
-                  const elements = retryRes.data.value.slice(0, MAX_ELEMENTS);
-                  for (const elem of elements.slice(0, 10)) { // Limit for quick recovery
-                    const elementId = elem.ELEMENT || elem['element-6066-11e4-a52e-4f735466cecf'];
-                    if (elementId) {
-                      try {
-                        const rectRes = await axios.get(`http://localhost:${port}/session/${newSessionId}/element/${elementId}/rect`, { timeout: 1000 });
-                        if (rectRes.data?.value && rectRes.data.value.width > 3) {
-                          const rect = rectRes.data.value;
-                          allElements.push({
-                            type: query.value,
-                            label: 'Recovered Element',
-                            name: 'Recovered Element',
-                            x: Math.round(rect.x),
-                            y: Math.round(rect.y),
-                            width: Math.round(rect.width),
-                            height: Math.round(rect.height),
-                            centerX: Math.round(rect.x + rect.width / 2),
-                            centerY: Math.round(rect.y + rect.height / 2)
-                          });
-                        }
-                      } catch (e) { /* ignore individual element errors during recovery */ }
-                    }
-                  }
-                  this.logger.info(`✅ Inspector: Recovered ${allElements.length} elements after session recovery`);
-                  continue; // Skip the normal error logging since we recovered
-                }
-              }
-            } catch (recoveryErr) {
-              this.logger.error(`❌ Inspector: Session recovery failed: ${recoveryErr.message}`);
-            }
-          }
-          
-          this.logger.warn(`Inspector query ${query.value} failed: ${err.message}`);
-        }
-      }
-      
-      const elapsed = Date.now() - startTime;
-      this.logger.info(`✅ Inspector: Loaded ${allElements.length} elements in ${elapsed}ms (element query)`);
-      
-      return {
-        success: true,
-        elements: allElements.map(e => ({
-          label: e.label || e.name,
-          type: e.type.replace('XCUIElementType', ''),
-          x: e.x,
-          y: e.y,
-          width: e.width,
-          height: e.height,
-          centerX: e.centerX,
-          centerY: e.centerY
-        })),
-        method: 'element_query'
-      };
-      
-    } catch (error) {
-      this.logger.error(`Inspector locator fetch failed: ${error.message}`);
-      throw error;
-    }
-  }
-
-  async cacheAllElementsFullScan() {
-    // Full comprehensive scan for manual refresh
-    const wdaSessionId = await this.getWDASessionId();
-    if (!wdaSessionId || !this.commanderDevice) return;
-    if (this.isCaching) return;
-    
-    this.isCaching = true;
-    const startTime = Date.now();
-    
-    try {
-      const axios = require('axios');
-      const device = this.commanderDevice;
-      const port = device.port || 8100;
-      const sessionId = wdaSessionId;
-
-      this.logger.info('🔍 Starting FULL locator scan...');
-
-      // Fast and accurate queries - back to original working set  
-      const queries = [
-        { using: 'class name', value: 'XCUIElementTypeButton' },
-        { using: 'class name', value: 'XCUIElementTypeTextField' },
-        { using: 'class name', value: 'XCUIElementTypeStaticText' }
-      ];
-      
-      const allElements = [];
-      const MAX_ELEMENTS = 100; // Full scan - more elements
-      
-      for (const query of queries) {
-        try {
-          const elementsRes = await axios.post(
-            `http://localhost:${port}/session/${sessionId}/elements`,
-            query,
-            { timeout: 3000 }
-          );
-
-          if (elementsRes.data?.value && Array.isArray(elementsRes.data.value)) {
-            const elements = elementsRes.data.value.slice(0, MAX_ELEMENTS);
-            
-            const chunkSize = 15;
-            for (let i = 0; i < elements.length; i += chunkSize) {
-              const chunk = elements.slice(i, i + chunkSize);
-              const chunkPromises = chunk.map(async (elem) => {
-                const elementId = elem.ELEMENT || elem['element-6066-11e4-a52e-4f735466cecf'];
-                if (!elementId) return null;
-                
-                try {
-                  const [rectRes, labelRes] = await Promise.all([
-                    axios.get(`http://localhost:${port}/session/${sessionId}/element/${elementId}/rect`, { timeout: 1500 }),
-                    axios.get(`http://localhost:${port}/session/${sessionId}/element/${elementId}/attribute/label`, { timeout: 1500 }).catch(() => ({ data: { value: null } }))
-                  ]);
-                  
-                  if (rectRes.data?.value) {
-                    const rect = rectRes.data.value;
-                    const label = labelRes.data?.value;
-                    
-                    // Simple fast filtering - back to original working logic
-                    if (rect.width > 3 && rect.height > 3) {
-                      return {
-                        type: query.value,
-                        label: label || 'Unlabeled',
-                        name: label || 'Unlabeled',
-                        accessibilityId: label,
-                        x: Math.round(rect.x),
-                        y: Math.round(rect.y),
-                        width: Math.round(rect.width),
-                        height: Math.round(rect.height),
-                        centerX: Math.round(rect.x + rect.width / 2),
-                        centerY: Math.round(rect.y + rect.height / 2)
-                      };
-                    }
-                  }
-                } catch (err) { return null; }
-                return null;
-              });
-              
-              const chunkResults = await Promise.all(chunkPromises);
-              const validElements = chunkResults.filter(e => e !== null);
-              
-              if (validElements.length > 0) {
-                allElements.push(...validElements);
-                
-                // Send progress updates
-                this.broadcast({
-                  type: 'cached_elements',
-                  elements: validElements.map(e => ({
-                    label: e.label || e.name,
-                    type: e.type.replace('XCUIElementType', ''),
-                    x: e.x,
-                    y: e.y,
-                    width: e.width,
-                    height: e.height
-                  })),
-                  total: allElements.length,
-                  timestamp: Date.now()
-                });
-              }
-            }
-          }
-        } catch (err) { 
-          this.logger.warn(`Full scan query ${query.value} failed: ${err.message}`);
-        }
-      }
-      
-      this.cachedElements = allElements;
-      this.lastCacheTime = Date.now();
-
-      const elapsed = Date.now() - startTime;
-      this.logger.info(`✅ Full scan completed: ${allElements.length} elements in ${elapsed}ms`);
-      
-    } finally {
-      this.isCaching = false;
-    }
-  }
-
-  broadcastCommanderStatus() {
-    // CRITICAL FIX: Proper null safety checks
-    const commanderName = this.isActive && this.commanderDevice?.name ? this.commanderDevice.name : null;
-    
-    // Debug logging to verify device name casing
-    if (commanderName) {
-      this.logger.info(`📡 Broadcasting commander status for device: "${commanderName}"`);
-    }
-    
-    const status = {
-      type: 'commander_status',
-      isActive: this.isActive,
-      commander: commanderName,
-      followers: Array.from(this.followerDevices || []).map(f => ({
-        deviceId: f?.name || 'unknown',
-        name: f?.name || 'unknown',
-        platform: f?.platform || 'unknown',
-        port: f?.port || 0
-      })),
-      followerCount: this.followerDevices ? this.followerDevices.size : 0,
-      sessionId: this.sessionId
-    };
-    this.broadcast(status);
-  }
-
-  broadcast(message) {
-    if (this.wss?.clients) {
-      this.wss.clients.forEach(client => {
-        if (client.readyState === 1) client.send(JSON.stringify(message));
-      });
-    }
-  }
-
-  async executeAppAction(appAction, appId) {
-    const results = [];
-    
-    // Execute on commander device first
-    if (this.commanderDevice) {
-      try {
-        if (this.commanderDevice.platform === 'ios') {
-          // iOS commander app control via WDA
-          const session = await this.getWDASessionId();
-          if (session) {
-            const wdaUrl = `http://localhost:${this.commanderDevice.port || 8100}/session/${session}`;
-            const axios = require('axios');
-            
-            switch (appAction) {
-              case 'openApp':
-              case 'launchApp':
-                await axios.post(`${wdaUrl}/wda/apps/launch`, { bundleId: appId });
-                break;
-              case 'closeApp':
-              case 'terminateApp':
-                await axios.post(`${wdaUrl}/wda/apps/terminate`, { bundleId: appId });
-                break;
-              case 'activateApp':
-                await axios.post(`${wdaUrl}/wda/apps/activate`, { bundleId: appId });
-                break;
-            }
-            results.push({ device: this.commanderDevice.name, success: true });
-            this.logger.info(`✅ App action ${appAction} executed on commander: ${this.commanderDevice.name}`);
-          }
-        } else if (this.commanderDevice.platform === 'android') {
-          // Android commander app control via UIAutomator2
-          const session = sessionManager.getByName(this.commanderDevice.name);
-          if (session?.sessionId && session?.port) {
-            const axios = require('axios');
-            const baseUrl = `http://localhost:${session.port}/session/${session.sessionId}`;
-            
-            switch (appAction) {
-              case 'openApp':
-              case 'launchApp':
-                await axios.post(`${baseUrl}/appium/device/activate_app`, { 
-                  json: { appId: appId } 
-                });
-                break;
-              case 'closeApp':
-              case 'terminateApp':
-                await axios.post(`${baseUrl}/appium/device/terminate_app`, { 
-                  json: { appId: appId } 
-                });
-                break;
-            }
-            results.push({ device: this.commanderDevice.name, success: true });
-            this.logger.info(`✅ App action ${appAction} executed on commander: ${this.commanderDevice.name}`);
-          }
-        }
-      } catch (error) {
-        this.logger.error(`❌ App action ${appAction} failed on commander: ${error.message}`);
-        results.push({ device: this.commanderDevice.name, success: false, error: error.message });
-      }
-    }
-    
-    // Broadcast to followers
-    if (this.followerDevices.size > 0) {
-      const broadcastResult = await this.broadcastCommand({
-        action: 'app-control',
-        appAction: appAction,
-        appId: appId
-      });
-      results.push(...broadcastResult.results || []);
-    }
-    
-    return {
-      success: true,
-      results: results,
-      executedOn: results.length
-    };
-  }
-
-  async broadcastCommand(commandData) {
-    if (!this.isActive || this.followerDevices.size === 0) {
-      this.logger.info('No followers to broadcast to');
-      return { success: true, broadcastCount: 0 };
-    }
-
-    this.logger.info(`📢 Broadcasting command to ${this.followerDevices.size} followers`);
-    
-    const results = [];
-    
-    for (const follower of this.followerDevices) {
-      try {
-        if (commandData.action === 'app-control') {
-          // Handle app control commands for followers
-          const { appAction, appId } = commandData;
-          
-          if (follower.platform === 'ios') {
-            // iOS follower app control via WDA
-            const session = this.checkFollowerWDASession(follower);
-            if (session?.sessionId) {
-              const wdaUrl = `http://localhost:${follower.port || 8100}/session/${session.sessionId}`;
-              const axios = require('axios');
-              
-              switch (appAction) {
-                case 'openApp':
-                case 'launchApp':
-                  await axios.post(`${wdaUrl}/wda/apps/launch`, { bundleId: appId });
-                  break;
-                case 'closeApp':
-                case 'terminateApp':
-                  await axios.post(`${wdaUrl}/wda/apps/terminate`, { bundleId: appId });
-                  break;
-                case 'activateApp':
-                  await axios.post(`${wdaUrl}/wda/apps/activate`, { bundleId: appId });
-                  break;
-              }
-            }
-          } else if (follower.platform === 'android') {
-            // Android follower app control via UIAutomator2
-            const session = await this.getAndroidSession(follower);
-            if (session?.sessionId && session?.port) {
-              const axios = require('axios');
-              const baseUrl = `http://localhost:${session.port}/session/${session.sessionId}`;
-              
-              switch (appAction) {
-                case 'openApp':
-                case 'launchApp':
-                  await axios.post(`${baseUrl}/appium/device/activate_app`, { 
-                    json: { appId: appId } 
-                  });
-                  break;
-                case 'closeApp':
-                case 'terminateApp':
-                  await axios.post(`${baseUrl}/appium/device/terminate_app`, { 
-                    json: { appId: appId } 
-                  });
-                  break;
-              }
-            }
-          }
-          
-          results.push({ device: follower.name, success: true });
-          this.logger.info(`✅ App control broadcast to ${follower.name}: ${appAction} ${appId}`);
-        } else {
-          // Handle general commands (home, swipe, etc.) by using shell scripts
-          const command = commandData.action;
-          this.logger.info(`📢 Broadcasting command '${command}' to follower ${follower.name} via shell script`);
-          
-          // Use the existing executeCommand function that calls shell scripts
-          // This is the same system that /api/execute uses
-          const { spawn } = require('child_process');
-          const executeCommand = require('util').promisify(require('child_process').exec);
-          
-          try {
-            // Get the correct script path based on platform and connection type
-            let scriptPath;
-            if (follower.platform === 'ios') {
-              scriptPath = follower.connectionType === 'wireless' 
-                ? './connect_ios_wireless_multi_final.sh'
-                : './connect_ios_usb_multi_final.sh';
-            } else if (follower.platform === 'android') {
-              scriptPath = follower.connectionType === 'wireless'
-                ? './connect_android_wireless_multi_final.sh' 
-                : './connect_android_usb_multi_final.sh';
-            }
-            
-            if (scriptPath) {
-              // Execute command on follower using the same shell script system
-              const result = await executeCommand(`${scriptPath} "${follower.name}" "${command}"`);
-              this.logger.info(`✅ Command '${command}' broadcast to follower ${follower.name}`);
-              results.push({ device: follower.name, success: true });
-            } else {
-              throw new Error(`No script found for platform: ${follower.platform}`);
-            }
-          } catch (error) {
-            this.logger.error(`❌ Failed to broadcast command '${command}' to ${follower.name}: ${error.message}`);
-            results.push({ device: follower.name, success: false, error: error.message });
-          }
-        }
-      } catch (error) {
-        this.logger.error(`❌ Failed to broadcast to ${follower.name}: ${error.message}`);
-        results.push({ device: follower.name, success: false, error: error.message });
-      }
-    }
-    
-    const successCount = results.filter(r => r.success).length;
-    this.logger.info(`📢 Broadcast complete: ${successCount}/${results.length} followers updated`);
-    
-    return { 
-      success: true, 
-      broadcastCount: successCount,
-      results 
-    };
-  }
-
-  /**
-   * GENIUS: Get specific device window size for coordinate scaling with caching
-   */
-  async getDeviceWindowSizeForScaling(deviceName, port) {
-    // Check cache first
-    const cacheKey = `${deviceName}:${port}`;
-    const cached = this.deviceSizeCache.get(cacheKey);
-    if (cached && (Date.now() - cached.timestamp) < 30000) { // Cache for 30 seconds
-      this.logger.debug(`📦 Using cached size for ${deviceName}: ${cached.size.width}×${cached.size.height}`);
-      return cached.size;
-    }
-
-    try {
-      const session = global.sessionManager?.getByName(deviceName);
-      if (!session?.sessionId) {
-        this.logger.warn(`⚠️ No session found for device: ${deviceName}`);
-        return null;
-      }
-
-      const response = await axios.get(`http://localhost:${port}/session/${session.sessionId}/window/size`, { 
-        timeout: 3000 
-      });
-      
-      if (response.data?.value) {
-        const size = response.data.value;
-        this.logger.debug(`📱 Device ${deviceName} window size: ${size.width}×${size.height}`);
-        
-        // Cache the result
-        this.deviceSizeCache.set(cacheKey, {
-          size: size,
-          timestamp: Date.now()
-        });
-        
-        return size;
-      }
-    } catch (error) {
-      this.logger.warn(`⚠️ Failed to get window size for ${deviceName}: ${error.message}`);
-    }
-    return null;
-  }
-
-  /**
-   * GENIUS: Scale coordinates from commander to follower device
-   */
-  scaleCoordinatesForDevice(commanderCoords, commanderSize, followerSize) {
-    if (!commanderSize || !followerSize) {
-      this.logger.warn(`⚠️ Missing device sizes for coordinate scaling`);
-      return commanderCoords; // Fallback to original coordinates
-    }
-
-    // Prevent division by zero
-    if (commanderSize.width === 0 || commanderSize.height === 0) {
-      this.logger.warn(`⚠️ Invalid commander size: ${commanderSize.width}×${commanderSize.height}`);
-      return commanderCoords;
-    }
-
-    const scaleX = followerSize.width / commanderSize.width;
-    const scaleY = followerSize.height / commanderSize.height;
-    
-    const scaledX = Math.round(commanderCoords.x * scaleX);
-    const scaledY = Math.round(commanderCoords.y * scaleY);
-    
-    // Ensure coordinates are within bounds
-    const boundedX = Math.max(0, Math.min(scaledX, followerSize.width - 1));
-    const boundedY = Math.max(0, Math.min(scaledY, followerSize.height - 1));
-    
-    this.logger.info(`📐 Coordinate scaling: ${commanderCoords.x},${commanderCoords.y} → ${boundedX},${boundedY}`);
-    this.logger.info(`   Commander: ${commanderSize.width}×${commanderSize.height}`);
-    this.logger.info(`   Follower:  ${followerSize.width}×${followerSize.height}`);
-    this.logger.info(`   Scale:     ${scaleX.toFixed(3)}×${scaleY.toFixed(3)}`);
-    
-    return { x: boundedX, y: boundedY };
-  }
-
-  // General action broadcasting (tap, type, etc.) with intelligent coordinate transformation
-  async broadcastAction({ action, locator, input, coordinates }) {
-    if (!this.isActive || this.followerDevices.size === 0) {
-      this.logger.info('No followers to broadcast action to');
-      return { success: true, broadcastCount: 0 };
-    }
-
-    this.logger.info(`📢 Broadcasting action '${action}' to ${this.followerDevices.size} followers`);
-    
-    // GENIUS: Get commander device screen size for coordinate scaling
-    let commanderSize = null;
-    if (coordinates && this.commanderDevice) {
-      const commanderPort = this.commanderDevice.port || 8100;
-      commanderSize = await this.getDeviceWindowSizeForScaling(this.commanderDevice.name, commanderPort);
-      if (commanderSize) {
-        this.logger.info(`📱 Commander screen size: ${commanderSize.width}×${commanderSize.height}`);
-      }
-    }
-    
-    const results = [];
-    const axios = require('axios');
-
-    for (const follower of this.followerDevices) {
-      try {
-        const port = follower.port || (follower.platform === 'ios' ? 8100 : 4723);
-        
-        // GENIUS: Get follower screen size and scale coordinates if needed
-        let scaledCoordinates = coordinates;
-        if (coordinates && commanderSize) {
-          const followerSize = await this.getDeviceWindowSizeForScaling(follower.name, port);
-          if (followerSize) {
-            scaledCoordinates = this.scaleCoordinatesForDevice(coordinates, commanderSize, followerSize);
-          } else {
-            this.logger.warn(`⚠️ Could not get screen size for follower ${follower.name}, using original coordinates`);
-          }
-        }
-        
-        if (follower.platform === 'ios') {
-          // iOS WebDriverAgent actions
-          // GENIUS: Get session from global manager for each follower
-          const followerSession = global.sessionManager?.getByName(follower.name);
-          const sessionId = followerSession?.sessionId || this.getWDASessionId(); // Fallback to commander's session
-          const baseUrl = `http://localhost:${port}`;
-          
-          switch (action) {
-            case 'tap':
-              if (scaledCoordinates) {
-                try {
-                  this.logger.info(`🎯 Tapping follower ${follower.name} at scaled coordinates: (${scaledCoordinates.x}, ${scaledCoordinates.y})`);
-                  await axios.post(`${baseUrl}/session/${sessionId}/wda/tap/0`, {
-                    x: scaledCoordinates.x,
-                    y: scaledCoordinates.y
-                  });
-                } catch (tapErr) {
-                  // If 404 error, follower session is invalid - try with fresh session
-                  if (tapErr.response?.status === 404) {
-                    this.logger.warn(`⚠️ Follower ${follower.name} session expired (404), attempting recovery...`);
-                    try {
-                      // Try to get a fresh session for the follower
-                      const newFollowerSession = global.sessionManager?.getByName(follower.name);
-                      const newSessionId = newFollowerSession?.sessionId;
-                      
-                      if (newSessionId && newSessionId !== sessionId) {
-                        // Retry with new session and scaled coordinates
-                        this.logger.info(`🔄 Retry tapping ${follower.name} with recovered session at: (${scaledCoordinates.x}, ${scaledCoordinates.y})`);
-                        await axios.post(`${baseUrl}/session/${newSessionId}/wda/tap/0`, {
-                          x: scaledCoordinates.x,
-                          y: scaledCoordinates.y
-                        });
-                        this.logger.info(`✅ Follower ${follower.name} tap succeeded after session recovery`);
-                      } else {
-                        throw tapErr; // Re-throw if no new session available
-                      }
-                    } catch (recoveryErr) {
-                      throw new Error(`Follower tap failed: ${recoveryErr.message}`);
-                    }
-                  } else {
-                    throw tapErr;
-                  }
-                }
-              } else if (locator) {
-                // Find element and tap
-                const elementRes = await axios.post(`${baseUrl}/session/${sessionId}/element`, {
-                  using: 'accessibility id',
-                  value: locator
-                });
-                const elementId = elementRes.data.value.ELEMENT;
-                await axios.post(`${baseUrl}/session/${sessionId}/element/${elementId}/click`);
-              }
-              break;
-
-            case 'type':
-              if (input) {
-                await axios.post(`${baseUrl}/session/${sessionId}/wda/keys`, {
-                  value: input.split('')
-                });
-              }
-              break;
-
-            case 'swipe':
-              if (scaledCoordinates && scaledCoordinates.fromX !== undefined) {
-                // Scale swipe coordinates too
-                let scaledSwipeCoords = scaledCoordinates;
-                if (coordinates && commanderSize) {
-                  const followerSize = await this.getDeviceWindowSizeForScaling(follower.name, port);
-                  if (followerSize) {
-                    scaledSwipeCoords = {
-                      fromX: Math.round(coordinates.fromX * (followerSize.width / commanderSize.width)),
-                      fromY: Math.round(coordinates.fromY * (followerSize.height / commanderSize.height)),
-                      toX: Math.round(coordinates.toX * (followerSize.width / commanderSize.width)),
-                      toY: Math.round(coordinates.toY * (followerSize.height / commanderSize.height)),
-                      duration: coordinates.duration || 0.5
-                    };
-                  }
-                }
-                
-                await axios.post(`${baseUrl}/session/${sessionId}/wda/dragfromtoforduration`, scaledSwipeCoords);
-              }
-              break;
-
-            default:
-              this.logger.warn(`Unsupported iOS action: ${action}`);
-          }
-        } else if (follower.platform === 'android') {
-          // Android UIAutomator2 actions
-          const baseUrl = `http://localhost:${port}/wd/hub`;
-          
-          switch (action) {
-            case 'tap':
-              if (scaledCoordinates) {
-                this.logger.info(`🎯 Tapping Android follower ${follower.name} at scaled coordinates: (${scaledCoordinates.x}, ${scaledCoordinates.y})`);
-                await axios.post(`${baseUrl}/session/${sessionId}/touch/click`, {
-                  element: { x: scaledCoordinates.x, y: scaledCoordinates.y }
-                });
-              } else if (locator) {
-                // Find element and tap
-                const elementRes = await axios.post(`${baseUrl}/session/${sessionId}/element`, {
-                  using: 'accessibility id',
-                  value: locator
-                });
-                const elementId = elementRes.data.value.ELEMENT;
-                await axios.post(`${baseUrl}/session/${sessionId}/element/${elementId}/click`);
-              }
-              break;
-
-            case 'type':
-              if (input) {
-                await axios.post(`${baseUrl}/session/${sessionId}/keys`, {
-                  value: [input]
-                });
-              }
-              break;
-
-            default:
-              this.logger.warn(`Unsupported Android action: ${action}`);
-          }
-        }
-        
-        results.push({ device: follower.name, success: true });
-        this.logger.info(`✅ Action '${action}' broadcast to ${follower.name}`);
-        
-      } catch (error) {
-        this.logger.error(`❌ Failed to broadcast action to ${follower.name}: ${error.message}`);
-        results.push({ device: follower.name, success: false, error: error.message });
-      }
-    }
-    
-    const successCount = results.filter(r => r.success).length;
-    this.logger.info(`📢 Action broadcast complete: ${successCount}/${results.length} followers updated`);
-    
-    return { 
-      success: true, 
-      broadcastCount: successCount,
-      results,
-      action 
-    };
-  }
-
-  /**
-   * 🎯 NEW GENIUS METHOD: Execute Intelligent Action on Follower
-   * Uses the IntelligentLocatorService to perform actions with maximum accuracy
-   */
-  async executeIntelligentActionOnFollower(follower, intelligentLocator, originalX, originalY) {
-    // Use session lock to prevent concurrent access
-    return this.withSessionLock(follower.name, async () => {
-      return this._executeIntelligentActionOnFollower(follower, intelligentLocator, originalX, originalY);
-    });
-  }
-
-  async _executeIntelligentActionOnFollower(follower, intelligentLocator, originalX, originalY) {
-    this.logger.info(`🎯 Executing intelligent action on ${follower.name} using ${intelligentLocator.method}`);
-    
-    try {
-      const startTime = Date.now();
-      
-      // OPTIMIZED: Only invalidate follower cache if commander cache was invalidated
-      // This prevents excessive cache clearing
-      if (!this.intelligentLocator.hasCachedLocators(follower.name)) {
-        this.logger.info(`🧹 Pre-invalidating locator cache for follower ${follower.name} (screen changed after commander action)`);
-        this.intelligentLocator.invalidateCache(follower.name);
-      }
-      
-      // Step 1: Execute using IntelligentLocatorService
-      const result = await this.intelligentLocator.executeIntelligentAction(
-        follower, 
-        intelligentLocator, 
-        'tap'
-      );
-      
-      const executionTime = Date.now() - startTime;
-      
-      if (result.success) {
-        this.logger.info(`✅ Intelligent action succeeded on ${follower.name} in ${executionTime}ms (method: ${result.method})`);
-        
-        // Update success metrics
-        if (result.method === 'locator') {
-          this.locatorSuccessCount++;
-        }
-        
-        // Update per-device success rate
-        const deviceRate = this.locatorSuccessRate.get(follower.name) || { success: 0, total: 0 };
-        deviceRate.success++;
-        deviceRate.total++;
-        this.locatorSuccessRate.set(follower.name, deviceRate);
-        
-        return { success: true, method: result.method, executionTime };
-        
-      } else {
-        this.logger.error(`❌ Intelligent action failed on ${follower.name}: ${result.error}`);
-        
-        // Update metrics
-        const deviceRate = this.locatorSuccessRate.get(follower.name) || { success: 0, total: 0 };
-        deviceRate.total++;
-        this.locatorSuccessRate.set(follower.name, deviceRate);
-        
-        return { success: false, error: result.error, method: result.method };
-      }
-      
-    } catch (error) {
-      this.logger.error(`❌ Intelligent follower execution failed: ${error.message}`);
-      
-      // Fallback to traditional coordinate scaling as last resort
-      this.logger.warn(`🔄 Attempting traditional coordinate fallback for ${follower.name}`);
-      
-      try {
-        // Use the existing coordinate scaling logic as fallback
-        const commanderSize = this.lastWindowSize;
-        const followerSize = await this.getDeviceWindowSizeForScaling(follower.name, follower.port || 8100);
-        
-        if (followerSize && commanderSize) {
-          const scaledCoords = this.scaleCoordinatesForDevice(
-            { x: originalX, y: originalY }, 
-            commanderSize, 
-            followerSize
-          );
-          
-          // Execute using coordinates
-          const coordResult = await this.intelligentLocator.executeCoordinateAction(
-            follower, 
-            scaledCoords, 
-            'tap'
-          );
-          
-          if (coordResult) {
-            this.logger.info(`✅ Coordinate fallback succeeded on ${follower.name}`);
-            return { success: true, method: 'coordinates_fallback' };
-          }
-        }
-        
-        throw new Error('Both intelligent and coordinate methods failed');
-        
-      } catch (fallbackError) {
-        this.logger.error(`❌ All methods failed for ${follower.name}: ${fallbackError.message}`);
-        return { success: false, error: `All methods failed: ${error.message}` };
-      }
-    }
-  }
-
-  /**
-   * 🎯 Get Intelligent Locator Performance Statistics
-   */
-  getIntelligentLocatorStats() {
-    const totalRequests = this.locatorSuccessCount + this.coordinateFallbackCount;
-    const locatorSuccessRate = totalRequests > 0 ? 
-      ((this.locatorSuccessCount / totalRequests) * 100).toFixed(1) : 0;
-    
-    const deviceStats = {};
-    for (const [deviceName, stats] of this.locatorSuccessRate.entries()) {
-      const rate = stats.total > 0 ? ((stats.success / stats.total) * 100).toFixed(1) : 0;
-      deviceStats[deviceName] = {
-        successRate: `${rate}%`,
-        successful: stats.success,
-        total: stats.total
-      };
-    }
-    
-    return {
-      overallLocatorSuccessRate: `${locatorSuccessRate}%`,
-      locatorSuccesses: this.locatorSuccessCount,
-      coordinateFallbacks: this.coordinateFallbackCount,
-      totalRequests: totalRequests,
-      deviceStats: deviceStats,
-      intelligentLocatorMetrics: this.intelligentLocator?.getPerformanceMetrics()
-    };
-  }
-
-  /**
-   * 🎯 Force Refresh Locator Cache for All Devices
-   */
-  async refreshIntelligentLocatorCache() {
-    this.logger.info('🔄 Refreshing intelligent locator cache for all devices...');
-    
-    const devices = [this.commanderDevice, ...Array.from(this.followerDevices)].filter(d => d);
-    const refreshResults = [];
-    
-    for (const device of devices) {
-      try {
-        const locators = await this.intelligentLocator.getCachedLocators(device.name, true);
-        refreshResults.push({
-          device: device.name,
-          success: true,
-          locatorCount: locators.length
-        });
-        this.logger.info(`✅ Refreshed ${locators.length} locators for ${device.name}`);
-      } catch (error) {
-        refreshResults.push({
-          device: device.name,
-          success: false,
-          error: error.message
-        });
-        this.logger.error(`❌ Failed to refresh locators for ${device.name}: ${error.message}`);
-      }
-    }
-    
-    return {
-      success: true,
-      refreshedDevices: refreshResults.filter(r => r.success).length,
-      totalDevices: refreshResults.length,
-      results: refreshResults
-    };
-  }
-
-  getStatus() {
-    const baseStatus = {
-      isActive: this.isActive,
-      commander: this.commanderDevice?.name,
-      followers: Array.from(this.followerDevices).map(f => ({
-        deviceId: f.name,
-        name: f.name,
-        platform: f.platform,
-        port: f.port
-      })),
-      followerCount: this.followerDevices.size
-    };
-    
-    // Add intelligent locator stats if available
-    if (this.useIntelligentLocators) {
-      baseStatus.intelligentLocatorStats = this.getIntelligentLocatorStats();
-    }
-    
-    return baseStatus;
-  }
-}
-
-module.exports = CommanderService;