devicely 1.0.7 → 1.0.9

package/lib/server.js.new

@@ -0,0 +1,3392 @@
+const path = require('path');
+
+// Load environment variables from .env file in project root
+require('dotenv').config({ path: path.join(__dirname, '../../.env') });
+
+const express = require('express');
+const cors = require('cors');
+const { spawn } = require('child_process');
+const WebSocket = require('ws');
+const fs = require('fs').promises;
+const AIProviderManager = require('./aiProviders');
+
+// Import deviceDetection from appropriate location (dev vs npm package)
+let discoverAllDevices;
+try {
+    // Try npm package location first (lib/)
+    ({ discoverAllDevices } = require('./deviceDetection'));
+} catch (err) {
+    // Fall back to development location
+    ({ discoverAllDevices } = require('../../deviceDetection'));
+}
+
+const { execSync } = require('child_process');
+
+const app = express();
+const PORT = process.env.PORT || 3001;
+
+// Debug mode - only show verbose logs if DEBUG=true in .env
+const DEBUG = process.env.DEBUG === 'true';
+const log = {
+  debug: (...args) => { if (DEBUG) console.log(...args); },
+  info: (...args) => console.log(...args),
+  error: (...args) => console.error(...args),
+  success: (msg) => console.log(`✅ ${msg}`),
+  warn: (msg) => console.log(`⚠️  ${msg}`)
+};
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+
+// Serve static frontend files - check both dev and npm package locations
+const frontendPath = require('fs').existsSync(path.join(__dirname, '../frontend/build'))
+  ? path.join(__dirname, '../frontend/build')
+  : path.join(__dirname, './frontend');
+  
+app.use(express.static(frontendPath));
+
+// WebSocket server
+const wss = new WebSocket.Server({ noServer: true });
+
+// AI Provider Manager - supports multiple AI providers
+const aiManager = new AIProviderManager();
+
+// Store connected devices
+let connectedDevices = [];
+let activeConnections = new Map();
+let wdaProcesses = new Map(); // Track WDA processes: Map<deviceName, {xcodebuild: pid, iproxy: pid}>
+
+// Track UIAutomator2 sessions for Android devices
+let androidSessions = new Map(); // Map<udid, {sessionId, port, serverPid}>
+
+// Helper to find config files in both dev and npm package locations
+function findConfigFile(filename) {
+  // Try development location first
+  let configPath = path.join(__dirname, '../../', filename);
+  if (require('fs').existsSync(configPath)) {
+    return configPath;
+  }
+  
+  // Try npm package location (lib/ -> config/)
+  configPath = path.join(__dirname, '../config/', filename);
+  if (require('fs').existsSync(configPath)) {
+    return configPath;
+  }
+  
+  // Fall back to dev location for creation
+  return path.join(__dirname, '../../', filename);
+}
+
+function findScriptFile(filename) {
+  // Try development location first
+  let scriptPath = path.join(__dirname, '../../', filename);
+  if (require('fs').existsSync(scriptPath)) {
+    return scriptPath;
+  }
+  
+  // Try npm package location (lib/ -> scripts/shell/)
+  // In npm package, scripts are compiled binaries without .sh extension
+  const binaryName = filename.replace('.sh', '');
+  scriptPath = path.join(__dirname, '../scripts/shell/', binaryName);
+  if (require('fs').existsSync(scriptPath)) {
+    return scriptPath;
+  }
+  
+  // Try with .sh extension as fallback
+  scriptPath = path.join(__dirname, '../scripts/shell/', filename);
+  if (require('fs').existsSync(scriptPath)) {
+    return scriptPath;
+  }
+  
+  return path.join(__dirname, '../../', filename);
+}
+
+// Device configuration paths
+const DEVICE_CONFIG = findConfigFile('devices.conf');
+// Use OS temp directory for session file - works for both local and npm package
+const SESSION_MAP_FILE = path.join(require('os').tmpdir(), 'devicely_android_sessions.map');
+const APPS_CONFIG = findConfigFile('apps_presets.conf');
+
+// iOS scripts
+const WIRELESS_SCRIPT_PATH = findScriptFile('connect_ios_wireless_multi_final.sh');
+const USB_SCRIPT_PATH = findScriptFile('connect_ios_usb_multi_final.sh');
+
+// Android scripts
+const ANDROID_WIRELESS_SCRIPT_PATH = findScriptFile('android_device_control.sh');
+const ANDROID_USB_SCRIPT_PATH = findScriptFile('android_device_control.sh');
+
+// Recording storage path
+const RECORDINGS_DIR = path.join(__dirname, '../../recordings');
+
+// Screenshots storage path
+const SCREENSHOTS_DIR = path.join(__dirname, './screenshots');
+
+// Recording state
+let currentRecording = null; // { name, devices, commands: [], startTime }
+let isRecording = false;
+
+// Replay state
+let isReplaying = false;
+let replayAborted = false;
+
+// ============================================
+// UIAutomator2 Session Management Functions
+// ============================================
+
+/**
+ * Start UIAutomator2 session for Android device
+ */
+async function startUIAutomator2Session(udid, deviceName) {
+  log.debug(`🚀 Starting UIAutomator2 session for ${deviceName} (${udid})...`);
+  
+  try {
+    // Find available port
+    let port = 8200;
+    while (true) {
+      try {
+        execSync(`lsof -i:${port}`, { stdio: 'ignore' });
+        port++; // Port is in use, try next
+      } catch {
+        break; // Port is available
+      }
+    }
+    
+    log.debug(`📡 Using port ${port} for ${deviceName}`);
+    
+    // Start UIAutomator2 server on device
+    const serverProcess = spawn('adb', ['-s', udid, 'shell', 'am', 'instrument', '-w',
+      'io.appium.uiautomator2.server.test/androidx.test.runner.AndroidJUnitRunner'
+    ], { detached: true, stdio: 'ignore' });
+    
+    serverProcess.unref(); // Don't wait for process to exit
+    
+    // Wait for server to start
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    // Forward port
+    execSync(`adb -s ${udid} forward tcp:${port} tcp:6790`);
+    log.debug(`✅ Port forwarding established: localhost:${port} -> device:6790`);
+    
+    // Wait a bit more
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    // Create session via HTTP
+    const axios = require('axios');
+    const sessionResponse = await axios.post(`http://localhost:${port}/wd/hub/session`, {
+      capabilities: {
+        alwaysMatch: {
+          platformName: 'Android',
+          'appium:automationName': 'UiAutomator2',
+          'appium:udid': udid
+        }
+      }
+    });
+    
+    const sessionId = sessionResponse.data.value.sessionId || sessionResponse.data.sessionId;
+    
+    // Store session info
+    androidSessions.set(udid, {
+      sessionId,
+      port,
+      serverPid: serverProcess.pid,
+      deviceName
+    });
+    
+    // Save to session file for scripts to use - remove old entries first
+    try {
+      let content = '';
+      try {
+        content = await fs.readFile(SESSION_MAP_FILE, 'utf-8');
+      } catch (err) {
+        // File doesn't exist yet, that's ok
+      }
+      const lines = content.split('\n').filter(line => line && !line.startsWith(`${udid}:`));
+      lines.push(`${udid}:${sessionId}:${port}`);
+      await fs.writeFile(SESSION_MAP_FILE, lines.join('\n') + '\n');
+      log.debug(`✅ Session file updated: ${udid}:${sessionId}:${port}`);
+    } catch (err) {
+      console.error(`⚠️  Failed to update session file: ${err.message}`);
+    }
+    
+    log.debug(`✅ UIAutomator2 session created for ${deviceName}`);
+    log.debug(`   Session ID: ${sessionId}`);
+    log.debug(`   Port: ${port}`);
+    
+    return { success: true, sessionId, port };
+    
+  } catch (error) {
+    console.error(`❌ Failed to start UIAutomator2 for ${deviceName}:`, error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Stop UIAutomator2 session for Android device
+ */
+async function stopUIAutomator2Session(udid, deviceName) {
+  log.debug(`🛑 Stopping UIAutomator2 session for ${deviceName} (${udid})...`);
+  
+  try {
+    const session = androidSessions.get(udid);
+    
+    if (!session) {
+      log.debug(`⚠️  No active session found for ${deviceName}`);
+      return { success: true, message: 'No active session' };
+    }
+    
+    // Delete session via HTTP
+    try {
+      const axios = require('axios');
+      await axios.delete(`http://localhost:${session.port}/wd/hub/session/${session.sessionId}`);
+      log.debug(`✅ UIAutomator2 session deleted for ${deviceName}`);
+    } catch (err) {
+      log.warn(`⚠️  Could not delete session via HTTP: ${err.message}`);
+    }
+    
+    // Remove port forwarding
+    try {
+      execSync(`adb -s ${udid} forward --remove tcp:${session.port}`);
+      log.debug(`✅ Port forwarding removed for ${deviceName}`);
+    } catch (err) {
+      console.log(`⚠️  Could not remove port forwarding: ${err.message}`);
+    }
+    
+    // Kill UIAutomator2 server on device
+    try {
+      execSync(`adb -s ${udid} shell am force-stop io.appium.uiautomator2.server`);
+      execSync(`adb -s ${udid} shell am force-stop io.appium.uiautomator2.server.test`);
+      console.log(`✅ UIAutomator2 server stopped on ${deviceName}`);
+    } catch (err) {
+      console.log(`⚠️  Could not stop UIAutomator2 server: ${err.message}`);
+    }
+    
+    // Remove from memory
+    androidSessions.delete(udid);
+    
+    // Update session file
+    try {
+      const content = await fs.readFile(SESSION_MAP_FILE, 'utf-8');
+      const lines = content.split('\n').filter(line => !line.startsWith(`${udid}:`));
+      await fs.writeFile(SESSION_MAP_FILE, lines.join('\n'));
+      log.debug(`✅ Session file updated for ${deviceName}`);
+    } catch (err) {
+      console.log(`⚠️  Could not update session file: ${err.message}`);
+    }
+    
+    console.log(`✅ UIAutomator2 session stopped for ${deviceName}`);
+    return { success: true };
+    
+  } catch (error) {
+    console.error(`❌ Error stopping UIAutomator2 for ${deviceName}:`, error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+// ============================================
+
+
+// Load device configuration
+async function loadDeviceConfig() {
+  try {
+    const content = await fs.readFile(DEVICE_CONFIG, 'utf-8');
+    const devices = content
+      .split('\n')
+      .filter(line => line.trim() && !line.startsWith('#'))
+      .map(line => {
+        const parts = line.split(',').map(s => s.trim());
+        const [name, udid, ip, platform, type] = parts;
+        
+        // Smart platform detection if not specified
+        let detectedPlatform = platform || 'ios';
+        if (!platform && udid) {
+          // Android wireless: IP:PORT format
+          if (udid.includes(':') && udid.match(/^\d+\.\d+\.\d+\.\d+:\d+$/)) {
+            detectedPlatform = 'android';
+          }
+          // Android USB: Short serial without dashes
+          else if (udid.length < 20 && !udid.includes('-')) {
+            detectedPlatform = 'android';
+          }
+          // iOS: Long UUID with dashes
+          else if (udid.includes('-') && udid.length > 30) {
+            detectedPlatform = 'ios';
+          }
+        }
+        
+        return { 
+          name, 
+          udid, 
+          ip: ip || '', 
+          platform: detectedPlatform, 
+          type: type || (ip ? 'wireless' : 'usb'),
+          status: 'unknown' 
+        };
+      });
+    return devices;
+  } catch (error) {
+    console.error('Error loading device config:', error);
+    return [];
+  }
+}
+
+// Discover and check device connectivity (USB + Wireless)
+async function discoverDevices() {
+  // Save current connection states
+  const previousStates = new Map();
+  connectedDevices.forEach(device => {
+    previousStates.set(device.udid, {
+      status: device.status,
+      sessionId: device.sessionId
+    });
+  });
+  
+  connectedDevices = await discoverAllDevices();
+  
+  // Restore connection states for devices that were previously connected
+  connectedDevices.forEach(device => {
+    const prevState = previousStates.get(device.udid);
+    if (prevState && prevState.status === 'online') {
+      // Preserve the online status for previously connected devices
+      device.status = 'online';
+      if (prevState.sessionId) {
+        device.sessionId = prevState.sessionId;
+      }
+    }
+  });
+  
+  // Auto-save USB devices to config for wireless use later
+  await autoSaveUSBDevicesToConfig(connectedDevices);
+  
+  return connectedDevices;
+}
+
+// Auto-save USB devices to config
+async function autoSaveUSBDevicesToConfig(devices) {
+  try {
+    const usbDevices = devices.filter(d => d.connectionType === 'usb');
+    if (usbDevices.length === 0) return;
+    
+    // Load existing config
+    const existingDevices = await loadDeviceConfig();
+    const existingUdids = new Set(existingDevices.map(d => d.udid));
+    
+    // Add new USB devices
+    const newDevices = usbDevices.filter(d => !existingUdids.has(d.udid));
+    if (newDevices.length === 0) return;
+    
+    // Append to config with placeholder IP (will be filled when wireless is configured)
+    const allDevices = [...existingDevices, ...newDevices.map(d => ({
+      name: d.name,
+      udid: d.udid,
+      ip: '' // Empty IP for USB devices, to be filled for wireless
+    }))];
+    
+    // Save to config
+    let content = '# Device Configuration (Auto-updated)\n';
+    content += '# Format: device_name,udid,ip_address\n';
+    content += '# USB devices auto-detected. Add IP for wireless connection.\n\n';
+    
+    allDevices.forEach(device => {
+      const ip = device.ip || '';
+      content += `${device.name},${device.udid},${ip}\n`;
+    });
+    
+    await fs.writeFile(DEVICE_CONFIG, content);
+    console.log(`✅ Auto-saved ${newDevices.length} new USB device(s) to config`);
+  } catch (error) {
+    console.error('Error auto-saving devices:', error);
+  }
+}
+
+// Check device connectivity
+function checkDeviceConnectivity(device) {
+  return new Promise((resolve) => {
+    const curl = spawn('curl', [
+      '-s',
+      '--connect-timeout', '2',
+      '--max-time', '3',
+      `http://${device.ip}:8100/status`
+    ]);
+    
+    let output = '';
+    curl.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+    
+    curl.on('close', (code) => {
+      resolve(output.includes('"state"'));
+    });
+    
+    setTimeout(() => {
+      curl.kill();
+      resolve(false);
+    }, 3000);
+  });
+}
+
+// Load app presets from config file
+function loadAppPresets() {
+  try {
+    if (!require('fs').existsSync(APPS_CONFIG)) {
+      return {};
+    }
+    
+    const content = require('fs').readFileSync(APPS_CONFIG, 'utf-8');
+    const presets = {};
+    
+    content.split('\n')
+      .filter(line => line.trim() && !line.startsWith('#'))
+      .forEach(line => {
+        const [name, packageId] = line.split(',').map(s => s.trim());
+        if (name && packageId) {
+          // Support platform-specific notation: name.ios or name.android
+          const parts = name.split('.');
+          if (parts.length === 2) {
+            const [appName, platform] = parts;
+            if (!presets[appName]) presets[appName] = {};
+            presets[appName][platform] = packageId;
+          } else {
+            // Generic app (works on both platforms)
+            if (!presets[name]) presets[name] = {};
+            presets[name].common = packageId;
+          }
+        }
+      });
+    
+    return presets;
+  } catch (error) {
+    console.error('Error loading app presets:', error);
+    return {};
+  }
+}
+
+// Resolve app preset based on device platform
+function resolveAppPreset(command, platform) {
+  const appPresets = loadAppPresets();
+  
+  // Check if command is "launch <appname>"
+  const launchMatch = command.match(/^launch\s+(\S+)(.*)$/);
+  if (!launchMatch) return command; // Not a launch command
+  
+  const appName = launchMatch[1];
+  const restOfCommand = launchMatch[2];
+  
+  // If it already looks like a bundle ID, don't resolve
+  if (appName.includes('.')) return command;
+  
+  // Look up preset
+  if (appPresets[appName]) {
+    const preset = appPresets[appName];
+    let bundleId;
+    
+    // Try platform-specific first, then common
+    if (preset[platform]) {
+      bundleId = preset[platform];
+    } else if (preset.common) {
+      bundleId = preset.common;
+    }
+    
+    if (bundleId) {
+      log.debug(`  📱 Resolved app preset: "${appName}" → "${bundleId}" (${platform})`);
+      return `launch ${bundleId}${restOfCommand}`;
+    }
+  }
+  
+  // No preset found, return original
+  return command;
+}
+
+// Execute command on device(s)
+function executeCommand(deviceNames, command, wsClient) {
+  return new Promise(async (resolve, reject) => {
+    log.debug(`\n${'#'.repeat(60)}`);
+    log.debug(`executeCommand() called`);
+    log.debug(`Device names received: [${deviceNames.join(', ')}]`);
+    log.debug(`Command: "${command}"`);
+    log.debug(`${'#'.repeat(60)}\n`);
+    
+    // Get full device objects from connectedDevices cache
+    // Match by name, udid, or serial
+    const devices = connectedDevices.filter(d => 
+      deviceNames.includes(d.name) || 
+      deviceNames.includes(d.udid) || 
+      deviceNames.includes(d.serial)
+    );
+    
+    log.debug(`Connected devices in cache: ${connectedDevices.length}`);
+    log.debug(`Cache contents:`, connectedDevices.map(d => `${d.name}(${d.status})`).join(', '));
+    log.debug(`Filtered devices: ${devices.length}`);
+    
+    if (devices.length === 0) {
+      console.error(`❌ No devices found for: [${deviceNames.join(', ')}]`);
+      return reject({ success: false, error: 'No devices found. Please refresh device list and try again.' });
+    }
+    
+    // Check if devices are online/connected
+    // Accept both 'online' and 'connected' as valid statuses
+    const offlineDevices = devices.filter(d => !['online', 'connected'].includes(d.status));
+    if (offlineDevices.length > 0) {
+      const offlineNames = offlineDevices.map(d => `${d.name} (status: ${d.status})`).join(', ');
+      console.error(`❌ Devices not connected: [${offlineNames}]`);
+      
+      // Send user-friendly message via WebSocket
+      if (wsClient) {
+        wsClient.send(JSON.stringify({
+          type: 'command_output',
+          data: `\n⚠️  Error: Devices not connected: ${offlineNames}\n\n💡 Please click the "Connect" button on each device before running commands.\n\n`,
+          devices: deviceNames
+        }));
+      }
+      
+      return reject({ 
+        success: false, 
+        error: `Devices not connected: ${offlineNames}. Please click "Connect" button on each device first.` 
+      });
+    }
+    
+    log.debug(`✅ Found ${devices.length} connected devices`);
+    log.debug('Device details:', devices.map(d => `${d.name}(${d.platform}-${d.connectionType})`).join(', '));
+    
+    // Group devices by platform and connection type
+    const iosUSBDevices = devices.filter(d => d.platform === 'ios' && d.connectionType === 'usb');
+    const iosWirelessDevices = devices.filter(d => d.platform === 'ios' && d.connectionType === 'wireless');
+    const androidUSBDevices = devices.filter(d => d.platform === 'android' && d.connectionType === 'usb');
+    const androidWirelessDevices = devices.filter(d => d.platform === 'android' && d.connectionType === 'wireless');
+    
+    log.debug(`iOS USB: ${iosUSBDevices.length}, iOS Wireless: ${iosWirelessDevices.length}`);
+    log.debug(`Android USB: ${androidUSBDevices.length}, Android Wireless: ${androidWirelessDevices.length}`);
+    
+    const promises = [];
+    
+    // Execute for iOS USB devices
+    if (iosUSBDevices.length > 0) {
+      const names = iosUSBDevices.map(d => d.name);
+      const iosCommand = resolveAppPreset(command, 'ios');
+      log.debug(`Using iOS USB script for: ${names.join(', ')}`);
+      promises.push(executeWithScript(USB_SCRIPT_PATH, names, iosCommand, wsClient));
+    }
+    
+    // Execute for iOS wireless devices
+    if (iosWirelessDevices.length > 0) {
+      const names = iosWirelessDevices.map(d => d.name);
+      const iosCommand = resolveAppPreset(command, 'ios');
+      log.debug(`Using iOS wireless script for: ${names.join(', ')}`);
+      promises.push(executeWithScript(WIRELESS_SCRIPT_PATH, names, iosCommand, wsClient));
+    }
+    
+    // Execute for Android USB devices
+    if (androidUSBDevices.length > 0) {
+      const androidCommand = resolveAppPreset(command, 'android');
+      log.debug(`Using Android control script for USB devices: ${androidUSBDevices.map(d => d.name).join(', ')}`);
+      promises.push(executeAndroidDevices(ANDROID_USB_SCRIPT_PATH, androidUSBDevices, androidCommand, wsClient));
+    }
+    
+    // Execute for Android wireless devices
+    if (androidWirelessDevices.length > 0) {
+      const androidCommand = resolveAppPreset(command, 'android');
+      log.debug(`Using Android control script for wireless devices: ${androidWirelessDevices.map(d => d.name).join(', ')}`);
+      promises.push(executeAndroidDevices(ANDROID_WIRELESS_SCRIPT_PATH, androidWirelessDevices, androidCommand, wsClient));
+    }
+    
+    if (promises.length === 0) {
+      console.log('No scripts to execute - no devices found!');
+      return reject({ success: false, error: 'No executable devices found' });
+    }
+    
+    try {
+      const results = await Promise.allSettled(promises);
+      const successCount = results.filter(r => r.status === 'fulfilled').length;
+      const failCount = results.filter(r => r.status === 'rejected').length;
+      
+      log.info(`ExecuteCommand summary: ${successCount} succeeded, ${failCount} failed`);
+      
+      resolve({ 
+        success: true, 
+        results,
+        summary: `${successCount}/${promises.length} script groups completed`
+      });
+    } catch (error) {
+      console.error('Script execution error:', error);
+      reject(error);
+    }
+  });
+}
+
+function executeWithScript(scriptPath, deviceNames, command, wsClient) {
+  return new Promise((resolve, reject) => {
+    log.debug(`\n${'='.repeat(60)}`);
+    log.debug(`EXECUTE WITH SCRIPT - START`);
+    log.debug(`Script: ${path.basename(scriptPath)}`);
+    log.debug(`Devices: [${deviceNames.join(', ')}]`);
+    log.debug(`Command: "${command}"`);
+    log.debug(`Total devices: ${deviceNames.length}`);
+    log.debug(`${'='.repeat(60)}\n`);
+    
+    // Execute command on each device in parallel
+    const devicePromises = deviceNames.map((deviceName, index) => {
+      log.debug(`[${index + 1}/${deviceNames.length}] Creating execution promise for: ${deviceName}`);
+      
+      return new Promise((resolveDevice, rejectDevice) => {
+        // Use -d flag for each device
+        const args = ['-d', deviceName, command];
+        
+        log.debug(`  └─ Spawning: ${path.basename(scriptPath)} ${args.join(' ')}`);
+        
+        const child = spawn(scriptPath, args, {
+          cwd: path.dirname(scriptPath),
+          env: { ...process.env }
+        });
+        
+        log.debug(`  └─ Process spawned with PID: ${child.pid}`);
+        
+        let output = '';
+        let error = '';
+        
+        child.stdout.on('data', (data) => {
+          const text = data.toString();
+          output += text;
+          // In production mode (non-DEBUG), only show final success/failure
+          // Filter out all intermediate debug messages from scripts
+          if (DEBUG) {
+            // Debug mode: show everything
+            console.log(`[${deviceName}] ${text.trim()}`);
+          }
+          // Production mode: don't log script output, only final result
+          if (wsClient) {
+            wsClient.send(JSON.stringify({
+              type: 'command_output',
+              data: `[${deviceName}] ${text}`,
+              devices: [deviceName]
+            }));
+          }
+        });
+        
+        child.stderr.on('data', (data) => {
+          const text = data.toString();
+          error += text;
+          log.error(`[${deviceName}] ${text.trim()}`);
+        });
+        
+        child.on('close', (code) => {
+          if (code === 0) {
+            log.info(`✅ [${deviceName}] Command completed successfully`);
+            resolveDevice({ success: true, output, device: deviceName });
+          } else {
+            log.error(`❌ [${deviceName}] Command failed with code: ${code}`);
+            rejectDevice({ success: false, error: error || `Script exited with code ${code}`, device: deviceName });
+          }
+        });
+        
+        child.on('error', (err) => {
+          console.error(`[${deviceName}] Process error: ${err.message}`);
+          rejectDevice({ success: false, error: err.message, device: deviceName });
+        });
+      });
+    });
+    
+    log.debug(`\nWaiting for ${devicePromises.length} device execution(s) to complete...\n`);
+    
+    // Wait for all devices to complete
+    Promise.allSettled(devicePromises)
+      .then(results => {
+        const successful = results.filter(r => r.status === 'fulfilled').length;
+        const failed = results.filter(r => r.status === 'rejected').length;
+        
+        console.log(`\n${'='.repeat(60)}`);
+        log.debug(`EXECUTION COMPLETE`);
+        log.debug(`Success: .*, Failed: ${failed}`);
+        console.log(`${'='.repeat(60)}\n`);
+        
+        resolve({ 
+          success: true, 
+          results,
+          summary: `${successful}/${deviceNames.length} devices completed successfully`
+        });
+      })
+      .catch(error => {
+        console.error(`Promise.allSettled error: ${error.message}`);
+        reject(error);
+      });
+  });
+}
+
+// Execute Android commands (uses device UDID instead of name)
+function executeAndroidDevices(scriptPath, devices, command, wsClient) {
+  return new Promise((resolve, reject) => {
+    log.debug(`\n${'='.repeat(60)}`);
+    log.debug(`EXECUTE ANDROID DEVICES - START`);
+    log.debug(`Script: ${path.basename(scriptPath)}`);
+    log.debug(`Devices: [${devices.map(d => d.name).join(', ')}]`);
+    log.debug(`Command: "${command}"`);
+    log.debug(`Total devices: ${devices.length}`);
+    log.debug(`${'='.repeat(60)}\n`);
+    
+    // Execute command on each device in parallel
+    const devicePromises = devices.map((device, index) => {
+      log.debug(`[${index + 1}/${deviceData.length}] Creating execution promise for: ${device.name} (${device.udid})`);
+      
+      return new Promise((resolveDevice, rejectDevice) => {
+        // Android script expects: <device_serial> <command> [args...]
+        // Use UDID (which is the serial for Android)
+        const args = [device.udid, ...command.split(' ')];
+        
+        log.debug(`  └─ Spawning: ${path.basename(scriptPath)} ${args.join(' ')}`);
+        
+        const child = spawn(scriptPath, args, {
+          cwd: path.dirname(scriptPath),
+          env: { ...process.env }  // Pass TMPDIR and other env vars
+        });
+        
+        log.debug(`  └─ Process spawned with PID: ${child.pid}`);
+        
+        let output = '';
+        let error = '';
+        
+        child.stdout.on('data', (data) => {
+          const text = data.toString();
+          output += text;
+          // Production mode: don't log script output to console
+          if (DEBUG) {
+            console.log(`[${device.name}] ${text.trim()}`);
+          }
+          if (wsClient) {
+            wsClient.send(JSON.stringify({ 
+              type: 'output', 
+              device: device.name, 
+              data: text 
+            }));
+          }
+        });
+        
+        child.stderr.on('data', (data) => {
+          const text = data.toString();
+          error += text;
+          log.error(`[${device.name}] ${text.trim()}`);
+        });
+        
+        child.on('close', (code) => {
+          if (code === 0) {
+            log.info(`✅ [${device.name}] Command completed successfully`);
+            resolveDevice({ success: true, output, device: device.name });
+          } else {
+            log.error(`❌ [${device.name}] Command failed with code: ${code}`);
+            if (error || output) {
+              log.error(`   Error: ${error || output}`);
+            }
+            resolveDevice({ success: false, error: error || output, device: device.name });
+          }
+        });
+        
+        child.on('error', (err) => {
+          log.error(`[${device.name}] Process error:`, err);
+          resolveDevice({ success: false, error: err.message, device: device.name });
+        });
+      });
+    });
+    
+    Promise.allSettled(devicePromises)
+      .then(results => {
+        console.log(`\n${'='.repeat(60)}`);
+        log.debug(`EXECUTION COMPLETE`);
+        const successCount = results.filter(r => r.status === 'fulfilled' && r.value.success).length;
+        const failCount = results.length - successCount;
+        log.debug(`Success: .*, Failed: ${failCount}`);
+        console.log(`${'='.repeat(60)}\n`);
+        
+        resolve({ success: true, results });
+      })
+      .catch(error => {
+        console.error('Execution error:', error);
+        reject(error);
+      });
+  });
+}
+
+// AI-powered command conversion (supports multiple providers)
+async function convertNaturalLanguageToCommand(text, devices, provider = null) {
+  // Determine platforms from devices
+  const deviceObjs = connectedDevices.filter(d => devices.includes(d.name));
+  
+  if (deviceObjs.length === 0) {
+    // No devices found, try with null platform
+    return await aiManager.convertCommand(text, null, provider);
+  }
+  
+  // Group devices by platform
+  const platforms = [...new Set(deviceObjs.map(d => d.platform))];
+  
+  console.log(`AI converting for ${deviceObjs.length} device(s) across ${platforms.length} platform(s): ${platforms.join(', ')}`);
+  
+  // For multi-platform, use 'both' to get generic app names
+  // The executeCommand function will resolve platform-specific package IDs
+  const platform = platforms.length === 1 ? platforms[0] : 'both';
+  
+  console.log(`AI using platform mode: ${platform}`);
+  return await aiManager.convertCommand(text, platform, provider);
+}
+
+// Execute commands sequentially with WAIT support
+async function executeCommandsSequentially(devices, commandsText, wsClient) {
+  const lines = commandsText.split('\n').map(line => line.trim()).filter(line => line);
+  
+  console.log(`\n${'~'.repeat(60)}`);
+  console.log(`SEQUENTIAL EXECUTION - START`);
+  console.log(`Total commands: ${lines.length}`);
+  console.log(`Commands:`, lines);
+  console.log(`${'~'.repeat(60)}\n`);
+  
+  const results = [];
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    
+    // Skip comments
+    if (line.startsWith('#')) {
+      continue;
+    }
+    
+    // Check if it's a WAIT command
+    if (line.startsWith('WAIT ')) {
+      const waitTime = parseInt(line.replace('WAIT ', ''));
+      console.log(`⏳ Waiting ${waitTime}ms before next command...`);
+      
+      if (wsClient) {
+        wsClient.send(JSON.stringify({
+          type: 'command_output',
+          data: `⏳ Waiting ${waitTime}ms...\n`,
+          devices: devices
+        }));
+      }
+      
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+      results.push({ command: line, success: true, output: `Waited ${waitTime}ms` });
+      continue;
+    }
+    
+    // Execute the command on ALL devices simultaneously
+    console.log(`\n▶️  Executing command ${i + 1}/${lines.length}: "${line}"`);
+    
+    if (wsClient) {
+      wsClient.send(JSON.stringify({
+        type: 'command_output',
+        data: `▶️  [${i + 1}/${lines.length}] ${line}\n`,
+        devices: devices
+      }));
+    }
+    
+    try {
+      const result = await executeCommand(devices, line, wsClient);
+      results.push({ command: line, success: true, result });
+      console.log(`✅ Command ${i + 1} completed successfully`);
+    } catch (error) {
+      console.error(`❌ Command ${i + 1} failed:`, error.message);
+      results.push({ command: line, success: false, error: error.message });
+      
+      if (wsClient) {
+        wsClient.send(JSON.stringify({
+          type: 'command_output',
+          data: `❌ Error: ${error.message}\n`,
+          devices: devices
+        }));
+      }
+    }
+  }
+  
+  console.log(`\n${'~'.repeat(60)}`);
+  console.log(`SEQUENTIAL EXECUTION - COMPLETE`);
+  console.log(`Total: ${results.length}, Success: ${results.filter(r => r.success).length}, Failed: ${results.filter(r => !r.success).length}`);
+  console.log(`${'~'.repeat(60)}\n`);
+  
+  return {
+    success: true,
+    results,
+    summary: `Executed ${results.length} commands`
+  };
+}
+
+
+// Create WDA session for a device
+async function createWDASession(host, deviceName) {
+  return new Promise(async (resolve) => {
+    const sessionFile = '/tmp/ios_multi_sessions';
+    
+    // First, check if session already exists for this device
+    try {
+      const existingContent = await fs.readFile(sessionFile, 'utf-8').catch(() => '');
+      const lines = existingContent.split('\n').filter(line => line.trim());
+      
+      for (const line of lines) {
+        const [name, sessionId] = line.split(':');
+        if (name === deviceName && sessionId) {
+          // Session already exists, verify it's still valid
+          const port = host === 'localhost' ? 8100 : 8100;
+          const verifyUrl = `http://${host}:${port}/session/${sessionId}`;
+          
+          const verifyProcess = spawn('curl', ['-s', '-X', 'GET', verifyUrl]);
+          let verifyOutput = '';
+          
+          verifyProcess.stdout.on('data', (data) => {
+            verifyOutput += data.toString();
+          });
+          
+          verifyProcess.on('close', (code) => {
+            if (code === 0 && verifyOutput && !verifyOutput.includes('invalid session id')) {
+              console.log(`✅ Existing valid session found: ${sessionId}`);
+              return resolve({ success: true, sessionId, existing: true });
+            } else {
+              // Session is invalid, create a new one
+              createNewSession(host, deviceName, sessionFile, resolve);
+            }
+          });
+          
+          return;
+        }
+      }
+    } catch (e) {
+      // File doesn't exist or error reading, create new session
+    }
+    
+    // No existing session, create a new one
+    createNewSession(host, deviceName, sessionFile, resolve);
+  });
+}
+
+function createNewSession(host, deviceName, sessionFile, resolve) {
+  const port = host === 'localhost' ? 8100 : 8100;
+  const sessionUrl = `http://${host}:${port}/session`;
+  
+  const curlProcess = spawn('curl', [
+    '-s',
+    '-X', 'POST',
+    sessionUrl,
+    '-H', 'Content-Type: application/json',
+    '-d', '{"capabilities":{"alwaysMatch":{}}}'
+  ]);
+  
+  let output = '';
+  curlProcess.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+  
+  curlProcess.on('close', (code) => {
+    if (code === 0 && output) {
+      try {
+        const response = JSON.parse(output);
+        const sessionId = response.sessionId || response.value?.sessionId;
+        
+        if (sessionId) {
+          // Read existing sessions and update
+          fs.readFile(sessionFile, 'utf-8')
+            .catch(() => '')
+            .then(existingContent => {
+              // Remove old session for this device if exists
+              const lines = existingContent.split('\n').filter(line => {
+                const [name] = line.split(':');
+                return line.trim() && name !== deviceName;
+              });
+              
+              // Add new session
+              lines.push(`${deviceName}:${sessionId}`);
+              
+              // Write back to file
+              return fs.writeFile(sessionFile, lines.join('\n') + '\n');
+            })
+            .then(() => {
+              console.log(`✅ New session created and saved: ${sessionId}`);
+              resolve({ success: true, sessionId });
+            })
+            .catch((err) => {
+              console.error(`❌ Failed to save session for ${deviceName}:`, err);
+              resolve({ success: false });
+            });
+        } else {
+          resolve({ success: false });
+        }
+      } catch (e) {
+        console.error('Failed to parse WDA session response:', e);
+        resolve({ success: false });
+      }
+    } else {
+      resolve({ success: false });
+    }
+  });
+  
+  curlProcess.on('error', (err) => {
+    console.error('Error creating WDA session:', err);
+    resolve({ success: false });
+  });
+}
+
+// Install UIAutomator2 on Android device
+async function installUIAutomator2(deviceUdid, deviceName) {
+  return new Promise((resolve) => {
+    console.log(`📥 Installing UIAutomator2 on ${deviceName}...`);
+    
+    const { execSync } = require('child_process');
+    const os = require('os');
+    const path = require('path');
+    
+    try {
+      // Try multiple locations for APKs
+      const possiblePaths = [
+        // Appium installed location
+        path.join(os.homedir(), '.appium', 'node_modules', 'appium-uiautomator2-driver', 'node_modules', 'appium-uiautomator2-server', 'apks'),
+        // Global npm location
+        execSync('npm root -g', { encoding: 'utf-8' }).trim() + '/appium-uiautomator2-driver/node_modules/appium-uiautomator2-server/apks',
+        // Alternative npm location
+        execSync('npm root -g', { encoding: 'utf-8' }).trim() + '/appium/node_modules/appium-uiautomator2-driver/node_modules/appium-uiautomator2-server/apks',
+      ];
+      
+      let serverApk = null;
+      let testApk = null;
+      let foundPath = null;
+      
+      // Try each path
+      for (const apkPath of possiblePaths) {
+        console.log(`📂 Checking: ${apkPath}`);
+        
+        try {
+          const serverCheck = execSync(`ls "${apkPath}"/appium-uiautomator2-server-v*.apk 2>/dev/null || echo ""`, { encoding: 'utf-8' }).trim();
+          const testCheck = execSync(`ls "${apkPath}"/appium-uiautomator2-server-debug-androidTest.apk 2>/dev/null || echo ""`, { encoding: 'utf-8' }).trim();
+          
+          if (serverCheck && testCheck) {
+            serverApk = serverCheck;
+            testApk = testCheck;
+            foundPath = apkPath;
+            console.log(`✅ Found APKs in: ${foundPath}`);
+            break;
+          }
+        } catch (e) {
+          continue;
+        }
+      }
+      
+      if (serverApk && testApk) {
+        console.log(`📦 Installing server APK: ${serverApk}`);
+        const serverOutput = execSync(`adb -s ${deviceUdid} install -r "${serverApk}" 2>&1`, { encoding: 'utf-8' });
+        console.log(serverOutput);
+        
+        console.log(`📦 Installing test APK: ${testApk}`);
+        const testOutput = execSync(`adb -s ${deviceUdid} install -r "${testApk}" 2>&1`, { encoding: 'utf-8' });
+        console.log(testOutput);
+        
+        console.log(`✅ UIAutomator2 installed successfully on ${deviceName}`);
+        resolve({ 
+          success: true, 
+          message: 'UIAutomator2 installed successfully' 
+        });
+      } else {
+        console.log(`⚠️  APK files not found in any expected location`);
+        console.log(`Tried paths:`, possiblePaths);
+        
+        // Try using appium to install
+        try {
+          console.log(`🔄 Trying to install via Appium...`);
+          const appiumOutput = execSync(`appium driver install uiautomator2 2>&1`, { encoding: 'utf-8' });
+          console.log(appiumOutput);
+          
+          resolve({ 
+            success: false, 
+            message: 'APKs not found. Tried to reinstall driver. Please run: appium driver install uiautomator2' 
+          });
+        } catch (appiumError) {
+          resolve({ 
+            success: false, 
+            message: 'UIAutomator2 APKs not found. Please run: appium driver install uiautomator2' 
+          });
+        }
+      }
+    } catch (error) {
+      console.error(`❌ Failed to install UIAutomator2: ${error.message}`);
+      resolve({ 
+        success: false, 
+        message: `Failed to install UIAutomator2: ${error.message}` 
+      });
+    }
+  });
+}
+
+// Connect to device - starts WDA if needed
+async function connectToDevice(device) {
+  return new Promise(async (resolve, reject) => {
+    const { name, udid, type, ip, platform } = device;
+    
+    log.debug(`Connecting to ${name} (${type}, platform: ${platform})...`);
+    
+    // Handle Android devices differently
+    if (platform === 'android') {
+      log.debug(`📱 Android device detected: ${name}`);
+      
+      // Check if device is connected via adb
+      const checkAdb = spawn('adb', ['devices']);
+      let output = '';
+      
+      checkAdb.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+      
+      checkAdb.on('close', async (code) => {
+        const deviceConnected = output.includes(udid.replace(':5555', '')) || output.includes(udid);
+        
+        if (deviceConnected) {
+          log.debug(`✅ Android device ${name} is connected via ADB`);
+          
+          // Update device status to online
+          const deviceIndex = connectedDevices.findIndex(d => d.name === name);
+          if (deviceIndex !== -1) {
+            connectedDevices[deviceIndex].status = 'online';
+          }
+          
+          // Broadcast updated device list
+          wss.clients.forEach(client => {
+            if (client.readyState === WebSocket.OPEN) {
+              client.send(JSON.stringify({
+                type: 'devices_updated',
+                devices: connectedDevices
+              }));
+            }
+          });
+          
+          // Check if UiAutomator2 is installed
+          log.debug(`📦 Checking UiAutomator2 server for ${name}...`);
+          const checkUiAutomator = spawn('adb', ['-s', udid, 'shell', 'pm', 'list', 'packages', 'io.appium.uiautomator2']);
+          let uiautomatorOutput = '';
+          
+          checkUiAutomator.stdout.on('data', (data) => {
+            uiautomatorOutput += data.toString();
+          });
+          
+          checkUiAutomator.on('close', async () => {
+            if (uiautomatorOutput.includes('io.appium.uiautomator2')) {
+              log.debug(`✅ UiAutomator2 already installed on ${name}`);
+              
+              // Start UIAutomator2 session
+              const sessionResult = await startUIAutomator2Session(udid, name);
+              if (sessionResult.success) {
+                resolve({ 
+                  success: true, 
+                  message: `Connected to ${name} - UIAutomator2 Ready ✅` 
+                });
+              } else {
+                resolve({ 
+                  success: true, 
+                  message: `Connected to ${name} - ADB Ready ✅` 
+                });
+              }
+            } else {
+              console.log(`⚠️  UiAutomator2 not found on ${name}, attempting auto-install...`);
+              
+              // Auto-install UIAutomator2
+              const installResult = await installUIAutomator2(udid, name);
+              
+              if (installResult.success) {
+                // Start UIAutomator2 session after installation
+                const sessionResult = await startUIAutomator2Session(udid, name);
+                resolve({ 
+                  success: true, 
+                  message: `Connected to ${name} - UIAutomator2 Installed & Ready ✅` 
+                });
+              } else {
+                resolve({ 
+                  success: true, 
+                  message: `Connected to ${name} - ADB Ready ✅` 
+                });
+              }
+            }
+          });
+        } else {
+          console.log(`❌ Android device ${name} not found in ADB`);
+          
+          // If wireless, try to connect via adb
+          if (type === 'wireless' && ip) {
+            console.log(`📡 Attempting to connect to ${name} wirelessly at ${ip}:5555...`);
+            const adbConnect = spawn('adb', ['connect', `${ip}:5555`]);
+            
+            adbConnect.on('close', async (code) => {
+              if (code === 0) {
+                console.log(`✅ Connected to ${name} wirelessly`);
+                
+                // Update device status
+                const deviceIndex = connectedDevices.findIndex(d => d.name === name);
+                if (deviceIndex !== -1) {
+                  connectedDevices[deviceIndex].status = 'online';
+                }
+                
+                // Broadcast updated device list
+                wss.clients.forEach(client => {
+                  if (client.readyState === WebSocket.OPEN) {
+                    client.send(JSON.stringify({
+                      type: 'devices_updated',
+                      devices: connectedDevices
+                    }));
+                  }
+                });
+                
+                // Auto-install UIAutomator2
+                console.log(`📦 Checking and installing UIAutomator2 on ${name}...`);
+                const installResult = await installUIAutomator2(`${ip}:5555`, name);
+                
+                let message = '';
+                if (installResult.success) {
+                  // Start UIAutomator2 session after installation
+                  const sessionResult = await startUIAutomator2Session(`${ip}:5555`, name);
+                  if (sessionResult.success) {
+                    message = `Connected to ${name} - UIAutomator2 Ready ✅`;
+                  } else {
+                    message = `Connected to ${name} - ADB Ready ✅`;
+                  }
+                } else {
+                  message = `Connected to ${name} - ADB Ready ✅`;
+                }
+                
+                resolve({ 
+                  success: true, 
+                  message: message
+                });
+              } else {
+                reject({ 
+                  success: false, 
+                  message: `Failed to connect to ${name}. Make sure USB debugging is enabled and device is on the same network.` 
+                });
+              }
+            });
+          } else {
+            reject({ 
+              success: false, 
+              message: `Android device ${name} not connected. Please connect via USB or enable wireless debugging.` 
+            });
+          }
+        }
+      });
+      
+      checkAdb.on('error', (err) => {
+        console.error(`❌ ADB error: ${err.message}`);
+        reject({ 
+          success: false, 
+          message: `ADB not available. Please install Android SDK Platform-Tools.` 
+        });
+      });
+      
+      return; // Exit early for Android devices
+    }
+    
+    // iOS device handling continues below
+    if (type === 'usb') {
+      // For USB devices, check if WDA is already running
+      const checkWDA = spawn('curl', [
+        '-s',
+        '--connect-timeout', '2',
+        'http://localhost:8100/status'
+      ]);
+      
+      let output = '';
+      checkWDA.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+      
+      checkWDA.on('error', (err) => {
+        console.error(`❌ Error checking WDA: ${err.message}`);
+        reject({ success: false, message: `Failed to check WDA status: ${err.message}` });
+      });
+      
+      checkWDA.on('close', async (code) => {
+        if (output.includes('"state"')) {
+          console.log(`✅ WDA already running for ${name}`);
+          
+          // Create WDA session if not exists
+          console.log(`📱 Creating WDA session for ${name}...`);
+          const sessionResult = await createWDASession('localhost', name);
+          
+          if (sessionResult.success) {
+            console.log(`✅ Session created: ${sessionResult.sessionId}`);
+          } else {
+            console.log(`⚠️  Session creation failed, will be created on first command`);
+          }
+          
+          // Update status to online
+          const deviceIndex = connectedDevices.findIndex(d => d.name === name);
+          if (deviceIndex !== -1) {
+            connectedDevices[deviceIndex].status = 'online';
+          }
+          
+          // Broadcast updated device list
+          wss.clients.forEach(client => {
+            if (client.readyState === WebSocket.OPEN) {
+              client.send(JSON.stringify({
+                type: 'devices_updated',
+                devices: connectedDevices
+              }));
+            }
+          });
+          
+          resolve({ success: true, message: `Connected to ${name} - WDA Ready ✅` });
+        } else {
+          console.log(`🚀 Starting WDA for ${name} (UDID: ${udid})...`);
+          
+          // Start WDA using xcodebuild
+          // First, check if we have WebDriverAgent path
+          const wdaPath = process.env.WDA_PATH || path.join(process.env.HOME, 'Downloads/WebDriverAgent-10.2.1');
+          
+          console.log(`📂 WDA Path: ${wdaPath}`);
+          console.log(`📱 Device UDID: ${udid}`);
+          
+          // Start xcodebuild in background with piped output for debugging
+          const wdaProcess = spawn('xcodebuild', [
+            'test',
+            '-project', path.join(wdaPath, 'WebDriverAgent.xcodeproj'),
+            '-scheme', 'WebDriverAgentRunner',
+            '-destination', `id=${udid}`,
+            'IPHONEOS_DEPLOYMENT_TARGET=14.0'
+          ], {
+            cwd: wdaPath,
+            detached: true,
+            stdio: ['ignore', 'pipe', 'pipe']
+          });
+          
+          // Log output for debugging
+          wdaProcess.stdout.on('data', (data) => {
+            const output = data.toString();
+            if (output.includes('ServerURLHere') || output.includes('WebDriverAgent')) {
+              console.log(`📱 WDA: ${output.trim()}`);
+            }
+          });
+          
+          wdaProcess.stderr.on('data', (data) => {
+            const error = data.toString();
+            if (!error.includes('note:') && !error.includes('warning:')) {
+              console.error(`⚠️ WDA Error: ${error.trim()}`);
+            }
+          });
+          
+          wdaProcess.on('error', (err) => {
+            console.error(`❌ Failed to start xcodebuild: ${err.message}`);
+          });
+          
+          wdaProcess.unref();
+          
+          // Also start iproxy to forward port
+          console.log(`🔌 Starting iproxy for port forwarding...`);
+          const iproxyProcess = spawn('iproxy', ['8100', '8100'], {
+            detached: true,
+            stdio: ['ignore', 'pipe', 'pipe']
+          });
+          
+          iproxyProcess.stdout.on('data', (data) => {
+            console.log(`🔌 iproxy: ${data.toString().trim()}`);
+          });
+          
+          iproxyProcess.on('error', (err) => {
+            console.error(`❌ Failed to start iproxy: ${err.message}`);
+            console.error(`   Make sure libimobiledevice is installed: brew install libimobiledevice`);
+          });
+          
+          iproxyProcess.unref();
+          
+          // Track WDA processes for cleanup on disconnect
+          wdaProcesses.set(name, {
+            xcodebuild: wdaProcess.pid,
+            iproxy: iproxyProcess.pid
+          });
+          
+          console.log(`✅ WDA starting for ${name}. Process ID: ${wdaProcess.pid}`);
+          
+          // Wait a bit for WDA to start, then verify
+          setTimeout(() => {
+            const verifyWDA = spawn('curl', [
+              '-s',
+              '--connect-timeout', '5',
+              'http://localhost:8100/status'
+            ]);
+            
+            let verifyOutput = '';
+            verifyWDA.stdout.on('data', (data) => {
+              verifyOutput += data.toString();
+            });
+            
+            verifyWDA.on('close', async () => {
+              if (verifyOutput.includes('"state"')) {
+                console.log(`✅ WDA successfully started for ${name}`);
+                
+                // Create WDA session for USB device
+                console.log(`📱 Creating WDA session for ${name}...`);
+                const sessionResult = await createWDASession('localhost', name);
+                
+                if (sessionResult.success) {
+                  console.log(`✅ Session created: ${sessionResult.sessionId}`);
+                } else {
+                  console.log(`⚠️  Session creation failed, will be created on first command`);
+                }
+                
+                // Update device status to online in connectedDevices
+                const deviceIndex = connectedDevices.findIndex(d => d.name === name);
+                if (deviceIndex !== -1) {
+                  connectedDevices[deviceIndex].status = 'online';
+                }
+                
+                // Broadcast updated device list and connection status to all WebSocket clients
+                wss.clients.forEach(client => {
+                  if (client.readyState === WebSocket.OPEN) {
+                    client.send(JSON.stringify({
+                      type: 'devices_updated',
+                      devices: connectedDevices
+                    }));
+                    // Send connection complete message
+                    client.send(JSON.stringify({
+                      type: 'command_output',
+                      output: `✅ ${name} connected - WDA Ready!\n${'─'.repeat(50)}\n`,
+                      device: name
+                    }));
+                  }
+                });
+              } else {
+                console.log(`⚠️  WDA still starting for ${name}...`);
+              }
+            });
+          }, 8000); // Wait 8 seconds for WDA to start
+          
+          // Return immediately with starting status
+          resolve({ 
+            success: true, 
+            message: `Connecting to ${name} - Starting WDA...`,
+            wdaStarting: true
+          });
+        }
+      });
+      
+      checkWDA.on('error', () => {
+        console.log(`⚠️  Could not check WDA status, attempting to start...`);
+        resolve({ success: false, message: `Error checking WDA. Please start manually in Xcode.` });
+      });
+    } else {
+      // For wireless devices, check if WDA is reachable
+      const checkWDA = spawn('curl', [
+        '-s',
+        '--connect-timeout', '3',
+        `http://${ip}:8100/status`
+      ]);
+      
+      let output = '';
+      checkWDA.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+      
+      checkWDA.on('close', async () => {
+        if (output.includes('"state"')) {
+          console.log(`✅ WDA reachable for ${name}`);
+          
+          // Create WDA session for wireless device
+          console.log(`📱 Creating WDA session for ${name}...`);
+          const sessionResult = await createWDASession(ip, name);
+          
+          if (sessionResult.success) {
+            console.log(`✅ Session created: ${sessionResult.sessionId}`);
+          } else {
+            console.log(`⚠️  Session creation failed, will be created on first command`);
+          }
+          
+          // Update status to online
+          const deviceIndex = connectedDevices.findIndex(d => d.name === name);
+          if (deviceIndex !== -1) {
+            connectedDevices[deviceIndex].status = 'online';
+          }
+          
+          // Broadcast updated device list
+          wss.clients.forEach(client => {
+            if (client.readyState === WebSocket.OPEN) {
+              client.send(JSON.stringify({
+                type: 'devices_updated',
+                devices: connectedDevices
+              }));
+            }
+          });
+          
+          resolve({ success: true, message: `Connected to ${name} - WDA Ready ✅` });
+        } else {
+          console.log(`❌ WDA not running on ${name}, attempting to start...`);
+          
+          // Start WDA wirelessly using xcodebuild
+          const wdaPath = process.env.WDA_PATH || path.join(process.env.HOME, 'Downloads/WebDriverAgent-10.2.1');
+          
+          console.log(`📂 WDA Path: ${wdaPath}`);
+          console.log(`📱 Device UDID: ${udid}`);
+          console.log(`📡 Device IP: ${ip}`);
+          
+          // Start xcodebuild in background for wireless device
+          const wdaProcess = spawn('xcodebuild', [
+            'test',
+            '-project', path.join(wdaPath, 'WebDriverAgent.xcodeproj'),
+            '-scheme', 'WebDriverAgentRunner',
+            '-destination', `id=${udid}`,
+            'IPHONEOS_DEPLOYMENT_TARGET=14.0'
+          ], {
+            cwd: wdaPath,
+            detached: true,
+            stdio: ['ignore', 'pipe', 'pipe']
+          });
+          
+          // Log output for debugging
+          wdaProcess.stdout.on('data', (data) => {
+            const output = data.toString();
+            if (output.includes('ServerURLHere') || output.includes('WebDriverAgent')) {
+              console.log(`📱 WDA (${name}): ${output.trim()}`);
+            }
+          });
+          
+          wdaProcess.stderr.on('data', (data) => {
+            const error = data.toString();
+            if (!error.includes('note:') && !error.includes('warning:')) {
+              console.error(`⚠️ WDA Error (${name}): ${error.trim()}`);
+            }
+          });
+          
+          wdaProcess.on('error', (err) => {
+            console.error(`❌ Failed to start xcodebuild for ${name}: ${err.message}`);
+          });
+          
+          wdaProcess.unref();
+          
+          // Track WDA process for cleanup on disconnect
+          wdaProcesses.set(name, {
+            xcodebuild: wdaProcess.pid
+          });
+          
+          console.log(`✅ WDA starting for ${name} (wireless). Process ID: ${wdaProcess.pid}`);
+          
+          // Wait for WDA to start, then verify
+          setTimeout(() => {
+            const verifyWDA = spawn('curl', [
+              '-s',
+              '--connect-timeout', '5',
+              `http://${ip}:8100/status`
+            ]);
+            
+            let verifyOutput = '';
+            verifyWDA.stdout.on('data', (data) => {
+              verifyOutput += data.toString();
+            });
+            
+            verifyWDA.on('close', async () => {
+              if (verifyOutput.includes('"state"')) {
+                console.log(`✅ WDA successfully started for ${name}`);
+                
+                // Create WDA session for wireless device
+                console.log(`📱 Creating WDA session for ${name}...`);
+                const sessionResult = await createWDASession(ip, name);
+                
+                if (sessionResult.success) {
+                  console.log(`✅ Session created: ${sessionResult.sessionId}`);
+                } else {
+                  console.log(`⚠️  Session creation failed, will be created on first command`);
+                }
+                
+                // Update device status to online
+                const deviceIndex = connectedDevices.findIndex(d => d.name === name);
+                if (deviceIndex !== -1) {
+                  connectedDevices[deviceIndex].status = 'online';
+                }
+                
+                // Broadcast updated device list
+                wss.clients.forEach(client => {
+                  if (client.readyState === WebSocket.OPEN) {
+                    client.send(JSON.stringify({
+                      type: 'devices_updated',
+                      devices: connectedDevices
+                    }));
+                  }
+                });
+                
+                resolve({ 
+                  success: true, 
+                  message: `Connected to ${name} via WiFi - WDA Started!`,
+                  wdaStarted: true
+                });
+              } else {
+                console.log(`⚠️  WDA starting for ${name}, may take a moment...`);
+                resolve({ 
+                  success: true, 
+                  message: `WDA is starting for ${name}. Please wait 10-15 seconds...`,
+                  wdaStarting: true
+                });
+              }
+            });
+          }, 10000); // Wait 10 seconds for wireless WDA to start
+        }
+      });
+      
+      checkWDA.on('error', () => {
+        console.log(`⚠️  Cannot reach ${name} at ${ip}. Check network connection.`);
+        reject({ success: false, message: `Cannot reach ${name} at ${ip}. Check network connection.` });
+      });
+    }
+  });
+}
+
+// Disconnect from device
+async function disconnectFromDevice(device) {
+  return new Promise((resolve, reject) => {
+    const { name, connectionType, udid, platform } = device;
+    console.log(`🔌 Disconnecting from ${name} (${connectionType}, platform: ${platform})...`);
+    
+    // Handle Android devices
+    if (platform === 'android') {
+      console.log(`📱 Android device disconnect: ${name}`);
+      
+      // Stop UIAutomator2 session first
+      stopUIAutomator2Session(udid, name).catch(err => {
+        console.error(`Error stopping UIAutomator2 session: ${err.message}`);
+      });
+      
+      // For wireless Android devices, disconnect adb
+      if (connectionType === 'wireless') {
+        const adbDisconnect = spawn('adb', ['disconnect', udid]);
+        
+        adbDisconnect.on('close', (code) => {
+          console.log(`✅ Disconnected Android device ${name} from ADB`);
+          
+          // Update device status
+          const deviceIndex = connectedDevices.findIndex(d => d.name === name);
+          if (deviceIndex !== -1) {
+            connectedDevices[deviceIndex].status = 'offline';
+          }
+          
+          // Broadcast update
+          wss.clients.forEach(client => {
+            if (client.readyState === WebSocket.OPEN) {
+              client.send(JSON.stringify({
+                type: 'devices_updated',
+                devices: connectedDevices
+              }));
+            }
+          });
+          
+          resolve({ 
+            success: true, 
+            message: `Disconnected from ${name} - ADB disconnected` 
+          });
+        });
+      } else {
+        // For USB Android devices, just update status
+        console.log(`✅ Android USB device ${name} - connection maintained`);
+        
+        const deviceIndex = connectedDevices.findIndex(d => d.name === name);
+        if (deviceIndex !== -1) {
+          connectedDevices[deviceIndex].status = 'offline';
+        }
+        
+        // Broadcast update
+        wss.clients.forEach(client => {
+          if (client.readyState === WebSocket.OPEN) {
+            client.send(JSON.stringify({
+              type: 'devices_updated',
+              devices: connectedDevices
+            }));
+          }
+        });
+        
+        resolve({ 
+          success: true, 
+          message: `Disconnected from ${name}` 
+        });
+      }
+      
+      return; // Exit early for Android
+    }
+    
+    // iOS device handling - Find the device in connectedDevices to get its port
+    const deviceInfo = connectedDevices.find(d => d.name === name);
+    const port = deviceInfo?.port;
+    
+    // Strategy 1: Kill WDA processes tracked in wdaProcesses Map
+    if (wdaProcesses.has(name)) {
+      const processes = wdaProcesses.get(name);
+      
+      try {
+        if (processes.xcodebuild) {
+          try {
+            process.kill(processes.xcodebuild, 'SIGTERM');
+            console.log(`✅ Killed xcodebuild for ${name} (PID: ${processes.xcodebuild})`);
+          } catch (e) {
+            console.log(`⚠️  xcodebuild process ${processes.xcodebuild} already stopped`);
+          }
+        }
+        
+        if (processes.iproxy) {
+          try {
+            process.kill(processes.iproxy, 'SIGTERM');
+            console.log(`✅ Killed iproxy for ${name} (PID: ${processes.iproxy})`);
+          } catch (e) {
+            console.log(`⚠️  iproxy process ${processes.iproxy} already stopped`);
+          }
+        }
+        
+        wdaProcesses.delete(name);
+      } catch (error) {
+        console.error(`Error cleaning up tracked processes for ${name}:`, error);
+      }
+    }
+    
+    // Strategy 2: Kill processes by port (works for script-started WDA too)
+    if (port) {
+      console.log(`🔍 Killing processes on port ${port} for ${name}...`);
+      const killPort = spawn('sh', ['-c', `lsof -ti:${port} | xargs kill -9 2>/dev/null || true`]);
+      
+      killPort.on('close', () => {
+        console.log(`✅ Cleaned up port ${port} for ${name}`);
+      });
+    }
+    
+    // Strategy 3: Kill xcodebuild processes for this specific UDID
+    if (udid && connectionType === 'usb') {
+      console.log(`🔍 Killing WDA for UDID ${udid}...`);
+      const killWDA = spawn('sh', ['-c', `pkill -f "xcodebuild.*${udid}" || true`]);
+      
+      killWDA.on('close', () => {
+        console.log(`✅ Cleaned up WDA processes for ${name}`);
+      });
+    }
+    
+    // Strategy 4: For wireless, kill iproxy processes associated with this device's port
+    if (connectionType === 'usb' && port) {
+      const killIproxy = spawn('sh', ['-c', `pkill -f "iproxy.*${port}" || true`]);
+      killIproxy.on('close', () => {
+        console.log(`✅ Cleaned up iproxy for ${name}`);
+      });
+    }
+    
+    // Wait a moment for all cleanup to complete
+    setTimeout(() => {
+      // Update device status to offline in connectedDevices
+      const deviceIndex = connectedDevices.findIndex(d => d.name === name);
+      if (deviceIndex !== -1) {
+        connectedDevices[deviceIndex].status = 'offline';
+      }
+      
+      // Broadcast updated device list to all WebSocket clients
+      wss.clients.forEach(client => {
+        if (client.readyState === WebSocket.OPEN) {
+          client.send(JSON.stringify({
+            type: 'devices_updated',
+            devices: connectedDevices
+          }));
+        }
+      });
+      
+      console.log(`✅ Successfully disconnected ${name}`);
+      resolve({ 
+        success: true, 
+        message: `Disconnected from ${name} - WDA stopped` 
+      });
+    }, 500);
+  });
+}
+
+// ============================================
+// Recording & Replay Functions
+// ============================================
+
+// Ensure recordings directory exists
+async function ensureRecordingsDir() {
+  try {
+    await fs.access(RECORDINGS_DIR);
+  } catch {
+    await fs.mkdir(RECORDINGS_DIR, { recursive: true });
+  }
+}
+
+// Start recording
+async function startRecording(name, devices) {
+  await ensureRecordingsDir();
+  
+  currentRecording = {
+    name: name || `recording_${Date.now()}`,
+    devices: devices || [],
+    commands: [],
+    startTime: new Date().toISOString()
+  };
+  isRecording = true;
+  
+  console.log(`🔴 Recording started: ${currentRecording.name}`);
+  return { success: true, recording: currentRecording };
+}
+
+// Add command to current recording
+function recordCommand(devices, command, useAI, convertedCommand) {
+  if (!isRecording || !currentRecording) {
+    return false;
+  }
+  
+  currentRecording.commands.push({
+    timestamp: new Date().toISOString(),
+    devices,
+    originalCommand: command,
+    useAI,
+    finalCommand: convertedCommand || command
+  });
+  
+  console.log(`📝 Recorded command: ${command} (${currentRecording.commands.length} total)`);
+  return true;
+}
+
+// Stop recording and save
+async function stopRecording() {
+  if (!isRecording || !currentRecording) {
+    return { success: false, error: 'No active recording' };
+  }
+  
+  currentRecording.endTime = new Date().toISOString();
+  
+  const filename = `${currentRecording.name}.json`;
+  const filepath = path.join(RECORDINGS_DIR, filename);
+  
+  await fs.writeFile(filepath, JSON.stringify(currentRecording, null, 2));
+  
+  const result = {
+    success: true,
+    recording: currentRecording,
+    filepath: filename
+  };
+  
+  console.log(`⏹️  Recording stopped: ${currentRecording.name} (${currentRecording.commands.length} commands)`);
+  
+  isRecording = false;
+  currentRecording = null;
+  
+  return result;
+}
+
+// List all recordings
+async function listRecordings() {
+  await ensureRecordingsDir();
+  
+  try {
+    const files = await fs.readdir(RECORDINGS_DIR);
+    const recordings = [];
+    
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        try {
+          const filepath = path.join(RECORDINGS_DIR, file);
+          const content = await fs.readFile(filepath, 'utf-8');
+          const recording = JSON.parse(content);
+          
+          // Handle both old format (array of commands) and new format (string)
+          let commandCount = 0;
+          if (Array.isArray(recording.commands)) {
+            commandCount = recording.commands.length;
+          } else if (typeof recording.commands === 'string') {
+            commandCount = recording.commands.split('\n').filter(cmd => cmd.trim()).length;
+          }
+          
+          recordings.push({
+            filename: file,
+            name: recording.name || file.replace('.json', ''),
+            devices: recording.devices || [],
+            commandCount: commandCount,
+            startTime: recording.startTime || recording.date,
+            endTime: recording.endTime || recording.date,
+            type: recording.type || 'manual'
+          });
+        } catch (e) {
+          console.error(`Error reading recording ${file}:`, e);
+        }
+      }
+    }
+    
+    return recordings;
+  } catch (error) {
+    console.error('Error listing recordings:', error);
+    return [];
+  }
+}
+
+// Load a recording
+async function loadRecording(filename) {
+  const filepath = path.join(RECORDINGS_DIR, filename);
+  
+  try {
+    const content = await fs.readFile(filepath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`Error loading recording ${filename}:`, error);
+    throw error;
+  }
+}
+
+// Delete a recording
+async function deleteRecording(filename) {
+  const filepath = path.join(RECORDINGS_DIR, filename);
+  
+  try {
+    await fs.unlink(filepath);
+    return { success: true };
+  } catch (error) {
+    console.error(`Error deleting recording ${filename}:`, error);
+    throw error;
+  }
+}
+
+// Replay a recording
+async function replayRecording(filename, targetDevices, wsClient) {
+  const recording = await loadRecording(filename);
+  
+  // Normalize commands to array format
+  let commands = [];
+  if (Array.isArray(recording.commands)) {
+    // Old format: array of command objects
+    commands = recording.commands.map(cmd => cmd.finalCommand || cmd.originalCommand);
+  } else if (typeof recording.commands === 'string') {
+    // New format: string with newlines
+    commands = recording.commands.split('\n').filter(cmd => cmd.trim());
+  }
+  
+  const devices = recording.devices && recording.devices.length > 0 
+    ? recording.devices 
+    : targetDevices;
+  
+  console.log(`\n${'▶'.repeat(60)}`);
+  console.log(`REPLAYING: ${recording.name}`);
+  console.log(`Original devices: ${devices.join(', ')}`);
+  console.log(`Target devices: ${targetDevices.join(', ')}`);
+  console.log(`Commands to replay: ${commands.length}`);
+  console.log(`${'▶'.repeat(60)}\n`);
+  
+  // Reset abort flag at start
+  replayAborted = false;
+  isReplaying = true;
+  
+  // Send initial summary to terminal
+  if (wsClient) {
+    wsClient.send(JSON.stringify({
+      type: 'command_output',
+      data: `📼 Recording: ${recording.name}\n` +
+            `📱 Devices: ${targetDevices.join(', ')}\n` +
+            `📝 Commands: ${commands.length}\n` +
+            `${'━'.repeat(50)}\n\n`,
+      devices: targetDevices
+    }));
+  }
+  
+  const results = [];
+  
+  for (let i = 0; i < commands.length; i++) {
+    // Check if replay was aborted
+    if (replayAborted) {
+      console.log('\n⏹️  Replay aborted by user\n');
+      if (wsClient) {
+        wsClient.send(JSON.stringify({
+          type: 'command_output',
+          data: '\n⏹️  Replay stopped by user\n',
+          devices: targetDevices
+        }));
+      }
+      isReplaying = false;
+      throw new Error('Replay aborted by user');
+    }
+    
+    const cmd = commands[i];
+    
+    console.log(`\n🎬 Replaying command ${i + 1}/${commands.length}`);
+    console.log(`   Command: ${cmd}`);
+    
+    if (wsClient) {
+      wsClient.send(JSON.stringify({
+        type: 'command_output',
+        data: `🎬 [${i + 1}/${commands.length}] Executing: ${cmd}\n`,
+        devices: targetDevices
+      }));
+    }
+    
+    try {
+      // Execute the command
+      const result = await executeCommand(targetDevices, cmd, null); // null to suppress websocket output from executeCommand
+      results.push({ command: cmd, success: true, result });
+      
+      if (wsClient) {
+        wsClient.send(JSON.stringify({
+          type: 'command_output',
+          data: `✅ Completed successfully\n\n`,
+          devices: targetDevices
+        }));
+      }
+      
+      // Add a small delay between commands
+      if (i < commands.length - 1) {
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
+    } catch (error) {
+      console.error(`❌ Replay command ${i + 1} failed:`, error.message);
+      results.push({ command: cmd, success: false, error: error.message });
+      
+      if (wsClient) {
+        wsClient.send(JSON.stringify({
+          type: 'command_output',
+          data: `❌ Failed: ${error.message}\n\n`,
+          devices: targetDevices
+        }));
+      }
+    }
+  }
+  
+  isReplaying = false;
+  
+  console.log(`\n${'▶'.repeat(60)}`);
+  console.log(`REPLAY COMPLETE`);
+  console.log(`Total: ${results.length}, Success: ${results.filter(r => r.success).length}, Failed: ${results.filter(r => !r.success).length}`);
+  console.log(`${'▶'.repeat(60)}\n`);
+  
+  return {
+    success: true,
+    recording: recording.name,
+    results
+  };
+}
+
+// API Routes
+app.get('/api/devices', async (req, res) => {
+  try {
+    const devices = await discoverDevices();
+    res.json({ success: true, devices });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+app.post('/api/devices/refresh', async (req, res) => {
+  try {
+    const devices = await discoverDevices();
+    
+    // Broadcast to all WebSocket clients
+    wss.clients.forEach(client => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(JSON.stringify({
+          type: 'devices_updated',
+          devices
+        }));
+      }
+    });
+    
+    res.json({ success: true, devices });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+app.post('/api/execute', async (req, res) => {
+  try {
+    const { devices, command, useAI, aiProvider } = req.body;
+    
+    if (!devices || devices.length === 0) {
+      return res.status(400).json({ success: false, error: 'No devices specified' });
+    }
+    
+    let finalCommand = command;
+    if (useAI) {
+      finalCommand = await convertNaturalLanguageToCommand(command, devices, aiProvider);
+    }
+    
+    // Check if command has multiple lines (sequential execution)
+    const hasMultipleCommands = finalCommand.includes('\n');
+    
+    let result;
+    if (hasMultipleCommands) {
+      console.log(`Detected multi-step command, using sequential execution`);
+      result = await executeCommandsSequentially(devices, finalCommand, null);
+    } else {
+      result = await executeCommand(devices, finalCommand, null);
+    }
+    
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+app.post('/api/convert-command', async (req, res) => {
+  try {
+    const { text, devices, provider } = req.body;
+    const command = await convertNaturalLanguageToCommand(text, devices || [], provider);
+    res.json({ success: true, command });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Connect to device endpoint
+app.post('/api/devices/connect', async (req, res) => {
+  try {
+    const { device } = req.body;
+    log.debug(`📡 Connect request received for device:`, device);
+    
+    if (!device) {
+      console.error('❌ No device provided in request');
+      return res.status(400).json({ success: false, error: 'No device provided' });
+    }
+    
+    if (!device.name || !device.udid) {
+      console.error('❌ Invalid device object:', device);
+      return res.status(400).json({ success: false, error: 'Invalid device object' });
+    }
+    
+    const result = await connectToDevice(device);
+    log.debug(`✅ Connect result:`, result);
+    res.json(result);
+  } catch (error) {
+    console.error(`❌ Connect error:`, error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Disconnect from device endpoint
+app.post('/api/devices/disconnect', async (req, res) => {
+  try {
+    const { device } = req.body;
+    const result = await disconnectFromDevice(device);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Disconnect all devices endpoint
+app.post('/api/devices/disconnect-all', async (req, res) => {
+  try {
+    console.log(`🔌 Disconnecting ALL devices...`);
+    
+    // Get all connected devices
+    const devicesToDisconnect = connectedDevices.filter(d => d.status === 'online');
+    
+    if (devicesToDisconnect.length === 0) {
+      return res.json({ 
+        success: true, 
+        message: 'No devices to disconnect' 
+      });
+    }
+    
+    console.log(`📱 Disconnecting ${devicesToDisconnect.length} device(s)...`);
+    
+    // Disconnect all devices in parallel
+    const disconnectPromises = devicesToDisconnect.map(device => disconnectFromDevice(device));
+    await Promise.all(disconnectPromises);
+    
+    console.log(`✅ All devices disconnected`);
+    
+    res.json({ 
+      success: true, 
+      message: `Disconnected ${devicesToDisconnect.length} device(s)`,
+      count: devicesToDisconnect.length
+    });
+  } catch (error) {
+    console.error(`❌ Error disconnecting all devices:`, error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+
+// New endpoints for AI provider management
+app.get('/api/ai/providers', (req, res) => {
+  try {
+    const providers = aiManager.getAvailableProviders();
+    const current = aiManager.getCurrentProvider();
+    res.json({ success: true, providers, current: current.id });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+app.post('/api/ai/provider', (req, res) => {
+  try {
+    const { provider } = req.body;
+    const success = aiManager.setProvider(provider);
+    if (success) {
+      res.json({ success: true, provider });
+    } else {
+      res.status(400).json({ success: false, error: 'Invalid or unavailable provider' });
+    }
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Settings API - Get API configuration
+app.get('/api/settings/api-config', async (req, res) => {
+  try {
+    const configPath = path.join(__dirname, '../../.env');
+    let config = {
+      provider: process.env.AI_PROVIDER || 'gemini',
+      model: process.env.AI_MODEL || '',
+      openai_api_key: process.env.OPENAI_API_KEY || '',
+      gemini_api_key: process.env.GEMINI_API_KEY || '',
+      claude_api_key: process.env.CLAUDE_API_KEY || '',
+      github_token: process.env.GITHUB_TOKEN || '',
+      groq_api_key: process.env.GROQ_API_KEY || '',
+      cohere_api_key: process.env.COHERE_API_KEY || '',
+      mistral_api_key: process.env.MISTRAL_API_KEY || '',
+    };
+    
+    // Try to read from .env file if exists
+    try {
+      const envContent = await fs.readFile(configPath, 'utf-8');
+      const lines = envContent.split('\n');
+      lines.forEach(line => {
+        const [key, value] = line.split('=');
+        if (key && value) {
+          const trimmedKey = key.trim();
+          const trimmedValue = value.trim();
+          if (trimmedKey === 'AI_PROVIDER') config.provider = trimmedValue;
+          if (trimmedKey === 'AI_MODEL') config.model = trimmedValue;
+          if (trimmedKey === 'OPENAI_API_KEY') config.openai_api_key = trimmedValue;
+          if (trimmedKey === 'GEMINI_API_KEY') config.gemini_api_key = trimmedValue;
+          if (trimmedKey === 'CLAUDE_API_KEY') config.claude_api_key = trimmedValue;
+          if (trimmedKey === 'GITHUB_TOKEN') config.github_token = trimmedValue;
+          if (trimmedKey === 'GROQ_API_KEY') config.groq_api_key = trimmedValue;
+          if (trimmedKey === 'COHERE_API_KEY') config.cohere_api_key = trimmedValue;
+          if (trimmedKey === 'MISTRAL_API_KEY') config.mistral_api_key = trimmedValue;
+        }
+      });
+    } catch (err) {
+      // .env doesn't exist, return defaults
+    }
+    
+    // Mask API keys for security - only show last 4 characters
+    const maskKey = (key) => {
+      if (!key || key.length < 8) return '';
+      return '•'.repeat(key.length - 4) + key.slice(-4);
+    };
+    
+    res.json({
+      provider: config.provider,
+      model: config.model,
+      openai_api_key: maskKey(config.openai_api_key),
+      gemini_api_key: maskKey(config.gemini_api_key),
+      claude_api_key: maskKey(config.claude_api_key),
+      github_token: maskKey(config.github_token),
+      groq_api_key: maskKey(config.groq_api_key),
+      cohere_api_key: maskKey(config.cohere_api_key),
+      mistral_api_key: maskKey(config.mistral_api_key),
+      has_openai_key: !!config.openai_api_key,
+      has_gemini_key: !!config.gemini_api_key,
+      has_claude_key: !!config.claude_api_key,
+      has_github_token: !!config.github_token,
+      has_groq_key: !!config.groq_api_key,
+      has_cohere_key: !!config.cohere_api_key,
+      has_mistral_key: !!config.mistral_api_key,
+    });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Settings API - Save API configuration
+app.post('/api/settings/api-config', async (req, res) => {
+  try {
+    const { 
+      provider, 
+      model,
+      openai_api_key, 
+      gemini_api_key, 
+      claude_api_key,
+      github_token,
+      groq_api_key,
+      cohere_api_key,
+      mistral_api_key
+    } = req.body;
+    
+    const configPath = path.join(__dirname, '../../.env');
+    
+    let envContent = `# AI Provider Configuration\nAI_PROVIDER=${provider}\n`;
+    if (model) {
+      envContent += `AI_MODEL=${model}\n`;
+    }
+    if (openai_api_key) {
+      envContent += `OPENAI_API_KEY=${openai_api_key}\n`;
+    }
+    if (gemini_api_key) {
+      envContent += `GEMINI_API_KEY=${gemini_api_key}\n`;
+    }
+    if (claude_api_key) {
+      envContent += `CLAUDE_API_KEY=${claude_api_key}\n`;
+    }
+    if (github_token) {
+      envContent += `GITHUB_TOKEN=${github_token}\n`;
+    }
+    if (groq_api_key) {
+      envContent += `GROQ_API_KEY=${groq_api_key}\n`;
+    }
+    if (cohere_api_key) {
+      envContent += `COHERE_API_KEY=${cohere_api_key}\n`;
+    }
+    if (mistral_api_key) {
+      envContent += `MISTRAL_API_KEY=${mistral_api_key}\n`;
+    }
+    
+    // Add WDA path if exists
+    if (process.env.WDA_PATH) {
+      envContent += `WDA_PATH=${process.env.WDA_PATH}\n`;
+    }
+    
+    await fs.writeFile(configPath, envContent);
+    
+    // Update environment variables
+    process.env.AI_PROVIDER = provider;
+    if (model) process.env.AI_MODEL = model;
+    if (openai_api_key) process.env.OPENAI_API_KEY = openai_api_key;
+    if (gemini_api_key) process.env.GEMINI_API_KEY = gemini_api_key;
+    if (claude_api_key) process.env.CLAUDE_API_KEY = claude_api_key;
+    if (github_token) process.env.GITHUB_TOKEN = github_token;
+    if (groq_api_key) process.env.GROQ_API_KEY = groq_api_key;
+    if (cohere_api_key) process.env.COHERE_API_KEY = cohere_api_key;
+    if (mistral_api_key) process.env.MISTRAL_API_KEY = mistral_api_key;
+    
+    // Reinitialize AI manager with new config
+    aiManager.provider = provider;
+    if (model) aiManager.model = model;
+    aiManager.initializeProviders();
+    
+    res.json({ success: true, message: 'API configuration saved' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Settings API - Get available AI providers and their models
+app.get('/api/settings/ai-providers', (req, res) => {
+  try {
+    const { AI_PROVIDERS_CONFIG } = require('./aiProvidersConfig');
+    res.json({ success: true, providers: AI_PROVIDERS_CONFIG });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Settings API - Get devices configuration
+app.get('/api/settings/devices', async (req, res) => {
+  try {
+    const devices = await loadDeviceConfig();
+    res.json({ success: true, devices });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Settings API - Save devices configuration
+app.post('/api/settings/devices', async (req, res) => {
+  try {
+    const { devices } = req.body;
+    
+    // Format: device_name,udid,ip_address,platform,type
+    let content = '# Device Configuration (Auto-updated)\n';
+    content += '# Format: device_name,udid,ip_address,platform,type\n';
+    content += '# Platform: ios | android\n';
+    content += '# Type: usb | wireless\n';
+    content += '# \n';
+    content += '# 🔌 USB DEVICES: Automatically detected and saved here\n';
+    content += '#    - No configuration needed for USB connection\n';
+    content += '#    - Add IP address to enable wireless support later\n';
+    content += '#\n';
+    content += '# 📡 WIRELESS DEVICES: Manually add with IP address\n';
+    content += '#    - Format: device_name,udid,ip_address,platform,wireless\n';
+    content += '#    - iOS: Device must be paired in Xcode, WebDriverAgent running\n';
+    content += '#    - Android: Enable wireless ADB first\n';
+    content += '#\n';
+    content += '# Example entries:\n';
+    content += '# MyiPhone,00008130-001A45C83ED8402E,,ios,usb           (iOS USB - auto-detected)\n';
+    content += '# MyiPad,00008140-002B24361E41901C,192.168.1.100,ios,wireless  (iOS Wireless)\n';
+    content += '# Pixel8,1A2B3C4D5E6F,,android,usb                      (Android USB - auto-detected)\n';
+    content += '# GalaxyS23,ABCD1234,192.168.1.150,android,wireless     (Android Wireless)\n\n';
+    
+    devices.forEach(device => {
+      const ip = device.ip || '';
+      const platform = device.platform || 'ios';
+      const type = device.type || device.connectionType || (ip ? 'wireless' : 'usb');
+      content += `${device.name},${device.udid},${ip},${platform},${type}\n`;
+    });
+    
+    await fs.writeFile(DEVICE_CONFIG, content);
+    
+    res.json({ success: true, message: 'Devices configuration saved' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Get app presets
+app.get('/api/apps/presets', async (req, res) => {
+  try {
+    const content = await fs.readFile(APPS_CONFIG, 'utf-8');
+    const apps = content
+      .split('\n')
+      .filter(line => line.trim() && !line.startsWith('#'))
+      .map(line => {
+        const [name, packageId] = line.split(',');
+        return { name: name.trim(), packageId: packageId.trim() };
+      });
+    
+    res.json({ success: true, apps });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Get locators from device's current screen
+app.post('/api/locators', async (req, res) => {
+  try {
+    const { deviceName } = req.body;
+    
+    if (!deviceName) {
+      return res.status(400).json({ success: false, error: 'Device name required' });
+    }
+    
+    console.log(`\n🔍 API: Getting locators for device: ${deviceName}`);
+    
+    // Find the device info
+    const device = connectedDevices.find(d => d.name === deviceName);
+    if (!device) {
+      return res.status(404).json({ success: false, error: 'Device not found' });
+    }
+    
+    // For Android devices, ensure UIAutomator2 session exists
+    if (device.platform === 'android') {
+      const session = androidSessions.get(device.udid);
+      if (!session) {
+        console.log(`⚠️ No UIAutomator2 session for ${deviceName}, auto-connecting...`);
+        
+        // Auto-connect the device
+        try {
+          const connectResult = await connectDevice(deviceName);
+          if (!connectResult.success) {
+            return res.status(500).json({ 
+              success: false, 
+              error: 'Failed to connect device. Please use the Connect button first.' 
+            });
+          }
+          console.log(`✅ Auto-connected ${deviceName} for getLocators`);
+          // Wait a moment for session to stabilize
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        } catch (err) {
+          return res.status(500).json({ 
+            success: false, 
+            error: `Auto-connection failed: ${err.message}` 
+          });
+        }
+      }
+    }
+    
+    // Execute getLocators command - this uses the fast shell script implementation
+    const result = await executeCommand([deviceName], 'getLocators', null);
+    
+    console.log(`Result success: ${result.success}`);
+    console.log(`Results array length: ${result.results?.length || 0}`);
+    
+    if (result.success && result.results) {
+      let output = '';
+      
+      // executeCommand returns: { success, results: [scriptResults] }
+      // scriptResults is from executeAndroidDevices/executeWithScript
+      // Structure: { status: 'fulfilled', value: { success, results: [allSettledResults] } }
+      // allSettledResults contains: { status: 'fulfilled', value: { success, output, device } }
+      
+      for (const scriptResult of result.results) {
+        console.log(`Script result:`, scriptResult);
+        
+        // Check if scriptResult has value.results (fulfilled promise)
+        if (scriptResult.status === 'fulfilled' && scriptResult.value && scriptResult.value.results) {
+          // This is the result from executeAndroidDevices/executeWithScript
+          for (const r of scriptResult.value.results) {
+            console.log(`Result status: ${r.status}`);
+            if (r.status === 'fulfilled' && r.value) {
+              // Check if it's a successful execution
+              if (r.value.success && r.value.output) {
+                output = r.value.output;
+                console.log(`✅ Found output: ${output.length} characters`);
+                break;
+              } else if (r.value.error) {
+                // Script executed but returned an error
+                console.log(`❌ Script error:`, r.value.error);
+                return res.status(500).json({ 
+                  success: false, 
+                  error: 'Failed to get UI elements. Please ensure UIAutomator2 is installed for Android devices.'
+                });
+              }
+            }
+          }
+        }
+        if (output) break;
+      }
+      
+      if (!output) {
+        console.log('❌ No output found in results');
+        console.log('Full result structure:', JSON.stringify(result, null, 2));
+        return res.status(500).json({ success: false, error: 'No output received from device' });
+      }
+      
+      // Parse the output into locator objects
+      const locators = parseLocatorsOutput(output);
+      console.log(`✅ Parsed ${locators.length} locators`);
+      
+      // Filter out empty/invalid locators
+      const validLocators = locators.filter(loc => loc.name || loc.label || loc.text);
+      console.log(`✅ Filtered to ${validLocators.length} valid locators`);
+      
+      res.json({ success: true, locators: validLocators });
+    } else {
+      console.log('❌ Command execution failed');
+      res.status(500).json({ success: false, error: 'Failed to get locators' });
+    }
+  } catch (error) {
+    console.error(`❌ API error:`, error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Click on a locator
+app.post('/api/locators/click', async (req, res) => {
+  try {
+    const { deviceName, locatorName, x, y } = req.body;
+    
+    if (!deviceName) {
+      return res.status(400).json({ success: false, error: 'Device name required' });
+    }
+    
+    let command;
+    // If coordinates are provided, use them directly
+    if (x !== undefined && y !== undefined) {
+      command = `tap ${x},${y}`;
+      console.log(`\n🖱️ API: Tapping at coordinates (${x},${y}) on device: ${deviceName}`);
+    } else if (locatorName) {
+      command = `click "${locatorName}"`;
+      console.log(`\n🖱️ API: Clicking locator "${locatorName}" on device: ${deviceName}`);
+    } else {
+      return res.status(400).json({ success: false, error: 'Locator name or coordinates required' });
+    }
+    
+    // Execute click command
+    const result = await executeCommand([deviceName], command, null);
+    
+    if (result.success) {
+      res.json({ success: true, message: 'Tap executed successfully' });
+    } else {
+      res.status(500).json({ success: false, error: 'Failed to execute tap' });
+    }
+  } catch (error) {
+    console.error('❌ Tap error:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Helper function to parse locators output
+function parseLocatorsOutput(output) {
+  console.log('🔍 Parsing locators output...');
+  console.log('Output length:', output?.length || 0);
+  
+  const locators = [];
+  if (!output) {
+    console.log('❌ No output to parse');
+    return locators;
+  }
+  
+  const lines = output.split('\n');
+  console.log('Total lines:', lines.length);
+  
+  for (const line of lines) {
+    // New format: "  1. 📍 ButtonName    │ [Button] │ Label:LabelText │ Val:ValueText │ @ (x,y) WxH │ ✓Vis ✓En"
+    // Look for lines with numbered locators starting with 📍
+    if (line.includes('📍') && /^\s*\d+\./.test(line)) {
+      try {
+        const locator = {};
+        
+        // Extract index number
+        const indexMatch = line.match(/^\s*(\d+)\./);
+        if (indexMatch) locator.index = parseInt(indexMatch[1]);
+        
+        // Split by pipe separator if present (new format), otherwise use old logic
+        if (line.includes('│')) {
+          const parts = line.split('│').map(p => p.trim());
+          
+          // Part 0: "1. 📍 ButtonName"
+          const nameMatch = parts[0].match(/📍\s+(.+)/);
+          if (nameMatch) {
+            locator.name = nameMatch[1].trim();
+            locator.text = nameMatch[1].trim();
+          }
+          
+          // Part 1: "[Button]" or "[TextView]"
+          const typeMatch = parts[1] ? parts[1].match(/\[([^\]]+)\]/) : null;
+          if (typeMatch) locator.type = typeMatch[1].trim();
+          
+          // Process remaining parts for Label, Val, ID, coordinates, flags
+          for (let i = 2; i < parts.length; i++) {
+            const part = parts[i];
+            
+            // Label:...
+            if (part.includes('Label:')) {
+              const labelMatch = part.match(/Label:([^\s]+)/);
+              if (labelMatch) locator.label = labelMatch[1];
+            }
+            
+            // Val:...
+            if (part.includes('Val:')) {
+              const valueMatch = part.match(/Val:([^\s]+)/);
+              if (valueMatch) locator.value = valueMatch[1];
+            }
+            
+            // ID:...
+            if (part.includes('ID:')) {
+              const idMatch = part.match(/ID:([^\s]+)/);
+              if (idMatch) locator.resourceId = idMatch[1];
+            }
+            
+            // @ (x,y) WxH
+            if (part.includes('@')) {
+              const coordMatch = part.match(/@\s*\((\d+),(\d+)\)\s*(\d+)x(\d+)/);
+              if (coordMatch) {
+                locator.x = parseInt(coordMatch[1]);
+                locator.y = parseInt(coordMatch[2]);
+                locator.width = parseInt(coordMatch[3]);
+                locator.height = parseInt(coordMatch[4]);
+                locator.coordinates = `(${locator.x},${locator.y}) ${locator.width}x${locator.height}`;
+              }
+            }
+            
+            // Flags
+            if (part.includes('✓Vis')) locator.visible = true;
+            if (part.includes('✓En')) locator.enabled = true;
+            if (part.includes('✓Click')) locator.clickable = true;
+          }
+        } else {
+          // Old format fallback
+          const nameMatch = line.match(/📍\s+([^\[]+?)(?:\s*\[|\s*Label)/);
+          if (nameMatch) {
+            locator.name = nameMatch[1].trim();
+            locator.text = nameMatch[1].trim();
+          }
+          
+          const typeMatch = line.match(/\[([^\]]+)\]/);
+          if (typeMatch) locator.type = typeMatch[1].trim();
+          
+          const labelMatch = line.match(/Label:([^\s]+?)(?:\s*Val:|\s*@|\s*✓)/);
+          if (labelMatch) locator.label = labelMatch[1].trim();
+          
+          const valueMatch = line.match(/Val:([^\s]+?)(?:\s*@|\s*✓)/);
+          if (valueMatch) locator.value = valueMatch[1].trim();
+          
+          const coordMatch = line.match(/@\s*\((\d+),(\d+)\)\s*(\d+)x(\d+)/);
+          if (coordMatch) {
+            locator.x = parseInt(coordMatch[1]);
+            locator.y = parseInt(coordMatch[2]);
+            locator.width = parseInt(coordMatch[3]);
+            locator.height = parseInt(coordMatch[4]);
+            locator.coordinates = `(${locator.x},${locator.y}) ${locator.width}x${locator.height}`;
+          }
+          
+          const idMatch = line.match(/ID:([^\s]+)/);
+          if (idMatch) locator.resourceId = idMatch[1].trim();
+          
+          locator.visible = line.includes('✓Vis');
+          locator.enabled = line.includes('✓En');
+        }
+        
+        // Only add if we have meaningful data
+        if (locator.name || locator.label || locator.text) {
+          console.log('✅ Parsed locator:', locator);
+          locators.push(locator);
+        }
+      } catch (e) {
+        // Skip malformed lines
+        console.error('Error parsing locator line:', line, e);
+      }
+    }
+  }
+  
+  console.log(`✅ Total parsed locators: ${locators.length}`);
+  return locators;
+}
+
+// WebSocket handling
+wss.on('connection', (ws) => {
+  console.log('New WebSocket connection');
+  
+  ws.on('message', async (message) => {
+    try {
+      const data = JSON.parse(message);
+      
+      switch (data.type) {
+        case 'execute_command':
+          const { devices, command, useAI, aiProvider } = data;
+          
+          console.log(`\n${'*'.repeat(60)}`);
+          log.debug(`WEBSOCKET: Received execute_command`);
+          console.log(`Devices received: [${devices.join(', ')}]`);
+          console.log(`Command: "${command}"`);
+          console.log(`Use AI: ${useAI}`);
+          if (aiProvider) console.log(`AI Provider: ${aiProvider}`);
+          console.log(`${'*'.repeat(60)}\n`);
+          
+          let finalCommand = command;
+          
+          if (useAI) {
+            try {
+              finalCommand = await convertNaturalLanguageToCommand(command, devices, aiProvider);
+              console.log(`✅ AI converted command to:\n${finalCommand}`);
+              ws.send(JSON.stringify({
+                type: 'command_converted',
+                original: command,
+                converted: finalCommand,
+                provider: aiProvider || aiManager.provider
+              }));
+            } catch (error) {
+              console.error(`❌ AI conversion failed: ${error.message}`);
+              
+              // Send error to frontend - DO NOT execute command
+              ws.send(JSON.stringify({
+                type: 'ai_error',
+                error: error.message,
+                original: command
+              }));
+              
+              // Stop execution - don't run unconverted commands
+              return;
+            }
+          } else {
+            console.log(`ℹ️  AI not enabled, using command as-is`);
+          }
+          
+          // Check if command has multiple lines (sequential execution)
+          const hasMultipleCommands = finalCommand.includes('\n');
+          
+          if (hasMultipleCommands) {
+            console.log(`Detected multi-step command, using sequential execution`);
+            executeCommandsSequentially(devices, finalCommand, ws)
+              .then(result => {
+                console.log(`Sequential execution completed`);
+                ws.send(JSON.stringify({
+                  type: 'command_complete',
+                  result
+                }));
+              })
+              .catch(error => {
+                console.error(`Sequential execution failed: ${error.message}`);
+                ws.send(JSON.stringify({
+                  type: 'command_error',
+                  error: error.message
+                }));
+              });
+          } else {
+            log.debug(`Calling executeCommand with ${devices.length} device(s)...`);
+            executeCommand(devices, finalCommand, ws)
+              .then(result => {
+                console.log(`executeCommand completed successfully`);
+                
+                // Record command if recording is active
+                if (isRecording) {
+                  recordCommand(devices, command, useAI, finalCommand);
+                }
+                
+                ws.send(JSON.stringify({
+                  type: 'command_complete',
+                  result
+                }));
+              })
+              .catch(error => {
+                console.error(`executeCommand failed: ${error.message}`);
+                ws.send(JSON.stringify({
+                  type: 'command_error',
+                  error: error.message
+                }));
+              });
+          }
+          break;
+        
+        case 'start_recording':
+          const startResult = await startRecording(data.name, data.devices);
+          ws.send(JSON.stringify({
+            type: 'recording_started',
+            ...startResult
+          }));
+          break;
+        
+        case 'stop_recording':
+          const stopResult = await stopRecording();
+          ws.send(JSON.stringify({
+            type: 'recording_stopped',
+            ...stopResult
+          }));
+          break;
+        
+        case 'replay_recording':
+          const { filename, targetDevices } = data;
+          
+          ws.send(JSON.stringify({
+            type: 'command_output',
+            data: `\n🎬 Starting replay: ${filename}\n\n`,
+            devices: targetDevices
+          }));
+          
+          replayRecording(filename, targetDevices, ws)
+            .then(result => {
+              ws.send(JSON.stringify({
+                type: 'replay_complete',
+                ...result
+              }));
+            })
+            .catch(error => {
+              ws.send(JSON.stringify({
+                type: 'replay_error',
+                error: error.message
+              }));
+            });
+          break;
+        
+        case 'stop_replay':
+          if (isReplaying) {
+            replayAborted = true;
+            ws.send(JSON.stringify({
+              type: 'command_output',
+              data: '\n⏹️  Stopping replay...\n'
+            }));
+          }
+          break;
+          
+        case 'refresh_devices':
+          const updatedDevices = await discoverDevices();
+          ws.send(JSON.stringify({
+            type: 'devices_updated',
+            devices: updatedDevices
+          }));
+          break;
+          
+        case 'get_ai_providers':
+          ws.send(JSON.stringify({
+            type: 'ai_providers',
+            providers: aiManager.getAvailableProviders(),
+            current: aiManager.provider
+          }));
+          break;
+          
+        case 'set_ai_provider':
+          const success = aiManager.setProvider(data.provider);
+          ws.send(JSON.stringify({
+            type: 'ai_provider_set',
+            success,
+            provider: data.provider
+          }));
+          break;
+      }
+    } catch (error) {
+      ws.send(JSON.stringify({
+        type: 'error',
+        message: error.message
+      }));
+    }
+  });
+  
+  ws.on('close', () => {
+    console.log('WebSocket connection closed');
+  });
+  
+  // Send initial device list
+  discoverDevices().then(devices => {
+    ws.send(JSON.stringify({
+      type: 'devices_updated',
+      devices
+    }));
+  });
+});
+
+// Android UIAutomator2 Installation
+app.post('/api/android/install-uiautomator2', async (req, res) => {
+  const { device } = req.body;
+  
+  if (!device) {
+    return res.status(400).json({ success: false, error: 'Device name required' });
+  }
+  
+  try {
+    console.log(`📥 Installing UIAutomator2 on ${device}...`);
+    
+    // Find device UDID
+    const deviceObj = connectedDevices.find(d => d.name === device);
+    if (!deviceObj) {
+      return res.json({
+        success: false,
+        error: 'Device not found or not connected'
+      });
+    }
+    
+    // Use the helper function
+    const result = await installUIAutomator2(deviceObj.udid, device);
+    
+    res.json(result);
+    
+  } catch (error) {
+    console.error('❌ UIAutomator2 installation error:', error.message);
+    res.json({
+      success: false,
+      error: error.message,
+      suggestion: 'Please install manually using: npm install -g appium-uiautomator2-driver'
+    });
+  }
+});
+
+// ============================================
+// Recording & Replay API Endpoints
+// ============================================
+
+// Start recording
+app.post('/api/recording/start', async (req, res) => {
+  try {
+    const { name, devices } = req.body;
+    const result = await startRecording(name, devices);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Stop recording
+app.post('/api/recording/stop', async (req, res) => {
+  try {
+    const result = await stopRecording();
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Get recording status
+app.get('/api/recording/status', (req, res) => {
+  res.json({
+    isRecording,
+    recording: currentRecording
+  });
+});
+
+// List all recordings
+app.get('/api/recordings', async (req, res) => {
+  try {
+    const recordings = await listRecordings();
+    res.json({ success: true, recordings });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Get specific recording
+app.get('/api/recordings/:filename', async (req, res) => {
+  try {
+    const recording = await loadRecording(req.params.filename);
+    res.json({ success: true, recording });
+  } catch (error) {
+    res.status(404).json({ success: false, error: 'Recording not found' });
+  }
+});
+
+// Delete recording
+app.delete('/api/recordings/:filename', async (req, res) => {
+  try {
+    await deleteRecording(req.params.filename);
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Update recording
+app.put('/api/recordings/:filename', async (req, res) => {
+  try {
+    const { filename } = req.params;
+    const updatedRecording = req.body;
+    
+    const filepath = path.join(RECORDINGS_DIR, filename);
+    await fs.writeFile(filepath, JSON.stringify(updatedRecording, null, 2));
+    
+    res.json({ success: true, recording: updatedRecording });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Save new recording
+app.post('/api/recordings/save', async (req, res) => {
+  try {
+    const { name, commands, date, type } = req.body;
+    
+    if (!name || !commands) {
+      return res.status(400).json({ success: false, error: 'Name and commands required' });
+    }
+    
+    // Create filename from name (sanitize)
+    const sanitizedName = name.replace(/[^a-z0-9_-]/gi, '_');
+    const filename = `${sanitizedName}_${Date.now()}.json`;
+    const filepath = path.join(RECORDINGS_DIR, filename);
+    
+    const recording = {
+      name,
+      commands,
+      date: date || new Date().toISOString(),
+      type: type || 'manual'
+    };
+    
+    await fs.writeFile(filepath, JSON.stringify(recording, null, 2));
+    
+    res.json({ success: true, filename, recording });
+  } catch (error) {
+    console.error('Error saving recording:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Replay recording
+app.post('/api/recording/replay', async (req, res) => {
+  try {
+    const { filename, devices } = req.body;
+    
+    if (!filename) {
+      return res.status(400).json({ success: false, error: 'Filename required' });
+    }
+    
+    if (!devices || devices.length === 0) {
+      return res.status(400).json({ success: false, error: 'Target devices required' });
+    }
+    
+    // Start replay in background, send immediate response
+    res.json({ success: true, message: 'Replay started' });
+    
+    // Replay will send updates via WebSocket
+    // This is handled by WebSocket message 'replay_recording'
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Screenshots API
+app.get('/api/screenshots', async (req, res) => {
+  try {
+    // Ensure screenshots directory exists
+    await fs.mkdir(SCREENSHOTS_DIR, { recursive: true });
+    
+    const files = await fs.readdir(SCREENSHOTS_DIR);
+    const screenshots = files
+      .filter(f => f.endsWith('.png'))
+      .map(f => {
+        const stat = require('fs').statSync(path.join(SCREENSHOTS_DIR, f));
+        return {
+          filename: f,
+          path: `/api/screenshots/${f}`,
+          size: stat.size,
+          timestamp: stat.mtime.getTime(),
+          created: stat.mtime
+        };
+      })
+      .sort((a, b) => b.timestamp - a.timestamp);
+    
+    res.json({ success: true, screenshots });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Serve screenshot files
+app.get('/api/screenshots/:filename', (req, res) => {
+  const filepath = path.join(SCREENSHOTS_DIR, req.params.filename);
+  res.sendFile(filepath, (err) => {
+    if (err) {
+      res.status(404).json({ success: false, error: 'Screenshot not found' });
+    }
+  });
+});
+
+// Delete screenshot
+app.delete('/api/screenshots/:filename', async (req, res) => {
+  try {
+    const filepath = path.join(SCREENSHOTS_DIR, req.params.filename);
+    await fs.unlink(filepath);
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// List installed apps on device
+app.post('/api/apps/list', async (req, res) => {
+  try {
+    const { devices } = req.body;
+    
+    if (!devices || devices.length === 0) {
+      return res.status(400).json({ success: false, error: 'Device selection required' });
+    }
+    
+    const deviceObjects = connectedDevices.filter(d => 
+      devices.includes(d.name) || devices.includes(d.udid) || devices.includes(d.serial)
+    );
+    
+    if (deviceObjects.length === 0) {
+      return res.status(400).json({ success: false, error: 'No connected devices found' });
+    }
+    
+    const results = {};
+    
+    for (const device of deviceObjects) {
+      try {
+        let apps = [];
+        
+        if (device.platform === 'android') {
+          // List Android apps
+          const { execSync } = require('child_process');
+          const serial = device.udid || device.serial;
+          const output = execSync(`adb -s ${serial} shell pm list packages -3`, { encoding: 'utf-8' });
+          apps = output
+            .split('\n')
+            .filter(line => line.startsWith('package:'))
+            .map(line => line.replace('package:', '').trim())
+            .filter(pkg => pkg)
+            .sort();
+        } else if (device.platform === 'ios') {
+          // List iOS apps - requires ideviceinstaller
+          const { execSync } = require('child_process');
+          const udid = device.udid;
+          try {
+            // Try new syntax first (ideviceinstaller list)
+            let output;
+            try {
+              output = execSync(`ideviceinstaller -u ${udid} list --user`, { encoding: 'utf-8', timeout: 30000 });
+            } catch (e) {
+              // Fallback to old syntax
+              output = execSync(`ideviceinstaller -u ${udid} -l`, { encoding: 'utf-8', timeout: 30000 });
+            }
+            
+            // Parse output - format is "BundleID - AppName" or CFBundleIdentifier format
+            apps = output
+              .split('\n')
+              .filter(line => {
+                const trimmed = line.trim();
+                // Skip empty lines, Total: line, and CSV header
+                return trimmed && 
+                       !trimmed.startsWith('Total:') &&
+                       !trimmed.startsWith('CFBundleIdentifier');
+              })
+              .map(line => {
+                // Try different formats
+                if (line.includes(' - ')) {
+                  const match = line.match(/^(.+?)\s+-\s+(.+?)$/);
+                  return match ? { id: match[1].trim(), name: match[2].trim() } : null;
+                } else if (line.includes(',')) {
+                  // Format: "BundleID", "Version", "Name"
+                  const parts = line.split(',').map(p => p.trim().replace(/"/g, ''));
+                  return parts.length >= 3 ? { id: parts[0], name: parts[2] } : null;
+                } else if (line.match(/^[a-zA-Z0-9.-]+$/)) {
+                  // Just bundle ID
+                  return { id: line.trim(), name: line.trim() };
+                }
+                return null;
+              })
+              .filter(app => app)
+              .sort((a, b) => a.name.localeCompare(b.name));
+              
+            if (apps.length === 0) {
+              apps = [{ error: 'No user apps found or unable to parse output' }];
+            }
+          } catch (error) {
+            console.error('iOS apps list error:', error.message);
+            apps = [{ error: `Failed to list apps: ${error.message}` }];
+          }
+        }
+        
+        results[device.name] = {
+          success: true,
+          platform: device.platform,
+          apps: apps,
+          count: Array.isArray(apps) ? apps.length : 0
+        };
+      } catch (error) {
+        results[device.name] = {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+    
+    res.json({ success: true, results });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Get app info
+app.post('/api/apps/info', async (req, res) => {
+  try {
+    const { device, bundleId } = req.body;
+    
+    if (!device || !bundleId) {
+      return res.status(400).json({ success: false, error: 'Device and bundle ID required' });
+    }
+    
+    const deviceObj = discoveredDevices.find(d => d.name === device);
+    if (!deviceObj) {
+      return res.status(404).json({ success: false, error: 'Device not found' });
+    }
+    
+    const { execSync } = require('child_process');
+    let appInfo = {};
+    
+    try {
+      if (deviceObj.platform === 'android') {
+        // Get Android app info
+        const serial = deviceObj.udid || deviceObj.serial;
+        
+        // Get app version
+        try {
+          const versionOutput = execSync(
+            `adb -s ${serial} shell dumpsys package ${bundleId} | grep versionName`,
+            { encoding: 'utf-8', timeout: 10000 }
+          );
+          const versionMatch = versionOutput.match(/versionName=([^\s]+)/);
+          if (versionMatch) {
+            appInfo.version = versionMatch[1];
+          }
+        } catch (e) {
+          appInfo.version = 'Unknown';
+        }
+        
+        // Get app label/name
+        try {
+          const labelOutput = execSync(
+            `adb -s ${serial} shell dumpsys package ${bundleId} | grep -A 1 "applicationInfo"`,
+            { encoding: 'utf-8', timeout: 10000 }
+          );
+          appInfo.name = bundleId;
+        } catch (e) {
+          appInfo.name = bundleId;
+        }
+        
+        // Get install location
+        try {
+          const pathOutput = execSync(
+            `adb -s ${serial} shell pm path ${bundleId}`,
+            { encoding: 'utf-8', timeout: 10000 }
+          );
+          appInfo.path = pathOutput.replace('package:', '').trim();
+        } catch (e) {
+          appInfo.path = 'Unknown';
+        }
+        
+        appInfo.bundleId = bundleId;
+        appInfo.platform = 'Android';
+        
+      } else if (deviceObj.platform === 'ios') {
+        // Get iOS app info
+        const udid = deviceObj.udid;
+        
+        try {
+          // Try to get app info using ideviceinstaller
+          const output = execSync(
+            `ideviceinstaller -u ${udid} list --user | grep "${bundleId}"`,
+            { encoding: 'utf-8', timeout: 10000 }
+          );
+          
+          // Parse CSV format: BundleID, Version, Name
+          const parts = output.split(',').map(p => p.trim().replace(/"/g, ''));
+          if (parts.length >= 3) {
+            appInfo.bundleId = parts[0];
+            appInfo.version = parts[1];
+            appInfo.name = parts[2];
+          } else {
+            appInfo.bundleId = bundleId;
+            appInfo.name = bundleId;
+            appInfo.version = 'Unknown';
+          }
+        } catch (e) {
+          // Fallback
+          appInfo.bundleId = bundleId;
+          appInfo.name = bundleId;
+          appInfo.version = 'Unknown';
+          appInfo.error = 'Could not retrieve detailed info';
+        }
+        
+        appInfo.platform = 'iOS';
+      }
+      
+      res.json({ success: true, appInfo });
+      
+    } catch (error) {
+      res.json({ 
+        success: false, 
+        error: error.message,
+        appInfo: {
+          bundleId: bundleId,
+          platform: deviceObj.platform,
+          error: 'Failed to get app info'
+        }
+      });
+    }
+    
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Upgrade HTTP server to WebSocket
+let server;
+
+function startServer(options = {}) {
+  const port = options.port || PORT;
+  const shouldOpenBrowser = options.browser !== false;
+  const frontendUrl = 'https://devicely-ai.vercel.app';
+  
+  console.log(`Frontend available at: ${frontendUrl}\n`);
+  
+  return new Promise((resolve, reject) => {
+    server = app.listen(port, () => {
+      console.log(`Server running on port ${port}`);
+      console.log(`WebSocket server ready`);
+      
+      // Initial device discovery
+      discoverDevices().then(devices => {
+        console.log(`Discovered ${devices.length} devices`);
+        
+        // Open browser if not disabled
+        if (shouldOpenBrowser) {
+          console.log(`\n🌐 Opening browser to ${frontendUrl}...`);
+          const open = require('open');
+          open(frontendUrl).catch(err => {
+            console.log(`\n📱 Please open ${frontendUrl} in your browser`);
+          });
+        }
+        
+        resolve({ port, devices });
+      }).catch(reject);
+    });
+
+    server.on('upgrade', (request, socket, head) => {
+      wss.handleUpgrade(request, socket, head, (ws) => {
+        wss.emit('connection', ws, request);
+      });
+    });
+
+    server.on('error', reject);
+  });
+}
+
+function stopServer() {
+  return new Promise((resolve) => {
+    if (server) {
+      server.close(resolve);
+    } else {
+      resolve();
+    }
+  });
+}
+
+// Export for CLI usage
+module.exports = {
+  startServer,
+  stopServer
+};
+
+// Start server if run directly (not imported as module)
+if (require.main === module) {
+  startServer().catch(err => {
+    console.error('Failed to start server:', err);
+    process.exit(1);
+  });
+}