devicely 2.2.10 → 2.2.12

package/lib/server.js.bak

@@ -1,3546 +0,0 @@
-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');
-const Logger = require('./logger');
-
-// Initialize logger
-const logger = new Logger('Server');
-
-// Import scriptLoader for encrypted scripts
-let scriptLoader;
-try {
-    scriptLoader = require('./scriptLoader');
-} catch (err) {
-    // Development mode - no encryption
-    scriptLoader = null;
-}
-
-// 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;
-
-// 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));
-// Frontend path: ${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) {
-  const fsSync = require('fs');
-  const os = require('os');
-  const crypto = require('crypto');
-  
-  const filenameWithoutExt = filename.replace(/\.sh$/, '');
-  const encFilename = filenameWithoutExt + '.enc';
-  
-  // List of paths to try in order
-  const pathsToTry = [
-    // Development location (project root) - .sh file
-    { path: path.join(__dirname, '../../', filename), encrypted: false },
-    // NPM package: encrypted .enc file
-    { path: path.join(__dirname, '../scripts/shell/', encFilename), encrypted: true },
-    // NPM package: .sh file (fallback if no encryption)
-    { path: path.join(__dirname, '../scripts/shell/', filename), encrypted: false },
-    // NPM package: compiled binary (fallback)
-    { path: path.join(__dirname, '../scripts/shell/', filenameWithoutExt), encrypted: false },
-  ];
-  
-  for (const { path: scriptPath, encrypted } of pathsToTry) {
-    if (fsSync.existsSync(scriptPath)) {
-      logger.debug(`✅ Found script: ${filename} at ${scriptPath}${encrypted ? ' (encrypted)' : ''}`);
-      
-      // If encrypted, decrypt to temp directory and return temp path
-      if (encrypted && scriptLoader) {
-        const tmpDir = path.join(os.tmpdir(), 'devicely_scripts_' + process.pid);
-        if (!fsSync.existsSync(tmpDir)) {
-          fsSync.mkdirSync(tmpDir, { recursive: true, mode: 0o700 });
-        }
-        
-        const tmpScript = path.join(tmpDir, filename);
-        
-        // Decrypt if not already decrypted
-        if (!fsSync.existsSync(tmpScript)) {
-          try {
-            const content = scriptLoader.decryptScript(scriptPath);
-            fsSync.writeFileSync(tmpScript, content, { mode: 0o755 });
-            logger.debug(`🔓 Decrypted ${filename} to temp directory`);
-          } catch (error) {
-            console.error(`❌ Failed to decrypt ${filename}: ${error.message}`);
-            continue;
-          }
-        }
-        
-        return tmpScript;
-      }
-      
-      return scriptPath;
-    }
-  }
-  
-  console.error(`❌ Script not found: ${filename}`);
-  console.error(`   Searched in:`);
-  pathsToTry.forEach(p => console.error(`   - ${p.path}`));
-  
-  // Return first path as fallback (will fail but with clear error)
-  return pathsToTry[0].path;
-}
-
-// 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) {
-  console.log(`🚀 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
-      }
-    }
-    
-    console.log(`📡 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`);
-
-    // 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');
-      console.log(`✅ Session file updated: ${udid}:${sessionId}:${port}`);
-    } catch (err) {
-      console.error(`⚠️  Failed to update session file: ${err.message}`);
-    }
-    
-    console.log(`✅ UIAutomator2 session created for ${deviceName}`);
-    console.log(`   Session ID: ${sessionId}`);
-    console.log(`   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) {
-  console.log(`🛑 Stopping UIAutomator2 session for ${deviceName} (${udid})...`);
-  
-  try {
-    const session = androidSessions.get(udid);
-    
-    if (!session) {
-      console.log(`⚠️  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}`);
-      console.log(`✅ UIAutomator2 session deleted for ${deviceName}`);
-    } catch (err) {
-      console.log(`⚠️  Could not delete session via HTTP: ${err.message}`);
-    }
-    
-    // Remove port forwarding
-    try {
-      execSync(`adb -s ${udid} forward --remove tcp:${session.port}`);
-      console.log(`✅ 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'));
-      console.log(`✅ 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) {
-      console.log(`  📱 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) => {
-    // separator removed
-    logger.debug(`Device names received: [${deviceNames.join(', ')}]`);
-    console.log(`Command: "${command}"`);
-    // separator removed
-    
-    // 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)
-    );
-
-    logger.debug(`Cache contents:`, connectedDevices.map(d => `${d.name}(${d.status})`).join(', '));
-
-    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.` 
-      });
-    }
-    
-    console.log(`✅ Found ${devices.length} connected devices`);
-    console.log('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');
-
-    const promises = [];
-    
-    // Execute for iOS USB devices
-    if (iosUSBDevices.length > 0) {
-      const names = iosUSBDevices.map(d => d.name);
-      const iosCommand = resolveAppPreset(command, 'ios');
-      logger.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');
-      console.log(`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');
-      logger.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');
-      logger.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) {
-
-      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;
-      
-      logger.debug(`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) => {
-    logger.debug(`\n${'='.repeat(60)}`);
-    logger.debug(`Script: ${path.basename(scriptPath)}`);
-    logger.debug(`Devices: [${deviceNames.join(', ')}]`);
-    logger.debug(`Command: "${command}"`);
-    logger.debug(`${'='.repeat(60)}\n`);
-    
-    // Execute command on each device in parallel
-    const devicePromises = deviceNames.map((deviceName, index) => {
-
-      return new Promise((resolveDevice, rejectDevice) => {
-        // Use -d flag for each device
-        const args = ['-d', deviceName, command];
-        
-        logger.debug(`[${index + 1}/${deviceNames.length}] Executing on: ${deviceName}`);
-        
-        
-        const child = spawn(scriptPath, args, {
-          cwd: path.dirname(scriptPath)
-        });
-        
-        
-        let output = '';
-        let error = '';
-        
-        child.stdout.on('data', (data) => {
-          const text = data.toString();
-          output += text;
-          logger.debug(`[${deviceName}] STDOUT: ${text.trim()}`);
-          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;
-          console.error(`[${deviceName}] STDERR: ${text.trim()}`);
-        });
-        
-        child.on('close', (code) => {
-
-          if (code === 0) {
-            resolveDevice({ success: true, output, device: deviceName });
-          } else {
-            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 });
-        });
-      });
-    });
-    
-    
-    // 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;
-        
-        // separator removed
-
-        // separator removed
-        
-        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) => {
-    logger.debug(`\n${'='.repeat(60)}`);
-    logger.debug(`Script: ${path.basename(scriptPath)}`);
-    logger.debug(`Devices: [${devices.map(d => d.name).join(', ')}]`);
-    logger.debug(`Command: "${command}"`);
-    logger.debug(`${'='.repeat(60)}\n`);
-    
-    // Execute command on each device in parallel
-    const devicePromises = devices.map((device, index) => {
-      logger.debug(`[${index + 1}/${devices.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(' ')];
-        
-        const child = spawn(scriptPath, args, {
-          cwd: path.dirname(scriptPath)
-        });
-        
-        
-        let output = '';
-        let error = '';
-        
-        child.stdout.on('data', (data) => {
-          const text = data.toString();
-          output += text;
-          logger.debug(`[${device.name}] STDOUT: ${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;
-          logger.debug(`[${device.name}] STDERR: ${text.trim()}`);
-        });
-        
-        child.on('close', (code) => {
-
-          if (code === 0) {
-            resolveDevice({ success: true, output, device: device.name });
-          } else {
-            resolveDevice({ success: false, error: error || output, device: device.name });
-          }
-        });
-        
-        child.on('error', (err) => {
-          console.error(`[${device.name}] Process error:`, err);
-          resolveDevice({ success: false, error: err.message, device: device.name });
-        });
-      });
-    });
-    
-    Promise.allSettled(devicePromises)
-      .then(results => {
-        // separator removed
-
-        const successCount = results.filter(r => r.status === 'fulfilled' && r.value.success).length;
-        const failCount = results.length - successCount;
-
-        // separator removed
-        
-        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);
-  
-  // separator removed
-
-  console.log(`Total commands: ${lines.length}`);
-  console.log(`Commands:`, lines);
-  // separator removed
-  
-  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
-        }));
-      }
-    }
-  }
-  
-  // separator removed
-
-  console.log(`Total: ${results.length}, Success: ${results.filter(r => r.success).length}, Failed: ${results.filter(r => !r.success).length}`);
-  // separator removed
-  
-  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;
-    
-    console.log(`Connecting to ${name} (${type}, platform: ${platform})...`);
-    
-    // Handle Android devices differently
-    if (platform === 'android') {
-      console.log(`📱 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) {
-          console.log(`✅ Android device ${name} is connected via ADB`);
-          
-          // Don't set status to 'online' yet - wait for UIAutomator2 confirmation
-          const deviceIndex = connectedDevices.findIndex(d => d.name === name);
-          if (deviceIndex !== -1) {
-            connectedDevices[deviceIndex].status = 'connecting';
-          }
-          
-          // Broadcast connecting status
-          wss.clients.forEach(client => {
-            if (client.readyState === WebSocket.OPEN) {
-              client.send(JSON.stringify({
-                type: 'devices_updated',
-                devices: connectedDevices
-              }));
-            }
-          });
-          
-          // Always ensure UIAutomator2 is installed and ready
-          console.log(`📦 Ensuring UIAutomator2 is installed on ${name}...`);
-          
-          // Check if already installed
-          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 () => {
-            const isInstalled = uiautomatorOutput.includes('io.appium.uiautomator2');
-            
-            if (!isInstalled) {
-              console.log(`📥 UIAutomator2 not found on ${name}, installing...`);
-              // Install UIAutomator2
-              const installResult = await installUIAutomator2(udid, name);
-              
-              if (!installResult.success) {
-                console.log(`⚠️ UIAutomator2 installation failed on ${name}`);
-                resolve({ 
-                  success: true, 
-                  message: `Connected to ${name} - ADB Ready ✅` 
-                });
-                return;
-              }
-            } else {
-              console.log(`✅ UIAutomator2 already installed on ${name}`);
-            }
-            
-            // Check if session already exists for this device
-            const existingSession = androidSessions.get(udid);
-            if (existingSession) {
-              console.log(`♻️  Reusing existing UIAutomator2 session on ${name} (port: ${existingSession.port})`);
-              
-              // Verify session is still valid
-              try {
-                const axios = require('axios');
-                await axios.get(`http://localhost:${existingSession.port}/wd/hub/status`);
-                console.log(`✅ Session verified and working on ${name}`);
-                
-                // Set status to 'online'
-                const deviceIndex = connectedDevices.findIndex(d => d.name === name);
-                if (deviceIndex !== -1) {
-                  connectedDevices[deviceIndex].status = 'online';
-                  
-                  // Broadcast updated status
-                  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} - UIAutomator2 Ready ✅` 
-                });
-                return;
-              } catch (err) {
-                console.log(`⚠️  Existing session invalid, creating new one for ${name}`);
-                androidSessions.delete(udid);
-              }
-            }
-            
-            // Start new UIAutomator2 session
-            console.log(`🚀 Starting new UIAutomator2 session on ${name}...`);
-            const sessionResult = await startUIAutomator2Session(udid, name);
-            
-            if (sessionResult.success) {
-              // Set status to 'online' only after UIAutomator2 is ready
-              const deviceIndex = connectedDevices.findIndex(d => d.name === name);
-              if (deviceIndex !== -1) {
-                connectedDevices[deviceIndex].status = 'online';
-                
-                // Broadcast updated status
-                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} - UIAutomator2 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`);
-                
-                // Don't set status yet - wait for UIAutomator2
-                const deviceIndex = connectedDevices.findIndex(d => d.name === name);
-                if (deviceIndex !== -1) {
-                  connectedDevices[deviceIndex].status = 'connecting';
-                }
-                
-                // Always ensure UIAutomator2 is installed
-                console.log(`📦 Ensuring UIAutomator2 is installed on ${name}...`);
-                
-                // Check if already installed
-                const checkUiAutomator = spawn('adb', ['-s', `${ip}:5555`, 'shell', 'pm', 'list', 'packages', 'io.appium.uiautomator2']);
-                let uiautomatorOutput = '';
-                
-                checkUiAutomator.stdout.on('data', (data) => {
-                  uiautomatorOutput += data.toString();
-                });
-                
-                checkUiAutomator.on('close', async () => {
-                  const isInstalled = uiautomatorOutput.includes('io.appium.uiautomator2');
-                  
-                  if (!isInstalled) {
-                    console.log(`📥 UIAutomator2 not found on ${name}, installing...`);
-                    const installResult = await installUIAutomator2(`${ip}:5555`, name);
-                    if (!installResult.success) {
-                      console.log(`⚠️ UIAutomator2 installation failed on ${name}`);
-                    }
-                  } else {
-                    console.log(`✅ UIAutomator2 already installed on ${name}`);
-                  }
-                  
-                  // Check if session already exists for this device
-                  const existingSession = androidSessions.get(`${ip}:5555`);
-                  if (existingSession) {
-                    console.log(`♻️  Reusing existing UIAutomator2 session on ${name} (port: ${existingSession.port})`);
-                    
-                    // Verify session is still valid
-                    try {
-                      const axios = require('axios');
-                      await axios.get(`http://localhost:${existingSession.port}/wd/hub/status`);
-                      console.log(`✅ Session verified and working on ${name}`);
-                      
-                      // Set status to 'online'
-                      if (deviceIndex !== -1) {
-                        connectedDevices[deviceIndex].status = 'online';
-                        
-                        // Broadcast updated status
-                        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} - UIAutomator2 Ready ✅`
-                      });
-                      return;
-                    } catch (err) {
-                      console.log(`⚠️  Existing session invalid, creating new one for ${name}`);
-                      androidSessions.delete(`${ip}:5555`);
-                    }
-                  }
-                  
-                  // Start new UIAutomator2 session
-                  console.log(`🚀 Starting new UIAutomator2 session on ${name}...`);
-                  const sessionResult = await startUIAutomator2Session(`${ip}:5555`, name);
-                  
-                  let message = '';
-                  if (sessionResult.success) {
-                    // Now set status to 'online' after UIAutomator2 is ready
-                    if (deviceIndex !== -1) {
-                      connectedDevices[deviceIndex].status = 'online';
-                      
-                      // Broadcast updated status
-                      wss.clients.forEach(client => {
-                        if (client.readyState === WebSocket.OPEN) {
-                          client.send(JSON.stringify({
-                            type: 'devices_updated',
-                            devices: connectedDevices
-                          }));
-                        }
-                      });
-                    }
-                    
-                    message = `Connected to ${name} - UIAutomator2 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
-
-        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;
-  
-  // separator removed
-  console.log(`REPLAYING: ${recording.name}`);
-  console.log(`Original devices: ${devices.join(', ')}`);
-  console.log(`Target devices: ${targetDevices.join(', ')}`);
-  console.log(`Commands to replay: ${commands.length}`);
-  // separator removed
-  
-  // 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;
-  
-  // separator removed
-  console.log(`REPLAY COMPLETE`);
-  console.log(`Total: ${results.length}, Success: ${results.filter(r => r.success).length}, Failed: ${results.filter(r => !r.success).length}`);
-  // separator removed
-  
-  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) {
-
-      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;
-    console.log(`📡 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);
-    console.log(`✅ 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 += '# iPhone17,00008130-001945C63ED3401E,,ios,usb           (iOS USB - auto-detected)\n';
-    content += '# iPhone16P,00008140-001C24361E41801C,10.173.221.204,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' });
-    }
-    
-    logger.debug(`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) {
-        // Auto-connect the device
-        console.log(`📡 Auto-connecting ${deviceName} for getLocators...`);
-        try {
-          const connectResult = await connectToDevice(device);
-          if (!connectResult.success) {
-            return res.status(500).json({ 
-              success: false, 
-              error: 'Failed to connect device. Please use the Connect button first.' 
-            });
-          }
-
-          // Wait a moment for session to stabilize
-          await new Promise(resolve => setTimeout(resolve, 2000));
-        } 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);
-    
-    logger.debug(`Result success: ${result.success}`);
-    logger.debug(`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) {
-        logger.debug(`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) {
-            logger.debug(`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;
-                logger.debug(`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) {
-  logger.debug('🔍 Parsing locators output...');
-  logger.debug('Output length:', output?.length || 0);
-  
-  if (!output) {
-    logger.error('❌ No output to parse');
-    return [];
-  }
-  
-  // First try to parse as JSON (new format)
-  const lines = output.split('\n');
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith('[') || trimmed.startsWith('{')) {
-      try {
-        const jsonData = JSON.parse(trimmed);
-        logger.debug('✅ Parsed as JSON, elements:', Array.isArray(jsonData) ? jsonData.length : 'not array');
-        return Array.isArray(jsonData) ? jsonData : [];
-      } catch (err) {
-        logger.debug('⚠️ JSON parse failed:', err.message);
-      }
-    }
-  }
-  
-  logger.debug('📝 Fallback to text parsing...');
-  
-  // Fallback to old text parsing
-  const locators = [];
-  logger.debug('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;
-          
-          // separator removed
-          console.log(`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}`);
-          // separator removed
-          
-          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 {
-
-          }
-          
-          // Check if command has multiple lines (sequential execution)
-          const hasMultipleCommands = finalCommand.includes('\n');
-          
-          if (hasMultipleCommands) {
-
-            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 {
-            executeCommand(devices, finalCommand, ws)
-              .then(result => {
-                
-                // 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();
-      }).catch(err => {
-        logger.error('Device discovery failed:', err.message);
-        resolve();
-      });
-    });
-
-    // Handle WebSocket upgrades
-    server.on('upgrade', (request, socket, head) => {
-      wss.handleUpgrade(request, socket, head, (ws) => {
-        wss.emit('connection', ws, request);
-      });
-    });
-
-    server.on('error', (err) => {
-      if (err.code === 'EADDRINUSE') {
-        logger.error(`\n❌ Port ${port} is already in use!`);
-        logger.error(`\nTry one of these solutions:`);
-        logger.error(`  1. Kill the process using port ${port}: lsof -ti:${port} | xargs kill -9`);
-        logger.error(`  2. Use a different port: PORT=3002 devicely`);
-        logger.error(`  3. Set PORT in .env file\n`);
-      }
-      reject(err);
-    });
-  });
-}
-
-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 => {
-    if (err.code === 'EADDRINUSE') {
-      logger.error(`\n❌ Port 3001 is already in use!`);
-      logger.error(`\nTry one of these solutions:`);
-      logger.error(`  1. Kill the process using port 3001: lsof -ti:3001 | xargs kill -9`);
-      logger.error(`  2. Use a different port: PORT=3002 devicely`);
-      logger.error(`     Note: Vercel frontend connects to port 3001 by default`);
-      logger.error(`  3. Use local frontend at http://localhost:3001\n`);
-    } else {
-      console.error('Failed to start server:', err.message);
-    }
-    process.exit(1);
-  });
-}