devicely 2.1.3 → 2.1.5

package/scripts/shell/connect_ios_usb_multi_final.sh

@@ -0,0 +1,4225 @@
+#!/bin/bash
+# iOS Multi-Device Control - USB VERSION WITH AI
+# Features: Revolutionary AI-powered click detection + Trust-preserving cleanup
+# Usage:
+#   ./connect_ios_usb_multi_final.sh                    # Interactive mode
+#   ./connect_ios_usb_multi_final.sh "text"             # Send text to all
+#   ./connect_ios_usb_multi_final.sh -d device "text"   # Send to specific device
+#   ./connect_ios_usb_multi_final.sh "click 100,200"    # Click at coordinates
+#   ./connect_ios_usb_multi_final.sh "click 'Button'"   # AI-powered click on element
+#   ./connect_ios_usb_multi_final.sh "longpress 'Menu'" # Long press on element
+# 
+# Revolutionary Features:
+#   🚀 AI-powered element detection - Pre-caches all screen elements
+#   🧠 Smart fuzzy matching - Finds elements like human would
+#   🎯 Multi-strategy fallback - Professional automation approaches
+#   📸 Screen analysis caching - Instant element lookup after first scan
+#   🔄 Self-refreshing cache - Updates when screen changes detected
+#
+# Commands:
+#   click <x,y> or click <text>     - AI-powered click detection
+#   longpress <x,y> or longpress <text> - AI-powered long press
+#   getLocators                     - Get all locators from current screen
+#   refresh                         - Force refresh screen element cache
+#   forcecleanup                    - Force terminate WDA (may affect device trust)
+#
+# Trust Preservation:
+#   Normal 'quit' preserves device trust by keeping WDA processes running
+
+# Load the revolutionary AI click system
+SCRIPT_DIR="$(dirname "$0")"
+source "$SCRIPT_DIR/advanced_click_system.sh" 2>/dev/null || echo "⚠️ AI system not loaded, using fallback"
+source "$SCRIPT_DIR/ios_click_fix.sh" 2>/dev/null || echo "⚠️ Non-AI click helper not loaded"
+
+WDA_PORT=8100
+WDA_PORT_BASE=8100
+SCRIPT_DIR="$(dirname "$0")"
+
+# Function to find config files in multiple locations
+find_config() {
+    local filename="$1"
+    local search_paths=(
+        "$SCRIPT_DIR/$filename"
+        "$SCRIPT_DIR/../../config/$filename"
+        "$SCRIPT_DIR/../config/$filename"
+        "$HOME/.devicely/$filename"
+        "/opt/homebrew/lib/node_modules/devicely/config/$filename"
+        "$(npm root -g 2>/dev/null)/devicely/config/$filename"
+    )
+    
+    for path in "${search_paths[@]}"; do
+        if [ -f "$path" ]; then
+            echo "$path"
+            return 0
+        fi
+    done
+    
+    return 1
+}
+
+# Find config files
+CONFIG_FILE=$(find_config "devices.conf")
+if [ -z "$CONFIG_FILE" ]; then
+    if [ -f "$HOME/.devicely/devices.conf" ]; then
+        CONFIG_FILE="$HOME/.devicely/devices.conf"
+    else
+        echo "❌ Required file not found: devices.conf"
+        echo "   Searched in: script dir, config/, ~/.devicely/, global npm"
+        exit 1
+    fi
+fi
+
+APPS_PRESETS_FILE=$(find_config "apps_presets.conf")
+if [ -z "$APPS_PRESETS_FILE" ]; then
+    if [ -f "$HOME/.devicely/apps_presets.conf" ]; then
+        APPS_PRESETS_FILE="$HOME/.devicely/apps_presets.conf"
+    else
+        echo "❌ Required file not found: apps_presets.conf"
+        echo "   Searched in: script dir, config/, ~/.devicely/, global npm"
+        exit 1
+    fi
+fi
+
+# Track iproxy processes for cleanup (using file-based tracking for bash 3.2 compatibility)
+IPROXY_PIDS_FILE="/tmp/ios_multi_iproxy_pids.$$"
+DEVICE_PORT_MAP_FILE="/tmp/ios_multi_device_ports.$$"
+DEVICE_CONNECTION_TYPE_FILE="/tmp/ios_multi_connection_types.$$"
+
+# Command history variables (like original script)
+HISTORY_FILE="/tmp/.ios_multi_history"
+HISTORY_MAX=50
+declare -a TEXT_HISTORY
+HISTORY_INDEX=-1
+CURRENT_INPUT=""
+
+# Disable bash history to avoid showing shell commands (like original script)
+set +o history
+unset HISTFILE
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+print_color() {
+    echo -e "$1$2${NC}"
+}
+
+# Global session tracking (use fixed filename so sessions persist across command invocations)
+DEVICE_SESSIONS_FILE="/tmp/ios_multi_sessions"
+
+# History management functions
+load_text_history() {
+    # Ensure history file exists and is clean
+    if [ ! -f "$HISTORY_FILE" ]; then
+        touch "$HISTORY_FILE"
+    fi
+}
+
+# Add text to history
+add_to_history() {
+    local text="$1"
+    # Skip empty text, commands, and special keys
+    if [ -z "$text" ] || [[ "$text" == /* ]] || [[ "$text" == "{*}" ]] || [[ "$text" == "\\n" ]] || [[ "$text" == "quit" ]] || [[ "$text" == "exit" ]] || [[ "$text" == "help" ]]; then
+        return
+    fi
+    
+    # Add to history file (remove duplicates and keep last entries)
+    grep -v "^$(printf '%s\n' "$text" | sed 's/[[\.*^$()+?{|]/\\&/g')$" "$HISTORY_FILE" > "${HISTORY_FILE}.tmp" 2>/dev/null || true
+    echo "$text" >> "${HISTORY_FILE}.tmp"
+    tail -n "$HISTORY_MAX" "${HISTORY_FILE}.tmp" > "$HISTORY_FILE"
+    rm -f "${HISTORY_FILE}.tmp"
+}
+
+# Parse arguments
+DEVICE_NAME_REQUEST=""
+TEXT=""
+APP_BUNDLE=""
+
+if [ "$1" = "-d" ]; then
+    DEVICE_NAME_REQUEST="$2"
+    TEXT="$3"
+elif [ -n "$1" ]; then
+    TEXT="$1"
+fi
+
+# Check files
+for file in "$CONFIG_FILE" "$APPS_PRESETS_FILE"; do
+    if [ ! -f "$file" ]; then
+        echo "❌ Required file not found: $file"
+        exit 1
+    fi
+done
+
+# Setup single USB device (for -d mode)
+setup_single_usb_device() {
+    local device_name="$1"
+    local details=$(get_device_details "$device_name")
+    
+    if [ $? -ne 0 ]; then
+        return 1
+    fi
+    
+    local port=$(echo "$details" | cut -d',' -f1)
+    local udid=$(echo "$details" | cut -d',' -f2)
+    
+    # Check if iproxy is already running for this port
+    if ! pgrep -f "iproxy.*${port}:8100" >/dev/null 2>&1; then
+        print_color "$CYAN" "   🔌 Starting iproxy: localhost:$port -> device:8100"
+        iproxy ${port} 8100 -u "$udid" >/dev/null 2>&1 &
+        local iproxy_pid=$!
+        echo "$device_name:$iproxy_pid" >> "$IPROXY_PIDS_FILE"
+        sleep 0.5
+    else
+        print_color "$GREEN" "   ✅ iproxy already running on port $port"
+    fi
+    
+    # Quick connection test (skip ping, go straight to WDA)
+    print_color "$CYAN" "   🔍 Testing WDA connection..."
+    if curl -s --connect-timeout 2 --max-time 3 "http://localhost:${port}/status" 2>/dev/null | grep -q '"state"'; then
+        print_color "$GREEN" "   ✅ WDA ready"
+        return 0
+    else
+        print_color "$YELLOW" "   ⚠️ WDA not responding, attempting auto-start..."
+        
+        # Try to auto-start WDA
+        if start_wda_usb "$device_name" "$port" "$udid"; then
+            print_color "$GREEN" "   ✅ WDA auto-started"
+            return 0
+        else
+            print_color "$RED" "   ❌ Failed to start WDA"
+            return 1
+        fi
+    fi
+}
+
+# Get connected USB devices
+get_all_device_names() {
+    local udids=($(idevice_id -l 2>/dev/null))
+    if [ ${#udids[@]} -eq 0 ]; then
+        return 1
+    fi
+    
+    # For each UDID, try to get device name
+    local devices=()
+    for udid in "${udids[@]}"; do
+        local device_name=$(ideviceinfo -u "$udid" -k DeviceName 2>/dev/null | head -n1 | tr -d '\r\n')
+        if [ -z "$device_name" ]; then
+            device_name="$udid"
+        fi
+        devices+=("$device_name")
+    done
+    printf '%s\n' "${devices[@]}"
+}
+
+# Check if device is connected via USB
+is_usb_connected() {
+    local udid="$1"
+    if command -v idevice_id >/dev/null 2>&1; then
+        idevice_id -l 2>/dev/null | grep -q "^${udid}$"
+        return $?
+    fi
+    return 1
+}
+
+# Get USB device name from UDID
+get_usb_device_name() {
+    local udid="$1"
+    if command -v idevicename >/dev/null 2>&1; then
+        idevicename -u "$udid" 2>/dev/null
+    elif command -v ideviceinfo >/dev/null 2>&1; then
+        ideviceinfo -u "$udid" -k DeviceName 2>/dev/null | head -n1 | tr -d '\r\n'
+    fi
+}
+
+# Get device details (port,udid) for USB devices
+get_device_details() {
+    local device_name="$1"
+    
+    # Check cache first for consistent port assignment
+    if [ -f "$DEVICE_PORT_MAP_FILE" ]; then
+        local cached=$(grep "^$device_name:" "$DEVICE_PORT_MAP_FILE" 2>/dev/null | cut -d':' -f2-)
+        if [ -n "$cached" ]; then
+            echo "$cached"
+            return 0
+        fi
+    fi
+    
+    # Not in cache, calculate and cache it
+    local udids=($(idevice_id -l 2>/dev/null))
+    local port_offset=0
+    
+    for udid in "${udids[@]}"; do
+        local name=$(ideviceinfo -u "$udid" -k DeviceName 2>/dev/null | head -n1 | tr -d '\r\n')
+        if [ -z "$name" ]; then
+            name="$udid"
+        fi
+        
+        if [ "$name" = "$device_name" ] || [ "$udid" = "$device_name" ]; then
+            local port=$((WDA_PORT_BASE + port_offset))
+            local result="$port,$udid"
+            # Cache it for consistent lookups
+            echo "$device_name:$result" >> "$DEVICE_PORT_MAP_FILE"
+            echo "$result"
+            return 0
+        fi
+        ((port_offset++))
+    done
+    return 1
+}
+
+# Resolve app name to bundle ID
+resolve_app_bundle() {
+    local input="$1"
+    
+    # If already a bundle ID, return as-is
+    if [[ "$input" == *"."* ]] && [[ "$input" != *" "* ]]; then
+        echo "$input"
+        return
+    fi
+    
+    # Look up in presets
+    if [ -f "$APPS_PRESETS_FILE" ]; then
+        local input_lower=$(echo "$input" | tr '[:upper:]' '[:lower:]')
+        while IFS=',' read -r name bundle rest; do
+            [[ "$name" =~ ^# ]] || [[ -z "$name" ]] && continue
+            if [ "$(echo "$name" | tr '[:upper:]' '[:lower:]')" = "$input_lower" ]; then
+                echo "$bundle"
+                return
+            fi
+        done < "$APPS_PRESETS_FILE"
+    fi
+    
+    # Default bundle IDs for common apps
+    case "$input_lower" in
+        "safari") echo "com.apple.mobilesafari" ;;
+        "settings") echo "com.apple.Preferences" ;;
+        "messages") echo "com.apple.MobileSMS" ;;
+        "camera") echo "com.apple.camera" ;;
+        "photos") echo "com.apple.mobileslideshow" ;;
+        "notes") echo "com.apple.mobilenotes" ;;
+        *) echo "$input" ;;
+    esac
+}
+
+# Check device connectivity (USB version with auto-WDA start)
+check_device_connectivity() {
+    local device_name="$1"
+    local device_details
+    device_details=$(get_device_details "$device_name")
+    
+    if [ $? -ne 0 ]; then
+        print_color "$RED" "❌ Device not found: $device_name"
+        return 1
+    fi
+    
+    # Get device info
+    local udid=$(echo "$device_details" | awk -F',' '{print $1}')
+    local port=$(echo "$device_details" | awk -F',' '{print $2}')
+    
+    # Check if device is still connected
+    if ! idevice_id -l 2>/dev/null | grep -q "^${udid}$"; then
+        print_color "$RED" "❌ Device disconnected: $device_name"
+        return 1
+    fi
+    
+    # Test localhost connectivity
+    echo "🌐 Ping test to localhost..."
+    if ping -c 1 -W 2000 localhost >/dev/null 2>&1; then
+        echo "✅ Network reachable"
+    else
+        echo "❌ Network unreachable"
+        return 1
+    fi
+    
+    # Test WDA connection
+    echo "🔍 Testing WDA connection..."
+    if curl -s --connect-timeout 2 --max-time 3 "http://localhost:$port/status" 2>/dev/null | grep -q '"state"'; then
+        echo "✅ WDA ready"
+        return 0
+    else
+        echo "⚠️ WDA not ready, attempting auto-start..."
+        start_wda_usb "$device_name" "$udid" "$port"
+        return $?
+    fi
+}
+
+create_persistent_session() {
+    local device_name="$1"
+    local device_details
+    device_details=$(get_device_details "$device_name")
+    local port=$(echo "$device_details" | cut -d',' -f1)
+    
+    # Create ONE session per device for the entire interactive session
+    # Don't launch any specific app - just create a session to the home screen
+    local session=$(curl -s -X POST "http://localhost:${port}/session" \
+        -H 'Content-Type: application/json' \
+        -d '{"capabilities":{"alwaysMatch":{}}}' | \
+        python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('sessionId','') or d.get('value',{}).get('sessionId',''))" 2>/dev/null)
+    
+    if [ -n "$session" ]; then
+        # Use a lock file for atomic writes when running in parallel
+        local lock_file="${DEVICE_SESSIONS_FILE}.lock"
+        while ! mkdir "$lock_file" 2>/dev/null; do
+            sleep 0.01
+        done
+        echo "$device_name:$session" >> "$DEVICE_SESSIONS_FILE"
+        rmdir "$lock_file"
+        echo "$session"
+    else
+        echo ""
+    fi
+}
+
+# Get existing session for device
+get_device_session() {
+    local device_name="$1"
+    if [ -f "$DEVICE_SESSIONS_FILE" ]; then
+        grep "^$device_name:" "$DEVICE_SESSIONS_FILE" | cut -d':' -f2 | tail -1
+    fi
+}
+
+# Helper function to find element using multiple strategies (like Appium)
+find_element_by_text() {
+    local session="$1"
+    local port="$2"
+    local text="$3"
+    local device_name="$4"
+    
+    local element_id=""
+    local found_strategy=""
+    
+    # Strategy 1: Accessibility ID (most reliable for iOS)
+    echo "[$device_name] Trying accessibility ID..."
+    local elements_result=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+        -H "Content-Type: application/json" \
+        -d "{\"using\": \"accessibility id\", \"value\": \"$text\"}" 2>/dev/null)
+    
+    if echo "$elements_result" | grep -q '"ELEMENT"'; then
+        element_id=$(echo "$elements_result" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements and len(elements) > 0:
+        print(elements[0].get('ELEMENT', ''))
+except:
+    pass" 2>/dev/null)
+        found_strategy="accessibility id"
+    fi
+    
+    # Strategy 2: Name attribute  
+    if [ -z "$element_id" ]; then
+        echo "[$device_name] Trying name attribute..."
+        elements_result=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+            -H "Content-Type: application/json" \
+            -d "{\"using\": \"name\", \"value\": \"$text\"}" 2>/dev/null)
+        
+        if echo "$elements_result" | grep -q '"ELEMENT"'; then
+            element_id=$(echo "$elements_result" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements and len(elements) > 0:
+        print(elements[0].get('ELEMENT', ''))
+except:
+    pass" 2>/dev/null)
+            found_strategy="name"
+        fi
+    fi
+    
+    # Strategy 3: Predicate string (iOS specific - very powerful)
+    if [ -z "$element_id" ]; then
+        echo "[$device_name] Trying predicate string..."
+        local predicate="name CONTAINS '$text' OR label CONTAINS '$text' OR value CONTAINS '$text'"
+        elements_result=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+            -H "Content-Type: application/json" \
+            -d "{\"using\": \"predicate string\", \"value\": \"$predicate\"}" 2>/dev/null)
+        
+        if echo "$elements_result" | grep -q '"ELEMENT"'; then
+            element_id=$(echo "$elements_result" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements and len(elements) > 0:
+        print(elements[0].get('ELEMENT', ''))
+except:
+    pass" 2>/dev/null)
+            found_strategy="predicate string"
+        fi
+    fi
+    
+    # Strategy 4: Class chain for buttons (iOS specific)
+    if [ -z "$element_id" ]; then
+        echo "[$device_name] Trying class chain for buttons..."
+        local class_chain="**/XCUIElementTypeButton[\`name CONTAINS '$text'\`]"
+        elements_result=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+            -H "Content-Type: application/json" \
+            -d "{\"using\": \"-ios class chain\", \"value\": \"$class_chain\"}" 2>/dev/null)
+        
+        if echo "$elements_result" | grep -q '"ELEMENT"'; then
+            element_id=$(echo "$elements_result" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements and len(elements) > 0:
+        print(elements[0].get('ELEMENT', ''))
+except:
+    pass" 2>/dev/null)
+            found_strategy="class chain (button)"
+        fi
+    fi
+    
+    # Strategy 5: Class chain for any element (broader search)
+    if [ -z "$element_id" ]; then
+        echo "[$device_name] Trying class chain for any element..."
+        local class_chain="**/*[\`name CONTAINS '$text'\`]"
+        elements_result=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+            -H "Content-Type: application/json" \
+            -d "{\"using\": \"-ios class chain\", \"value\": \"$class_chain\"}" 2>/dev/null)
+        
+        if echo "$elements_result" | grep -q '"ELEMENT"'; then
+            element_id=$(echo "$elements_result" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements and len(elements) > 0:
+        print(elements[0].get('ELEMENT', ''))
+except:
+    pass" 2>/dev/null)
+            found_strategy="class chain (any)"
+        fi
+    fi
+    
+    # Strategy 6: Table cell search (common in Settings app)
+    if [ -z "$element_id" ]; then
+        echo "[$device_name] Trying table cell search..."
+        local class_chain="**/XCUIElementTypeCell[\`name CONTAINS '$text'\`]"
+        elements_result=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+            -H "Content-Type: application/json" \
+            -d "{\"using\": \"-ios class chain\", \"value\": \"$class_chain\"}" 2>/dev/null)
+        
+        if echo "$elements_result" | grep -q '"ELEMENT"'; then
+            element_id=$(echo "$elements_result" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements and len(elements) > 0:
+        print(elements[0].get('ELEMENT', ''))
+except:
+    pass" 2>/dev/null)
+            found_strategy="class chain (cell)"
+        fi
+    fi
+    
+    # Strategy 7: Static text search (for text labels)
+    if [ -z "$element_id" ]; then
+        echo "[$device_name] Trying static text search..."
+        local class_chain="**/XCUIElementTypeStaticText[\`name CONTAINS '$text'\`]"
+        elements_result=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+            -H "Content-Type: application/json" \
+            -d "{\"using\": \"-ios class chain\", \"value\": \"$class_chain\"}" 2>/dev/null)
+        
+        if echo "$elements_result" | grep -q '"ELEMENT"'; then
+            element_id=$(echo "$elements_result" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements and len(elements) > 0:
+        print(elements[0].get('ELEMENT', ''))
+except:
+    pass" 2>/dev/null)
+            found_strategy="class chain (static text)"
+        fi
+    fi
+    
+    # Strategy 8: Partial match with case-insensitive search
+    if [ -z "$element_id" ]; then
+        echo "[$device_name] Trying case-insensitive partial match..."
+        local predicate="name CONTAINS[c] '$text' OR label CONTAINS[c] '$text' OR value CONTAINS[c] '$text'"
+        elements_result=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+            -H "Content-Type: application/json" \
+            -d "{\"using\": \"predicate string\", \"value\": \"$predicate\"}" 2>/dev/null)
+        
+        if echo "$elements_result" | grep -q '"ELEMENT"'; then
+            element_id=$(echo "$elements_result" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements and len(elements) > 0:
+        print(elements[0].get('ELEMENT', ''))
+except:
+    pass" 2>/dev/null)
+            found_strategy="predicate (case-insensitive)"
+        fi
+    fi
+    
+    # Output results
+    if [ -n "$element_id" ]; then
+        echo "$element_id|$found_strategy"
+    else
+        echo "|"
+    fi
+}
+
+# Helper function to get element center coordinates with multiple methods
+get_element_center() {
+    local session="$1"
+    local port="$2"
+    local element_id="$3"
+    
+    # Method 1: Try /rect endpoint
+    local rect_response=$(curl -s -X GET "http://localhost:${port}/session/$session/element/$element_id/rect" \
+        -H 'Content-Type: application/json' 2>/dev/null)
+    
+    echo "DEBUG: Rect response: '$rect_response'" >&2
+    
+    if echo "$rect_response" | grep -q '"x"' && echo "$rect_response" | grep -q '"y"'; then
+        local x=$(echo "$rect_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    rect = data.get('value', {})
+    x = rect.get('x', 0)
+    width = rect.get('width', 0)
+    center_x = int(x + width/2)
+    print(center_x)
+except Exception as e:
+    print('0')" 2>/dev/null)
+        
+        local y=$(echo "$rect_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    rect = data.get('value', {})
+    y = rect.get('y', 0)  
+    height = rect.get('height', 0)
+    center_y = int(y + height/2)
+    print(center_y)
+except Exception as e:
+    print('0')" 2>/dev/null)
+        
+        if [[ "$x" =~ ^[0-9]+$ ]] && [[ "$y" =~ ^[0-9]+$ ]] && [ "$x" -gt 0 ] && [ "$y" -gt 0 ]; then
+            echo "$x,$y"
+            return
+        fi
+    fi
+    
+    # Method 2: Try /location endpoint
+    echo "DEBUG: Trying location endpoint..." >&2
+    local location_response=$(curl -s -X GET "http://localhost:${port}/session/$session/element/$element_id/location" \
+        -H 'Content-Type: application/json' 2>/dev/null)
+    
+    echo "DEBUG: Location response: '$location_response'" >&2
+    
+    if echo "$location_response" | grep -q '"x"' && echo "$location_response" | grep -q '"y"'; then
+        local x=$(echo "$location_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    location = data.get('value', {})
+    print(int(location.get('x', 0)))
+except:
+    print('0')" 2>/dev/null)
+        
+        local y=$(echo "$location_response" | python3 -c "
+import sys, json  
+try:
+    data = json.load(sys.stdin)
+    location = data.get('value', {})
+    print(int(location.get('y', 0)))
+except:
+    print('0')" 2>/dev/null)
+        
+        if [[ "$x" =~ ^[0-9]+$ ]] && [[ "$y" =~ ^[0-9]+$ ]] && [ "$x" -gt 0 ] && [ "$y" -gt 0 ]; then
+            echo "$x,$y"
+            return
+        fi
+    fi
+    
+    # Method 3: Try WebDriverAgent specific endpoint
+    echo "DEBUG: Trying WDA accessibilityContainer endpoint..." >&2
+    local wda_response=$(curl -s -X GET "http://localhost:${port}/session/$session/wda/element/$element_id/accessibilityContainer" \
+        -H 'Content-Type: application/json' 2>/dev/null)
+    
+    echo "DEBUG: WDA response: '$wda_response'" >&2
+    
+    # Method 4: Use element attribute to get frame info
+    echo "DEBUG: Trying element attribute..." >&2
+    local attr_response=$(curl -s -X GET "http://localhost:${port}/session/$session/element/$element_id/attribute/frame" \
+        -H 'Content-Type: application/json' 2>/dev/null)
+    
+    echo "DEBUG: Attribute response: '$attr_response'" >&2
+    
+    # If all methods fail, return 0,0
+    echo "0,0"
+}
+
+cleanup_wda_session() {
+    local device_name="$1"
+    local preserve_trust="${2:-true}"
+    local session=""
+    
+    if [ -f "$DEVICE_SESSIONS_FILE" ]; then
+        session=$(grep "^$device_name:" "$DEVICE_SESSIONS_FILE" | cut -d':' -f2 | tail -1)
+    fi
+    
+    if [ -n "$session" ]; then
+        local device_details
+        device_details=$(get_device_details "$device_name")
+        local port=$(echo "$device_details" | cut -d',' -f1)
+        
+        curl -s -X DELETE "http://localhost:${port}/session/$session" >/dev/null 2>&1
+        
+        # Remove session from tracking
+        if [ -f "$DEVICE_SESSIONS_FILE" ]; then
+            grep -v "^$device_name:" "$DEVICE_SESSIONS_FILE" > "${DEVICE_SESSIONS_FILE}.tmp" 2>/dev/null || true
+            mv "${DEVICE_SESSIONS_FILE}.tmp" "$DEVICE_SESSIONS_FILE" 2>/dev/null || true
+        fi
+        
+        if [ "$preserve_trust" = "true" ] && [ "${preserve_trust}" != "false" ]; then
+            print_color "$GREEN" "✅ Session closed for $device_name (WebDriverAgent preserved)"
+        fi
+    fi
+}
+
+# Helper function to find clickable parent element
+# When StaticText is found, we need to click its parent Cell or Button
+find_clickable_element() {
+    local session="$1"
+    local port="$2"
+    local element_id="$3"
+    local device_name="$4"
+    
+    # Get element type to determine if it's clickable
+    local element_type=$(curl -s -X GET "http://localhost:${port}/session/$session/element/$element_id/attribute/type" 2>/dev/null | \
+        python3 -c "import sys,json; print(json.load(sys.stdin).get('value', ''))" 2>/dev/null)
+    
+    echo "[$device_name] Element type: $element_type" >&2
+    
+    # If it's StaticText, try to find parent Cell/Button (common in Settings app)
+    if [[ "$element_type" == *"StaticText"* ]]; then
+        echo "[$device_name] StaticText found, searching for clickable parent..." >&2
+        
+        # Try to get parent cell using xpath
+        local parent=$(curl -s -X POST "http://localhost:${port}/session/$session/element/$element_id/element" \
+            -H 'Content-Type: application/json' \
+            -d '{"using":"xpath","value":"./ancestor::XCUIElementTypeCell[1]"}' 2>/dev/null | \
+            python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('value',{}).get('ELEMENT',''))" 2>/dev/null)
+        
+        if [ -n "$parent" ]; then
+            echo "[$device_name] ✅ Found parent Cell: $parent" >&2
+            echo "$parent"
+            return 0
+        fi
+        
+        # Try button parent
+        parent=$(curl -s -X POST "http://localhost:${port}/session/$session/element/$element_id/element" \
+            -H 'Content-Type: application/json' \
+            -d '{"using":"xpath","value":"./ancestor::XCUIElementTypeButton[1]"}' 2>/dev/null | \
+            python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('value',{}).get('ELEMENT',''))" 2>/dev/null)
+        
+        if [ -n "$parent" ]; then
+            echo "[$device_name] ✅ Found parent Button: $parent" >&2
+            echo "$parent"
+            return 0
+        fi
+        
+        echo "[$device_name] ⚠️ No clickable parent found, using original element" >&2
+    fi
+    
+    # Return original element
+    echo "$element_id"
+}
+
+# Execute WDA command directly
+execute_wda_command() {
+    local device_name="$1"
+    local command="$2"
+    local log_prefix="[${device_name}]"
+    local device_details
+    device_details=$(get_device_details "$device_name")
+    local port=$(echo "$device_details" | cut -d',' -f1)
+    
+    # Parse command
+    local cmd_type=$(echo "$command" | awk '{print $1}')
+    local cmd_args=$(echo "$command" | sed "s/^$cmd_type *//" | xargs)
+    
+    # Show what we parsed for debugging
+    echo "${log_prefix} Processing command: '$cmd_type' with args: '$cmd_args'"
+    
+    # Check the actual values with explicit debugging
+    echo "${log_prefix} cmd_type length: ${#cmd_type}"
+    echo "${log_prefix} cmd_type hex: $(echo -n "$cmd_type" | xxd -p)"
+    
+    case "$cmd_type" in
+        "launch"|"open")
+            echo "${log_prefix} CASE: Launch/open matched"
+            local bundle_id=$(resolve_app_bundle "$cmd_args")
+            echo "${log_prefix} Launching: $cmd_args → $bundle_id"
+            
+            # Clean up existing session and create new one for the target app
+            cleanup_wda_session "$device_name" false  # Don't show message during launch
+            
+            # Create new session with target app (this launches it)
+            local session=$(curl -s -X POST "http://localhost:${port}/session" \
+                -H 'Content-Type: application/json' \
+                -d "{\"capabilities\":{\"alwaysMatch\":{\"bundleId\":\"$bundle_id\"}}}" | \
+                python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('sessionId','') or d.get('value',{}).get('sessionId',''))" 2>/dev/null)
+            
+            if [ -n "$session" ]; then
+                # Store new session
+                echo "$device_name:$session" >> "$DEVICE_SESSIONS_FILE"
+                echo "${log_prefix} ✅ App launched"
+            else
+                echo "${log_prefix} ❌ Launch failed"
+            fi
+            ;;
+            
+        "kill"|"close"|"terminate")
+            local bundle_id=$(resolve_app_bundle "$cmd_args")
+            echo "${log_prefix} Terminating: $cmd_args → $bundle_id"
+            
+            # Method 1: Try WDA terminate endpoint
+            local session=$(get_device_session "$device_name")
+            local success=false
+            
+            if [ -n "$session" ]; then
+                echo "${log_prefix} → Trying WDA terminate endpoint..."
+                local response=$(curl -s -X POST "http://localhost:${port}/wda/apps/terminate" \
+                    -H 'Content-Type: application/json' \
+                    -d "{\"bundleId\":\"$bundle_id\"}")
+                
+                # Debug: Show response for troubleshooting
+                # echo "${log_prefix} DEBUG: Response: $response"
+                
+                if echo "$response" | grep -q '"value".*true' && ! echo "$response" | grep -q '"error"'; then
+                    echo "${log_prefix} ✅ App terminated via WDA"
+                    success=true
+                elif echo "$response" | grep -q '"sessionId"' && ! echo "$response" | grep -q '"error"'; then
+                    echo "${log_prefix} ✅ App terminated via WDA" 
+                    success=true
+                else
+                    echo "${log_prefix} → WDA terminate failed, trying alternatives..."
+                fi
+            fi
+            
+            # Method 2: Try alternative WDA endpoint if first method failed
+            if [ "$success" = false ] && [ -n "$session" ]; then
+                echo "${log_prefix} → Trying session-based terminate method..."
+                local response=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/apps/terminate" \
+                    -H 'Content-Type: application/json' \
+                    -d "{\"bundleId\":\"$bundle_id\"}")
+                
+                if echo "$response" | grep -q '"value".*true' || (echo "$response" | grep -q '"sessionId"' && ! echo "$response" | grep -q '"error"'); then
+                    echo "${log_prefix} ✅ App terminated via session API"
+                    success=true
+                else
+                    echo "${log_prefix} → Session terminate also failed..."
+                fi
+            fi
+            
+            # Method 3: Try using xcrun devicectl (iOS 17+)
+            if [ "$success" = false ]; then
+                echo "${log_prefix} → Trying xcrun devicectl..."
+                local device_details
+                device_details=$(get_device_details "$device_name")
+                local udid=$(echo "$device_details" | cut -d',' -f2)
+                
+                if [ -n "$udid" ] && command -v xcrun >/dev/null 2>&1; then
+                    # Try process kill first
+                    local kill_result=$(xcrun devicectl device process kill --device "$udid" "$bundle_id" 2>&1)
+                    if [ $? -eq 0 ]; then
+                        echo "${log_prefix} ✅ App terminated via xcrun devicectl (process kill)"
+                        success=true
+                    else
+                        # Try app terminate
+                        local terminate_result=$(xcrun devicectl device apps terminate --device "$udid" "$bundle_id" 2>&1)
+                        if [ $? -eq 0 ]; then
+                            echo "${log_prefix} ✅ App terminated via xcrun devicectl (app terminate)"
+                            success=true
+                        fi
+                    fi
+                fi
+            fi
+            
+            # Method 4: Try launching home screen to background the app
+            if [ "$success" = false ]; then
+                echo "${log_prefix} → Backgrounding app (launching home screen)..."
+                local response=$(curl -s -X POST "http://localhost:${port}/wda/homescreen" \
+                    -H 'Content-Type: application/json' -d '{}')
+                
+                if ! echo "$response" | grep -q '"error"'; then
+                    echo "${log_prefix} ✅ App backgrounded (sent to home screen)"
+                    success=true
+                fi
+            fi
+            
+            if [ "$success" = false ]; then
+                echo "${log_prefix} ❌ All terminate methods failed"
+                echo "${log_prefix} 💡 Try manually closing the app or use 'home' command"
+            fi
+            ;;
+            
+        "home")
+            echo "${log_prefix} Going to home screen"
+            # Use the same endpoint as original script (no session ID needed)
+            local response=$(curl -s -X POST "http://localhost:${port}/wda/homescreen" \
+                -H 'Content-Type: application/json' -d '{}')
+            
+            if ! echo "$response" | grep -q '"error"'; then
+                echo "${log_prefix} ✅ Went to home"
+            else
+                echo "${log_prefix} ❌ Home failed"
+            fi
+            ;;
+            
+        "url")
+            local url="$cmd_args"
+            if ! echo "$url" | grep -qE '^[a-z]+://'; then
+                url="https://$url"
+            fi
+            echo "${log_prefix} Opening URL: $url"
+            
+            # Use existing session - first activate Safari, then navigate
+            local session=$(get_device_session "$device_name")
+            if [ -n "$session" ]; then
+                # Activate Safari first
+                curl -s -X POST "http://localhost:${port}/wda/apps/activate" \
+                    -H 'Content-Type: application/json' \
+                    -d '{"bundleId":"com.apple.mobilesafari"}' >/dev/null 2>&1
+                sleep 1
+                # Navigate to URL
+                curl -s -X POST "http://localhost:${port}/session/$session/url" \
+                    -H 'Content-Type: application/json' \
+                    -d "{\"url\":\"$url\"}" >/dev/null 2>&1
+                echo "${log_prefix} ✅ URL opened in Safari"
+            else
+                echo "${log_prefix} ❌ URL open failed"
+            fi
+            ;;
+            
+        "screenshot")
+            echo "${log_prefix} Taking screenshot"
+            local session=$(get_device_session "$device_name")
+            if [ -n "$session" ]; then
+                # Save to webapp screenshots directory
+                local screenshots_dir="$SCRIPT_DIR/webapp/backend/screenshots"
+                mkdir -p "$screenshots_dir"
+                local out_file="${screenshots_dir}/screenshot_ios_${device_name}_$(date +%Y%m%d_%H%M%S).png"
+                local response=$(curl -s -X GET "http://localhost:${port}/screenshot")
+                
+                if echo "$response" | python3 -c "
+import sys,base64,json
+try:
+    j=json.load(sys.stdin)
+    img_b64=j.get('value','')
+    if img_b64:
+        with open('$out_file','wb') as f:
+            f.write(base64.b64decode(img_b64))
+        print('✅ Screenshot saved: $out_file')
+    else:
+        print('❌ Screenshot failed')
+except:
+    print('❌ Screenshot error')
+" 2>/dev/null; then
+                    echo "${log_prefix} Screenshot completed"
+                fi
+            else
+                echo "${log_prefix} ❌ Screenshot failed"
+            fi
+            ;;
+            
+        "lock")
+            echo "${log_prefix} Locking device"
+            local response=$(curl -s -X POST "http://localhost:${port}/wda/lock" \
+                -H 'Content-Type: application/json' -d '{}')
+            
+            if ! echo "$response" | grep -q '"error"'; then
+                echo "${log_prefix} ✅ Device locked"
+            else
+                echo "${log_prefix} ❌ Lock failed"
+            fi
+            ;;
+            
+        "unlock")
+            echo "${log_prefix} Unlocking device"
+            local response=$(curl -s -X POST "http://localhost:${port}/wda/unlock" \
+                -H 'Content-Type: application/json' -d '{}')
+            
+            if ! echo "$response" | grep -q '"error"'; then
+                echo "${log_prefix} ✅ Device unlocked"
+            else
+                echo "${log_prefix} ❌ Unlock failed"
+            fi
+            ;;
+            
+        "back"|"goback")
+            echo "${log_prefix} Going back"
+            # iOS doesn't have a universal back button like Android
+            # Use swipe from left edge gesture which is the iOS equivalent
+            local session=$(get_device_session "$device_name")
+            if [ -n "$session" ]; then
+                # Swipe from left edge (back gesture)
+                local swipe_payload='{
+                    "actions": [
+                        {
+                            "type": "pointer",
+                            "id": "finger1",
+                            "parameters": {"pointerType": "touch"},
+                            "actions": [
+                                {"type": "pointerMove", "duration": 0, "x": 10, "y": 400},
+                                {"type": "pointerDown", "button": 0},
+                                {"type": "pointerMove", "duration": 300, "x": 200, "y": 400},
+                                {"type": "pointerUp", "button": 0}
+                            ]
+                        }
+                    ]
+                }'
+                
+                curl -s -X POST "http://localhost:${port}/session/$session/actions" \
+                    -H 'Content-Type: application/json' \
+                    -d "$swipe_payload" >/dev/null 2>&1
+                
+                echo "${log_prefix} ✅ Back gesture performed"
+            else
+                echo "${log_prefix} ❌ Back failed"
+            fi
+            ;;
+            
+        "install")
+            local app_path="$cmd_args"
+            echo "${log_prefix} Installing app: $app_path"
+            
+            # Check if file exists
+            if [ ! -f "$app_path" ]; then
+                echo "${log_prefix} ❌ App file not found: $app_path"
+                return 1
+            fi
+            
+            # Check if it's an IPA file
+            if [[ ! "$app_path" =~ \.ipa$ ]]; then
+                echo "${log_prefix} ❌ File must be a .ipa file: $app_path"
+                return 1
+            fi
+            
+            # Get device details for wireless installation
+            local device_details
+            device_details=$(get_device_details "$device_name")
+            local udid=$(echo "$device_details" | cut -d',' -f2)
+            
+            if [ -n "$udid" ]; then
+                echo "${log_prefix} 📦 Installing app via wireless-compatible tools..."
+                
+                # For wireless devices, prioritize xcrun devicectl
+                if command -v xcrun >/dev/null 2>&1; then
+                    # Use xcrun devicectl (works with wireless devices on iOS 17+)
+                    echo "${log_prefix} 🔄 Using xcrun devicectl for wireless installation..."
+                    local install_result=$(xcrun devicectl device install app --device "$udid" "$app_path" 2>&1)
+                    if [ $? -eq 0 ]; then
+                        echo "${log_prefix} ✅ App installed successfully via xcrun devicectl"
+                    else
+                        echo "${log_prefix} ❌ Installation failed via xcrun devicectl: $install_result"
+                        echo "${log_prefix} 💡 For wireless devices, ensure:"
+                        echo "${log_prefix}    • Device is paired and trusted in Xcode"
+                        echo "${log_prefix}    • iOS 17+ for best wireless support"
+                    fi
+                elif command -v ios-deploy >/dev/null 2>&1; then
+                    # Try ios-deploy with wireless flag
+                    echo "${log_prefix} 🔄 Trying ios-deploy with wireless support..."
+                    local install_result=$(ios-deploy --id "$udid" --bundle "$app_path" 2>&1)
+                    if [ $? -eq 0 ]; then
+                        echo "${log_prefix} ✅ App installed successfully via ios-deploy"
+                    else
+                        echo "${log_prefix} ❌ Installation failed via ios-deploy: $install_result"
+                    fi
+                elif command -v ideviceinstaller >/dev/null 2>&1; then
+                    # ideviceinstaller may not work with wireless, but try anyway
+                    echo "${log_prefix} 🔄 Trying ideviceinstaller (may require USB)..."
+                    local install_result=$(ideviceinstaller -u "$udid" install "$app_path" 2>&1)
+                    if [ $? -eq 0 ]; then
+                        echo "${log_prefix} ✅ App installed successfully via ideviceinstaller"
+                    else
+                        echo "${log_prefix} ❌ Installation failed via ideviceinstaller (wireless not supported): $install_result"
+                    fi
+                else
+                    echo "${log_prefix} ❌ No wireless-compatible installation tools found"
+                    echo "${log_prefix} 💡 For wireless installation:"
+                    echo "${log_prefix}    • Install via Xcode → Window → Devices and Simulators"
+                    echo "${log_prefix}    • Or use: xcrun devicectl device install app --device $udid $app_path"
+                fi
+            else
+                echo "${log_prefix} ❌ Device UDID not available"
+            fi
+            ;;
+            
+        "uninstall")
+            local bundle_id="$cmd_args"
+            echo "${log_prefix} Uninstalling app: $bundle_id"
+            
+            # Get device UDID for wireless uninstallation
+            local device_details
+            device_details=$(get_device_details "$device_name")
+            local udid=$(echo "$device_details" | cut -d',' -f2)
+            
+            if [ -n "$udid" ]; then
+                echo "${log_prefix} 🗑️  Uninstalling app via wireless-compatible tools..."
+                
+                # For wireless devices, prioritize xcrun devicectl
+                if command -v xcrun >/dev/null 2>&1; then
+                    # Use xcrun devicectl (works with wireless devices on iOS 17+)
+                    echo "${log_prefix} 🔄 Using xcrun devicectl for wireless uninstallation..."
+                    local uninstall_result=$(xcrun devicectl device uninstall app --device "$udid" "$bundle_id" 2>&1)
+                    if [ $? -eq 0 ]; then
+                        echo "${log_prefix} ✅ App uninstalled successfully via xcrun devicectl"
+                    else
+                        echo "${log_prefix} ❌ Uninstallation failed via xcrun devicectl: $uninstall_result"
+                        echo "${log_prefix} 💡 For wireless devices, ensure:"
+                        echo "${log_prefix}    • Device is paired and trusted in Xcode"
+                        echo "${log_prefix}    • App bundle ID is correct: $bundle_id"
+                    fi
+                elif command -v ideviceinstaller >/dev/null 2>&1; then
+                    # ideviceinstaller may not work with wireless, but try anyway
+                    echo "${log_prefix} 🔄 Trying ideviceinstaller (may require USB)..."
+                    local uninstall_result=$(ideviceinstaller -u "$udid" uninstall "$bundle_id" 2>&1)
+                    if [ $? -eq 0 ]; then
+                        echo "${log_prefix} ✅ App uninstalled successfully via ideviceinstaller"
+                    else
+                        echo "${log_prefix} ❌ Uninstallation failed via ideviceinstaller (wireless not supported): $uninstall_result"
+                    fi
+                else
+                    echo "${log_prefix} ❌ No wireless-compatible uninstallation tools found"
+                    echo "${log_prefix} 💡 For wireless uninstallation:"
+                    echo "${log_prefix}    • Uninstall manually on device (long-press app icon)"
+                    echo "${log_prefix}    • Or use Xcode → Window → Devices and Simulators"
+                    echo "${log_prefix}    • Or use: xcrun devicectl device uninstall app --device $udid $bundle_id"
+                fi
+            else
+                echo "${log_prefix} ❌ Device UDID not available"
+            fi
+            ;;
+            
+        "listapps"|"apps")
+            local search_term="$cmd_args"
+            if [ -n "$search_term" ]; then
+                echo "${log_prefix} 🔍 Searching installed apps for: '$search_term'"
+                echo "${log_prefix} 💡 Searching by app name, bundle ID, and display name..."
+            else
+                echo "${log_prefix} Listing all installed apps..."
+            fi
+            
+            # For wireless devices, use WebDriverAgent or xcrun devicectl
+            local device_details
+            device_details=$(get_device_details "$device_name")
+            local port=$(echo "$device_details" | cut -d',' -f1)
+            local udid=$(echo "$device_details" | cut -d',' -f2)
+            
+            echo "${log_prefix} 📱 Using wireless device tools for app listing..."
+            
+            # Method 1: Try xcrun devicectl for wireless devices (iOS 17+)
+            if command -v xcrun >/dev/null 2>&1 && [ -n "$udid" ]; then
+                echo "${log_prefix} 🔄 Trying xcrun devicectl (wireless-compatible)..."
+                
+                if [ -n "$search_term" ]; then
+                    # First try exact bundle ID match
+                    local list_result=$(xcrun devicectl device info apps --device "$udid" --bundle-id "$search_term" 2>&1)
+                    local found_exact=false
+                    if [ $? -eq 0 ] && [ -n "$list_result" ] && ! echo "$list_result" | grep -q "No matching apps found"; then
+                        echo "${log_prefix} ✅ Found exact bundle ID match: $search_term"
+                        echo "$list_result" | while read line; do
+                            echo "${log_prefix}    $line"
+                        done
+                        found_exact=true
+                    fi
+                    
+                    # Always also search by app name/partial match for better user experience
+                    local list_result=$(xcrun devicectl device info apps --device "$udid" --include-all-apps 2>&1)
+                    if [ $? -eq 0 ]; then
+                        # Enhanced search: look for matches in app name, display name, and bundle ID
+                        local filtered_apps=$(echo "$list_result" | grep -i "$search_term" 2>/dev/null)
+                        if [ -n "$filtered_apps" ]; then
+                            if [ "$found_exact" = false ]; then
+                                echo "${log_prefix} ✅ Found matching apps:"
+                            else
+                                echo "${log_prefix} ✅ Additional matches found:"
+                            fi
+                            echo "$filtered_apps" | while read line; do
+                                echo "${log_prefix}    $line"
+                            done
+                            return
+                        elif [ "$found_exact" = false ]; then
+                            echo "${log_prefix} ❌ No apps found matching: '$search_term'"
+                        fi
+                    fi
+                else
+                    # List all apps
+                    local list_result=$(xcrun devicectl device info apps --device "$udid" --include-all-apps 2>&1)
+                    if [ $? -eq 0 ]; then
+                        echo "${log_prefix} ✅ App list retrieved via xcrun devicectl"
+                        echo "${log_prefix} ✅ Installed apps:"
+                        echo "$list_result" | head -20 | while read line; do
+                            echo "${log_prefix}    $line"
+                        done
+                        local app_count=$(echo "$list_result" | wc -l)
+                        if [ "$app_count" -gt 20 ]; then
+                            echo "${log_prefix}    ... and $((app_count - 20)) more apps"
+                        fi
+                        return
+                    else
+                        echo "${log_prefix} ❌ xcrun devicectl failed: $list_result"
+                    fi
+                fi
+            fi
+            
+            # Method 2: Use WebDriverAgent to get basic app info
+            local session=$(get_device_session "$device_name")
+            if [ -n "$session" ] && [ -n "$host" ]; then
+                echo "${log_prefix} 🔄 Trying WebDriverAgent for basic app detection..."
+                
+                # Test a few common apps to demonstrate the approach
+                local test_apps=(
+                    "com.apple.mobilesafari"
+                    "com.apple.mobilemail" 
+                    "com.apple.MobileSMS"
+                    "com.apple.camera"
+                    "com.apple.mobilenotes"
+                    "com.apple.Preferences"
+                    "com.mobileiron.enterprise.anyware.ios"
+                    "com.facebook.Facebook"
+                    "com.google.chrome.ios"
+                    "com.microsoft.Office.Outlook"
+                )
+                
+                echo "${log_prefix} 📱 Checking common/enterprise apps via WebDriverAgent..."
+                local found_apps=()
+                
+                for bundle_id in "${test_apps[@]}"; do
+                    local app_state_response=$(curl -s -X GET "http://localhost:${port}/wda/apps/state" \
+                        -H 'Content-Type: application/json' \
+                        -d "{\"bundleId\":\"$bundle_id\"}" 2>/dev/null)
+                    
+                    if echo "$app_state_response" | grep -q '"value"' && ! echo "$app_state_response" | grep -q '"error"'; then
+                        local state_value=$(echo "$app_state_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    state = data.get('value', 0)
+    if state > 0:  # App is installed if state > 0
+        print('installed')
+    else:
+        print('not_installed')
+except:
+    print('error')" 2>/dev/null)
+                        
+                        if [ "$state_value" = "installed" ]; then
+                            found_apps+=("$bundle_id")
+                        fi
+                    fi
+                done
+                
+                if [ ${#found_apps[@]} -gt 0 ]; then
+                    echo "${log_prefix} ✅ Found installed apps via WebDriverAgent:"
+                    local matches=0
+                    for app in "${found_apps[@]}"; do
+                        if [ -z "$search_term" ] || echo "$app" | grep -qi "$search_term"; then
+                            echo "${log_prefix}    $app - installed"
+                            ((matches++))
+                        fi
+                    done
+                    
+                    if [ -n "$search_term" ] && [ $matches -eq 0 ]; then
+                        echo "${log_prefix} ❌ No apps found matching: '$search_term'"
+                    elif [ -n "$search_term" ]; then
+                        echo "${log_prefix} 🎯 Found $matches app(s) matching: '$search_term'"
+                    fi
+                else
+                    echo "${log_prefix} ❌ No apps detected via WebDriverAgent"
+                fi
+            else
+                echo "${log_prefix} ❌ No WebDriverAgent session available"
+            fi
+            
+            # Method 3: Suggest manual verification
+            echo "${log_prefix} 💡 For complete app listing on wireless devices:"
+            echo "${log_prefix}    • Use Xcode → Window → Devices and Simulators"
+            echo "${log_prefix}    • Or check specific apps with: appinfo <bundle_id>"
+            ;;
+            
+        "debug"|"test")
+            echo "${log_prefix} 🔍 Running debug tests..."
+            
+            # Get device UDID
+            local device_details
+            device_details=$(get_device_details "$device_name")
+            local udid=$(echo "$device_details" | cut -d',' -f2)
+            
+            echo "${log_prefix} Device: $device_name"
+            echo "${log_prefix} UDID: $udid"
+            
+            if [ -n "$udid" ]; then
+                echo "${log_prefix} 🧪 Testing idevice tools..."
+                
+                # Test 1: Check if device is detected
+                echo "${log_prefix} Test 1: Device detection"
+                if command -v idevice_id >/dev/null 2>&1; then
+                    local detected_devices=$(idevice_id -l 2>/dev/null)
+                    if echo "$detected_devices" | grep -q "$udid"; then
+                        echo "${log_prefix} ✅ Device detected by idevice_id"
+                    else
+                        echo "${log_prefix} ❌ Device NOT detected by idevice_id"
+                        echo "${log_prefix} Available devices: $detected_devices"
+                    fi
+                else
+                    echo "${log_prefix} ❌ idevice_id not found"
+                fi
+                
+                # Test 2: Raw ideviceinstaller command
+                echo "${log_prefix} Test 2: Raw ideviceinstaller"
+                local raw_command="ideviceinstaller -u '$udid' list --user"
+                echo "${log_prefix} Command: $raw_command"
+                local raw_result=$(eval $raw_command 2>&1)
+                local raw_exit=$?
+                echo "${log_prefix} Exit code: $raw_exit"
+                if [ $raw_exit -eq 0 ]; then
+                    local app_count=$(echo "$raw_result" | wc -l)
+                    echo "${log_prefix} ✅ Success! Found $app_count apps"
+                    echo "${log_prefix} Sample apps:"
+                    echo "$raw_result" | head -3 | while read line; do
+                        echo "${log_prefix}    $line"
+                    done
+                else
+                    echo "${log_prefix} ❌ Failed: $raw_result"
+                fi
+                
+                # Test 3: Your specific app search
+                echo "${log_prefix} Test 3: MobileIron app search"
+                local mobileiron_search=$(eval $raw_command 2>/dev/null | grep -i mobileiron)
+                if [ -n "$mobileiron_search" ]; then
+                    echo "${log_prefix} ✅ Found MobileIron apps:"
+                    echo "$mobileiron_search" | while read line; do
+                        echo "${log_prefix}    $line"
+                    done
+                else
+                    echo "${log_prefix} ❌ No MobileIron apps found"
+                fi
+                
+            else
+                echo "${log_prefix} ❌ No UDID available for testing"
+            fi
+            ;;
+            
+        "appinfo"|"version")
+            local bundle_id="$cmd_args"
+            echo "${log_prefix} Getting app info: $bundle_id"
+            
+            # Get device UDID for app info
+            local device_details
+            device_details=$(get_device_details "$device_name")
+            local udid=$(echo "$device_details" | cut -d',' -f2)
+            
+            if [ -n "$udid" ]; then
+                echo "${log_prefix} 📱 Checking app info via iOS tools..."
+                
+                # Try different methods to get app info
+                if command -v ideviceinstaller >/dev/null 2>&1; then
+                    # Method 1: Search by exact bundle ID
+                    echo "${log_prefix} 🔍 Searching for exact bundle ID: $bundle_id"
+                    local app_info=$(ideviceinstaller -u "$udid" list --bundle-identifier "$bundle_id" 2>/dev/null)
+                    
+                    if [ -n "$app_info" ]; then
+                        echo "${log_prefix} ✅ App found (exact match):"
+                        echo "${log_prefix}    $app_info"
+                    else
+                        # Method 2: List all apps and grep for partial matches
+                        echo "${log_prefix} 🔍 Searching all installed apps for pattern..."
+                        local all_apps=$(ideviceinstaller -u "$udid" list --all 2>/dev/null)
+                        local found_apps=$(echo "$all_apps" | grep -i "$bundle_id" 2>/dev/null)
+                        
+                        if [ -n "$found_apps" ]; then
+                            echo "${log_prefix} ✅ Found matching apps:"
+                            echo "$found_apps" | while read line; do
+                                echo "${log_prefix}    $line"
+                            done
+                        else
+                            # Method 3: Search by partial bundle ID (useful for enterprise apps)
+                            local partial_search=$(echo "$bundle_id" | sed 's/.*\.//')  # Get last part after dot
+                            local partial_apps=$(echo "$all_apps" | grep -i "$partial_search" 2>/dev/null)
+                            
+                            if [ -n "$partial_apps" ]; then
+                                echo "${log_prefix} ✅ Found apps with similar names:"
+                                echo "$partial_apps" | while read line; do
+                                    echo "${log_prefix}    $line"
+                                done
+                            else
+                                echo "${log_prefix} ❌ App not found: $bundle_id"
+                            fi
+                        fi
+                    fi
+                elif command -v xcrun >/dev/null 2>&1; then
+                    # Use xcrun devicectl to get app info (iOS 17+)
+                    echo "${log_prefix} 🔄 Checking via xcrun devicectl..."
+                    local app_info=$(xcrun devicectl device info apps --device "$udid" --bundle-id "$bundle_id" 2>&1)
+                    
+                    if [ $? -eq 0 ] && [ -n "$app_info" ] && ! echo "$app_info" | grep -q "No matching apps found"; then
+                        echo "${log_prefix} ✅ App info:"
+                        echo "$app_info" | while read line; do
+                            echo "${log_prefix}    $line"
+                        done
+                    else
+                        echo "${log_prefix} ❌ App not found or info unavailable: $bundle_id"
+                        echo "${log_prefix} Response: $app_info"
+                    fi
+                else
+                    echo "${log_prefix} ❌ No iOS app info tools found"
+                    echo "${log_prefix} Please install ideviceinstaller or use Xcode"
+                fi
+                
+                # Alternative: Try to get app info through WebDriverAgent if available
+                local session=$(get_device_session "$device_name")
+                if [ -n "$session" ]; then
+                    echo "${log_prefix} 🔍 Checking if app is installed via WDA..."
+                    local wda_response=$(curl -s -X GET "http://localhost:${port}/wda/apps/state" \
+                        -H 'Content-Type: application/json' \
+                        -d "{\"bundleId\":\"$bundle_id\"}" 2>/dev/null)
+                    
+                    if echo "$wda_response" | grep -q '"value"' && ! echo "$wda_response" | grep -q '"error"'; then
+                        local app_state=$(echo "$wda_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    state = data.get('value', 0)
+    states = {0: 'Not installed', 1: 'Not running', 2: 'Running in background', 3: 'Running in foreground', 4: 'Running but suspended'}
+    print(f'App State: {states.get(state, f\"Unknown ({state})\")}')" 2>/dev/null)
+                        
+                        if [ -n "$app_state" ]; then
+                            echo "${log_prefix} ✅ $app_state"
+                        fi
+                    fi
+                fi
+            else
+                echo "${log_prefix} ❌ Device UDID not available"
+            fi
+            ;;
+            
+        "darkmode"|"lightmode"|"theme"|"appearance")
+            if [ "$cmd_type" = "appearance" ] && [ -z "$cmd_args" ]; then
+                # Just check current appearance
+                echo "${log_prefix} Checking current appearance..."
+                check_appearance_mode "$device_name"
+            else
+                local mode=""
+                case "$cmd_type" in
+                    "darkmode") mode="dark" ;;
+                    "lightmode") mode="light" ;;
+                    "theme") mode="$cmd_args" ;;
+                    "appearance") mode="$cmd_args" ;;
+                esac
+                if [ -z "$mode" ]; then
+                    mode="toggle"
+                fi
+                echo "${log_prefix} Setting theme to: $mode"
+                
+                # Try multiple methods for theme switching
+                if ! toggle_dark_mode "$device_name" "$mode"; then
+                    # Fallback: Try direct URL scheme approach
+                    echo "${log_prefix} Trying alternative method..."
+                    local session=$(get_device_session "$device_name")
+                    if [ -n "$session" ]; then
+                        case "$mode" in
+                            "dark"|"light")
+                                # Use Settings URL scheme
+                                local url_result=$(curl -s -X POST "http://localhost:${port}/session/$session/url" \
+                                    -H "Content-Type: application/json" \
+                                    -d '{"url": "prefs:root=DISPLAY"}' 2>/dev/null)
+                                
+                                if echo "$url_result" | grep -q '"sessionId"'; then
+                                    echo "${log_prefix} ✅ Opened Display settings - manual selection may be needed"
+                                    sleep 3
+                                    execute_wda_command "$device_name" "home" >/dev/null
+                                else
+                                    echo "${log_prefix} 💡 Please manually go to Settings > Display & Brightness > Appearance"
+                                fi
+                                ;;
+                        esac
+                    fi
+                fi
+            fi
+            ;;
+            
+        "rotate"|"rotation")
+            local orientation="$cmd_args"
+            if [ -z "$orientation" ]; then
+                orientation="toggle"
+            fi
+            echo "${log_prefix} Rotating screen to: $orientation"
+            rotate_screen "$device_name" "$orientation"
+            ;;
+            
+        "rotationlock"|"lockrotation")
+            local lock_state="$cmd_args"
+            if [ -z "$lock_state" ]; then
+                lock_state="toggle"
+            fi
+            echo "${log_prefix} Setting rotation lock: $lock_state"
+            toggle_rotation_lock "$device_name" "$lock_state"
+            ;;
+            
+        "restart"|"reboot")
+            echo "${log_prefix} 🔄 Attempting device restart..."
+            
+            # Get device UDID for wireless restart
+            local device_details
+            device_details=$(get_device_details "$device_name")
+            local udid=$(echo "$device_details" | cut -d',' -f2)
+            
+            if [ -n "$udid" ]; then
+                echo "${log_prefix} 🔄 Restarting device via wireless-compatible tools..."
+                
+                # Method 1: Try xcrun devicectl (works with wireless devices on iOS 17+)
+                if command -v xcrun >/dev/null 2>&1; then
+                    echo "${log_prefix} 🔄 Using xcrun devicectl for wireless restart..."
+                    
+                    # First try with hardware UDID
+                    local restart_result=$(xcrun devicectl device reboot --device "$udid" --timeout 10 2>&1)
+                    if [ $? -eq 0 ]; then
+                        echo "${log_prefix} ✅ Restart command sent via xcrun devicectl (UDID)"
+                        echo "${log_prefix} ⏳ Device will reboot in a few seconds..."
+                    else
+                        # Try to find device by name in devicectl list and use that identifier
+                        echo "${log_prefix} 🔍 Searching for device in CoreDevice list..."
+                        local coredevice_info=$(xcrun devicectl list devices --timeout 5 2>/dev/null | grep -v "Name\|--" | head -20)
+                        
+                        # Look for connected devices first, then any device
+                        local target_device=""
+                        if [ -n "$coredevice_info" ]; then
+                            # First try to find a connected device
+                            target_device=$(echo "$coredevice_info" | grep "connected" | head -1 | awk '{print $1}')
+                            
+                            # If no connected device, try any available device
+                            if [ -z "$target_device" ]; then
+                                target_device=$(echo "$coredevice_info" | head -1 | awk '{print $1}')
+                            fi
+                        fi
+                        
+                        if [ -n "$target_device" ]; then
+                            echo "${log_prefix} 🎯 Found target device: $target_device"
+                            local retry_result=$(xcrun devicectl device reboot --device "$target_device" --timeout 10 2>&1)
+                            if [ $? -eq 0 ]; then
+                                echo "${log_prefix} ✅ Restart command sent via xcrun devicectl (device name)"
+                                echo "${log_prefix} ⏳ Device will reboot in a few seconds..."
+                            else
+                                echo "${log_prefix} ❌ Restart failed with both UDID and device name"
+                                echo "${log_prefix} 💡 Error: $retry_result"
+                                
+                                # Final fallback to USB method
+                                echo "${log_prefix} 🔄 Trying USB fallback..."
+                                local device_control_script="$SCRIPT_DIR/ios_device_control.sh"
+                                if [ -f "$device_control_script" ] && "$device_control_script" restart "$device_name" 2>&1 | grep -q "✅"; then
+                                    echo "${log_prefix} ✅ Restart command sent via USB fallback"
+                                    echo "${log_prefix} ⏳ Device will reboot in a few seconds..."
+                                else
+                                    echo "${log_prefix} ❌ All restart methods failed"
+                                    echo "${log_prefix} 💡 Try connecting device via USB cable"
+                                fi
+                            fi
+                        else
+                            echo "${log_prefix} ❌ No devices found in CoreDevice list"
+                            echo "${log_prefix} 💡 Ensure device is paired and trusted in Xcode"
+                        fi
+                    fi
+                elif command -v idevicediagnostics >/dev/null 2>&1; then
+                    # Fallback to USB-based restart
+                    echo "${log_prefix} 🔄 xcrun not available, trying USB restart..."
+                    if idevicediagnostics -u "$udid" restart 2>/dev/null; then
+                        echo "${log_prefix} ✅ Restart command sent via USB"
+                        echo "${log_prefix} ⏳ Device will reboot in a few seconds..."
+                    else
+                        echo "${log_prefix} ❌ Restart failed - device must be USB connected"
+                        echo "${log_prefix} 💡 For wireless devices, ensure iOS 17+ and Xcode pairing"
+                    fi
+                else
+                    echo "${log_prefix} ❌ No restart tools available"
+                    echo "${log_prefix} 💡 Install Xcode command line tools or libimobiledevice"
+                fi
+            else
+                echo "${log_prefix} ❌ Device UDID not available"
+            fi
+            ;;
+            
+        "shutdown"|"poweroff")
+            echo "${log_prefix} 🔌 Attempting device shutdown..."
+            echo "${log_prefix} ⚠️  WARNING: Wireless shutdown not supported - will attempt restart instead!"
+            
+            # Get device UDID for wireless operations
+            local device_details
+            device_details=$(get_device_details "$device_name")
+            local udid=$(echo "$device_details" | cut -d',' -f2)
+            
+            if [ -n "$udid" ]; then
+                echo "${log_prefix} 🔄 Note: xcrun devicectl doesn't support shutdown, using restart..."
+                
+                # Method 1: Try xcrun devicectl reboot (closest alternative for wireless)
+                if command -v xcrun >/dev/null 2>&1; then
+                    echo "${log_prefix} 🔄 Using xcrun devicectl for wireless restart (shutdown not supported)..."
+                    
+                    # First try with hardware UDID
+                    local restart_result=$(xcrun devicectl device reboot --device "$udid" --timeout 10 2>&1)
+                    if [ $? -eq 0 ]; then
+                        echo "${log_prefix} ⚠️  Device will restart instead of shutdown (wireless limitation)"
+                        echo "${log_prefix} ⏳ Device will reboot in a few seconds..."
+                    else
+                        # Try to find device by name in devicectl list
+                        echo "${log_prefix} 🔍 Searching for device in CoreDevice list..."
+                        local coredevice_info=$(xcrun devicectl list devices --timeout 5 2>/dev/null | grep -v "Name\|--" | head -20)
+                        
+                        # Look for connected devices first
+                        local target_device=""
+                        if [ -n "$coredevice_info" ]; then
+                            target_device=$(echo "$coredevice_info" | grep "connected" | head -1 | awk '{print $1}')
+                            if [ -z "$target_device" ]; then
+                                target_device=$(echo "$coredevice_info" | head -1 | awk '{print $1}')
+                            fi
+                        fi
+                        
+                        if [ -n "$target_device" ]; then
+                            echo "${log_prefix} 🎯 Found target device: $target_device"
+                            local retry_result=$(xcrun devicectl device reboot --device "$target_device" --timeout 10 2>&1)
+                            if [ $? -eq 0 ]; then
+                                echo "${log_prefix} ⚠️  Device will restart instead of shutdown (wireless limitation)"
+                                echo "${log_prefix} ⏳ Device will reboot in a few seconds..."
+                            else
+                                echo "${log_prefix} ❌ Wireless restart failed, trying USB shutdown..."
+                                
+                                # Final fallback to USB shutdown
+                                local device_control_script="$SCRIPT_DIR/ios_device_control.sh"
+                                if [ -f "$device_control_script" ]; then
+                                    # Auto-confirm for batch operations
+                                    if echo "y" | "$device_control_script" shutdown "$device_name" 2>&1 | grep -q "✅"; then
+                                        echo "${log_prefix} ✅ Shutdown command sent via USB fallback"
+                                        echo "${log_prefix} ⏳ Device will power off in a few seconds..."
+                                    else
+                                        echo "${log_prefix} ❌ Both wireless and USB methods failed"
+                                        echo "${log_prefix} 💡 Try connecting via USB or manually power off device"
+                                    fi
+                                fi
+                            fi
+                        else
+                            echo "${log_prefix} ❌ No devices found for wireless operation"
+                            echo "${log_prefix} 💡 Ensure device is paired and trusted in Xcode"
+                        fi
+                    fi
+                elif command -v idevicediagnostics >/dev/null 2>&1; then
+                    # Fallback to USB-based shutdown
+                    echo "${log_prefix} 🔄 xcrun not available, trying USB shutdown..."
+                    if idevicediagnostics -u "$udid" shutdown 2>/dev/null; then
+                        echo "${log_prefix} ✅ Shutdown command sent via USB"
+                        echo "${log_prefix} ⏳ Device will power off in a few seconds..."
+                    else
+                        echo "${log_prefix} ❌ Shutdown failed - device must be USB connected"
+                        echo "${log_prefix} 💡 For wireless devices, only restart is supported"
+                    fi
+                else
+                    echo "${log_prefix} ❌ No device control tools available"
+                    echo "${log_prefix} 💡 Install Xcode command line tools or libimobiledevice"
+                fi
+            else
+                echo "${log_prefix} ❌ Device UDID not available"
+            fi
+            ;;
+            
+        "back"|"goback"|"navigate back"|"←")
+            echo "${log_prefix} CASE: Back navigation matched!"
+            local back_context="$cmd_args"
+            
+            local session=$(get_device_session "$device_name")
+            if [ -n "$session" ]; then
+                echo "${log_prefix} 🔙 Executing smart back navigation..."
+                
+                # Method 1: Try back button click first (most reliable)
+                echo "${log_prefix} Trying Method 1: Back button click..."
+                local back_click_payload='{
+                    "actions": [
+                        {
+                            "type": "pointer",
+                            "id": "finger1",
+                            "parameters": {"pointerType": "touch"},
+                            "actions": [
+                                {"type": "pointerMove", "duration": 0, "x": 40, "y": 110},
+                                {"type": "pointerDown", "button": 0},
+                                {"type": "pause", "duration": 150},
+                                {"type": "pointerUp", "button": 0}
+                            ]
+                        }
+                    ]
+                }'
+                
+                local click_response=$(curl -s -X POST "http://localhost:${port}/session/$session/actions" \
+                    -H 'Content-Type: application/json' \
+                    -d "$back_click_payload" 2>/dev/null)
+                
+                if echo "$click_response" | grep -q '"sessionId"' && ! echo "$click_response" | grep -q '"error"'; then
+                    echo "${log_prefix} ✅ Back navigation via button click"
+                else
+                    # Method 2: Try improved iOS native back gesture (proper edge swipe)
+                    echo "${log_prefix} Trying Method 2: iOS back gesture (proper edge swipe)..."
+                    local swipe_payload='{
+                        "actions": [
+                            {
+                                "type": "pointer",
+                                "id": "finger1",
+                                "parameters": {"pointerType": "touch"},
+                                "actions": [
+                                    {"type": "pointerMove", "duration": 0, "x": 0, "y": 400},
+                                    {"type": "pointerDown", "button": 0},
+                                    {"type": "pointerMove", "duration": 800, "x": 250, "y": 400},
+                                    {"type": "pointerUp", "button": 0}
+                                ]
+                            }
+                        ]
+                    }'
+                    
+                    local swipe_response=$(curl -s -X POST "http://localhost:${port}/session/$session/actions" \
+                        -H 'Content-Type: application/json' \
+                        -d "$swipe_payload" 2>/dev/null)
+                    
+                    if echo "$swipe_response" | grep -q '"sessionId"' && ! echo "$swipe_response" | grep -q '"error"'; then
+                        echo "${log_prefix} ✅ Back navigation via edge swipe"
+                    else
+                        # Method 3: Try WebDriverAgent drag method as fallback
+                        echo "${log_prefix} Trying Method 3: WDA drag method..."
+                        local drag_response=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/dragfromtoforduration" \
+                            -H 'Content-Type: application/json' \
+                            -d '{"fromX": 0, "fromY": 400, "toX": 250, "toY": 400, "duration": 0.8}' 2>/dev/null)
+                        
+                        if echo "$drag_response" | grep -q '"sessionId"' && ! echo "$drag_response" | grep -q '"error"'; then
+                            echo "${log_prefix} ✅ Back navigation via drag method"
+                        else
+                            # Method 4: Try context-specific back navigation
+                            echo "${log_prefix} Trying Method 4: Context-specific navigation..."
+                            case "${back_context,,}" in
+                                "settings"|"preferences")
+                                    # Settings app back - try Settings-specific position
+                                    local settings_back='{"actions":[{"type":"pointer","id":"finger1","parameters":{"pointerType":"touch"},"actions":[{"type":"pointerMove","duration":0,"x":35,"y":94},{"type":"pointerDown","button":0},{"type":"pause","duration":100},{"type":"pointerUp","button":0}]}]}'
+                                    curl -s -X POST "http://localhost:${port}/session/$session/actions" -H 'Content-Type: application/json' -d "$settings_back" >/dev/null
+                                    echo "${log_prefix} ✅ Settings back navigation"
+                                    ;;
+                                "safari"|"browser"|"web")
+                                    # Safari back navigation
+                                    local safari_back='{"actions":[{"type":"pointer","id":"finger1","parameters":{"pointerType":"touch"},"actions":[{"type":"pointerMove","duration":0,"x":44,"y":94},{"type":"pointerDown","button":0},{"type":"pause","duration":100},{"type":"pointerUp","button":0}]}]}'
+                                    curl -s -X POST "http://localhost:${port}/session/$session/actions" -H 'Content-Type: application/json' -d "$safari_back" >/dev/null
+                                    echo "${log_prefix} ✅ Safari back navigation"
+                                    ;;
+                                *)
+                                    # Method 5: Hardware home button simulation (universal fallback)
+                                    echo "${log_prefix} Trying Method 5: Home button fallback..."
+                                    local home_response=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/homescreen" \
+                                        -H 'Content-Type: application/json' -d '{}' 2>/dev/null)
+                                    
+                                    if echo "$home_response" | grep -q '"sessionId"' && ! echo "$home_response" | grep -q '"error"'; then
+                                        echo "${log_prefix} ✅ Navigated to home screen"
+                                    else
+                                        echo "${log_prefix} ❌ All back navigation methods failed"
+                                    fi
+                                    ;;
+                            esac
+                        fi
+                    fi
+                fi
+            else
+                echo "${log_prefix} ❌ No session available"
+            fi
+            ;;
+            
+        "click"|"tap")
+            echo "${log_prefix} CASE: Accessibility-first Click Activated"
+            local coords="$cmd_args"
+            
+            if [[ "$coords" =~ ^[0-9]+,[0-9]+$ ]]; then
+                # Direct coordinates - use precise W3C Actions API
+                local x=$(echo "$coords" | cut -d',' -f1)
+                local y=$(echo "$coords" | cut -d',' -f2)
+                echo "${log_prefix} 🎯 Precise coordinate click: ($x, $y)"
+                
+                local session=$(get_device_session "$device_name")
+                if [ -n "$session" ]; then
+                    local actions_payload='{
+                        "actions": [
+                            {
+                                "type": "pointer",
+                                "id": "finger1",
+                                "parameters": {"pointerType": "touch"},
+                                "actions": [
+                                    {"type": "pointerMove", "duration": 0, "x": '$x', "y": '$y'},
+                                    {"type": "pointerDown", "button": 0},
+                                    {"type": "pause", "duration": 100},
+                                    {"type": "pointerUp", "button": 0}
+                                ]
+                            }
+                        ]
+                    }'
+                    
+                    local response=$(curl -s -X POST "http://localhost:${port}/session/$session/actions" \
+                        -H 'Content-Type: application/json' \
+                        -d "$actions_payload" 2>/dev/null)
+                    
+                    if echo "$response" | grep -q '"sessionId"' && ! echo "$response" | grep -q '"error"'; then
+                        echo "${log_prefix} ✅ Coordinate click successful at ($x, $y)"
+                    else
+                        echo "${log_prefix} ❌ Coordinate click failed"
+                        echo "${log_prefix} Response: $response"
+                    fi
+                else
+                    echo "${log_prefix} ❌ No session available"
+                fi
+            else
+                # Non-AI click: Inline accessibility-first implementation
+                local text="$coords"
+                echo "${log_prefix} 🔎 Accessibility search: '$text'"
+                local session=$(get_device_session "$device_name")
+                if [ -n "$session" ]; then
+                    # Method 1: Try accessibility ID
+                    local acc_elements=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+                        -H 'Content-Type: application/json' \
+                        -d '{"using":"accessibility id","value":"'"$text"'"}' 2>/dev/null)
+                    
+                    local element_id=$(echo "$acc_elements" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements and 'ELEMENT' in elements[0]:
+        print(elements[0]['ELEMENT'])
+except: pass
+" 2>/dev/null)
+                    
+                    if [ -z "$element_id" ]; then
+                        # Method 2: Try name attribute
+                        local name_elements=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+                            -H 'Content-Type: application/json' \
+                            -d '{"using":"name","value":"'"$text"'"}' 2>/dev/null)
+                        element_id=$(echo "$name_elements" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements and 'ELEMENT' in elements[0]:
+        print(elements[0]['ELEMENT'])
+except: pass
+" 2>/dev/null)
+                    fi
+                    
+                    if [ -n "$element_id" ]; then
+                        echo "${log_prefix} ✅ Found element via accessibility"
+                        # Find clickable parent if element is StaticText or Cell
+                        local clickable_element=$(find_clickable_element "$session" "$port" "$element_id" "$device_name")
+                        if [ -n "$clickable_element" ]; then
+                            element_id="$clickable_element"
+                        fi
+                        # Get element rect for coordinates
+                        local rect_response=$(curl -s -X GET "http://localhost:${port}/session/$session/element/$element_id/rect" 2>/dev/null)
+                        local elem_x=$(echo "$rect_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    value = data.get('value', {})
+    print(int(value.get('x', 0) + value.get('width', 0) / 2))
+except: print(0)
+" 2>/dev/null)
+                        local elem_y=$(echo "$rect_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    value = data.get('value', {})
+    print(int(value.get('y', 0) + value.get('height', 0) / 2))
+except: print(0)
+" 2>/dev/null)
+                        
+                        if [ "$elem_x" -gt 0 ] && [ "$elem_y" -gt 0 ]; then
+                            echo "${log_prefix} 🎯 Element center: ($elem_x,$elem_y)"
+                            local elem_actions='{"actions":[{"type":"pointer","id":"finger1","parameters":{"pointerType":"touch"},"actions":[{"type":"pointerMove","duration":0,"x":'$elem_x',"y":'$elem_y'},{"type":"pointerDown","button":0},{"type":"pause","duration":150},{"type":"pointerUp","button":0}]}]}'
+                            local elem_response=$(curl -s -X POST "http://localhost:${port}/session/$session/actions" \
+                                -H 'Content-Type: application/json' -d "$elem_actions" 2>/dev/null)
+                            
+                            if echo "$elem_response" | grep -q '"sessionId"' && ! echo "$elem_response" | grep -q '"error"'; then
+                                echo "${log_prefix} ✅ Clicked '$text' at ($elem_x,$elem_y)"
+                            else
+                                echo "${log_prefix} ❌ Click failed"
+                            fi
+                        else
+                            # Fallback: Direct element click
+                            local click_response=$(curl -s -X POST "http://localhost:${port}/session/$session/element/$element_id/click" \
+                                -H 'Content-Type: application/json' -d '{}' 2>/dev/null)
+                            if echo "$click_response" | grep -q '"sessionId"' && ! echo "$click_response" | grep -q '"error"'; then
+                                echo "${log_prefix} ✅ Clicked '$text' via element click"
+                            else
+                                echo "${log_prefix} ❌ Click failed"
+                            fi
+                        fi
+                    else
+                        echo "${log_prefix} ❌ Element '$text' not found"
+                    fi
+                else
+                    echo "${log_prefix} ❌ No session available"
+                fi
+            fi
+            ;;
+            
+        "refresh"|"refresh_screen"|"reload_cache")
+            echo "${log_prefix} 🔄 REFRESHING SCREEN CACHE..."
+            refresh_screen_cache "$device_name"
+            echo "${log_prefix} ✅ Screen cache refreshed. Next click will re-analyze screen."
+            ;;
+            
+        "longpress"|"longclick")
+            local coords="$cmd_args"
+            if [[ "$coords" =~ ^[0-9]+,[0-9]+$ ]]; then
+                local x=$(echo "$coords" | cut -d',' -f1)
+                local y=$(echo "$coords" | cut -d',' -f2)
+                echo "${log_prefix} 🎯 Precise long press at ($x, $y)"
+                local session=$(get_device_session "$device_name")
+                if [ -n "$session" ]; then
+                    local actions_payload='{"actions":[{"type":"pointer","id":"finger1","parameters":{"pointerType":"touch"},"actions":[{"type":"pointerMove","duration":0,"x":'$x',"y":'$y'},{"type":"pointerDown","button":0},{"type":"pause","duration":800},{"type":"pointerUp","button":0}]}]}'
+                    local response=$(curl -s -X POST "http://localhost:${port}/session/$session/actions" -H 'Content-Type: application/json' -d "$actions_payload" 2>/dev/null)
+                    if echo "$response" | grep -q '"sessionId"' && ! echo "$response" | grep -q '"error"'; then
+                        echo "${log_prefix} ✅ Long press successful at ($x, $y)"
+                    else
+                        echo "${log_prefix} ❌ Long press failed"
+                        echo "${log_prefix} Response: $response"
+                    fi
+                else
+                    echo "${log_prefix} ❌ No session available"
+                fi
+            else
+                # Search for element by text - GENIUS SCALABLE APPROACH!
+                local text="$coords"
+                echo "${log_prefix} Searching for element: '$text'"
+                
+                local session=$(get_device_session "$device_name")
+                if [ -n "$session" ]; then
+                    # Step 1: Try dynamic element detection first (like long press does)
+                    echo "${log_prefix} 🔍 Attempting dynamic element detection..."
+                    local search_result=$(find_element_by_text "$session" "$host" "$text" "$device_name")
+                    local element_id=$(echo "$search_result" | cut -d'|' -f1)
+                    local found_strategy=$(echo "$search_result" | cut -d'|' -f2)
+                    
+                    if [ -n "$element_id" ]; then
+                        echo "${log_prefix} ✅ Found element dynamically using: $found_strategy"
+                        echo "${log_prefix} Element ID: $element_id"
+                        
+                        # Get element center coordinates
+                        local coordinates=$(get_element_center "$session" "$host" "$element_id")
+                        local x=$(echo "$coordinates" | cut -d',' -f1)
+                        local y=$(echo "$coordinates" | cut -d',' -f2)
+                        
+                        if [[ "$x" =~ ^[0-9]+$ ]] && [[ "$y" =~ ^[0-9]+$ ]] && [ "$x" -gt 0 ] && [ "$y" -gt 0 ]; then
+                            echo "${log_prefix} 🎯 Dynamic element center: ($x, $y)"
+                            
+                            # Use W3C Actions API for precise click
+                            echo "${log_prefix} Trying Method 1: W3C Actions API (dynamic)..."
+                            local actions_payload='{
+                                "actions": [
+                                    {
+                                        "type": "pointer",
+                                        "id": "finger1", 
+                                        "parameters": {"pointerType": "touch"},
+                                        "actions": [
+                                            {"type": "pointerMove", "duration": 0, "x": '$x', "y": '$y'},
+                                            {"type": "pointerDown", "button": 0},
+                                            {"type": "pause", "duration": 100},
+                                            {"type": "pointerUp", "button": 0}
+                                        ]
+                                    }
+                                ]
+                            }'
+                            
+                            local tap_response=$(curl -s -X POST "http://localhost:${port}/session/$session/actions" \
+                                -H 'Content-Type: application/json' \
+                                -d "$actions_payload" 2>/dev/null)
+                            
+                            echo "${log_prefix} Method 1 Response: '$tap_response'"
+                            
+                            if echo "$tap_response" | grep -q '"sessionId"' && ! echo "$tap_response" | grep -q '"error"'; then
+                                echo "${log_prefix} ✅ Successfully clicked '$text' at ($x, $y) - Dynamic Detection"
+                                echo "${log_prefix} Completed"
+                                return
+                            fi
+                        fi
+                    fi
+                    
+                    # Step 2: Fallback to device-specific coordinate mapping
+                    echo "${log_prefix} 🔄 Falling back to coordinate mapping..."
+                    local text_lower=$(echo "$text" | tr '[:upper:]' '[:lower:]')
+                    local x y found=false
+                    
+                    # Get device screen dimensions for coordinate adaptation
+                    local screen_width screen_height
+                    case "$device_name" in
+                        "iphone16p")
+                            screen_width=430; screen_height=932
+                            ;;
+                        "iphone17")
+                            screen_width=402; screen_height=874
+                            ;;
+                        "ipad")
+                            screen_width=834; screen_height=1210
+                            ;;
+                        *)
+                            screen_width=400; screen_height=800  # fallback
+                            ;;
+                    esac
+                    
+                    # Common app icons (home screen)
+                    case "$text_lower" in
+                        "settings")
+                            x=200; y=300; found=true
+                            ;;
+                        "safari")
+                            x=75; y=300; found=true
+                            ;;
+                        "camera")
+                            x=325; y=300; found=true
+                            ;;
+                        "photos")
+                            x=75; y=425; found=true
+                            ;;
+                        "messages")
+                            x=200; y=425; found=true
+                            ;;
+                        "mail")
+                            x=325; y=425; found=true
+                            ;;
+                        "phone")
+                            x=75; y=550; found=true
+                            ;;
+                        "facetime")
+                            x=200; y=550; found=true
+                            ;;
+                        # Settings app elements
+                        "general")
+                            x=200; y=200; found=true
+                            ;;
+                        "wi-fi"|"wifi")
+                            x=200; y=150; found=true
+                            ;;
+                        "bluetooth")
+                            x=200; y=200; found=true
+                            ;;
+                        "cellular")
+                            x=200; y=250; found=true
+                            ;;
+                        "personal hotspot"|"hotspot")
+                            x=200; y=300; found=true
+                            ;;
+                        "privacy & security"|"privacy")
+                            x=200; y=400; found=true
+                            ;;
+                        # Navigation elements - COMPREHENSIVE BACK SYSTEM (device-aware)
+                        "settings back"|"settings <"|"< settings")
+                            # Back button in Settings app
+                            x=$(echo "$screen_width * 0.0875" | bc); y=$(echo "$screen_height * 0.117" | bc); found=true
+                            ;;
+                        "safari back"|"safari <"|"< safari")
+                            # Back button in Safari
+                            x=$(echo "$screen_width * 0.11" | bc); y=$(echo "$screen_height * 0.117" | bc); found=true
+                            ;;
+                        "app back"|"navigation back")
+                            # Generic app back button
+                            x=$(echo "$screen_width * 0.08" | bc); y=$(echo "$screen_height * 0.1225" | bc); found=true
+                            ;;
+                        "cancel"|"cancel button")
+                            # Top-left area
+                            x=$(echo "$screen_width * 0.125" | bc); y=$(echo "$screen_width * 0.125" | bc); found=true
+                            ;;
+                        "next"|"next button")
+                            # Top-right
+                            x=$(echo "$screen_width * 0.875" | bc); y=$(echo "$screen_height * 0.125" | bc); found=true
+                            ;;
+                        "edit"|"edit button")
+                            # Top-right
+                            x=$(echo "$screen_width * 0.875" | bc); y=$(echo "$screen_height * 0.125" | bc); found=true
+                            ;;
+                        "save"|"save button")
+                            x=350; y=100; found=true
+                            ;;
+                        # Tab Bar Navigation (bottom of screen)
+                        "tab back"|"previous tab")
+                            x=100; y=680; found=true
+                            ;;
+                        "home tab"|"house"|"🏠")
+                            x=200; y=680; found=true
+                            ;;
+                        "search tab"|"🔍"|"magnifying glass")
+                            x=300; y=680; found=true
+                            ;;
+                        # Browser Navigation
+                        "browser back"|"web back")
+                            x=44; y=650; found=true
+                            ;;
+                        "browser forward"|"web forward")
+                            x=100; y=650; found=true
+                            ;;
+                        "refresh"|"reload"|"↻")
+                            x=200; y=650; found=true
+                            ;;
+                        # Control Center elements
+                        "wifi toggle"|"wifi button")
+                            x=100; y=200; found=true
+                            ;;
+                        "bluetooth toggle"|"bluetooth button")
+                            x=200; y=200; found=true
+                            ;;
+                        "airplane mode")
+                            x=50; y=200; found=true
+                            ;;
+                        # Common UI Elements - Device-aware coordinates
+                        "learn more"|"learn more >")
+                            # Typically at bottom half of screen  
+                            x=$(echo "$screen_width / 2" | bc); y=$(echo "$screen_height * 0.5" | bc); found=true
+                            ;;
+                        "continue"|"continue button")
+                            # Typically at bottom of screen (75% down)
+                            x=$(echo "$screen_width / 2" | bc); y=$(echo "$screen_height * 0.75" | bc); found=true
+                            ;;
+                        "get started"|"start"|"begin")
+                            # Usually in lower half
+                            x=$(echo "$screen_width / 2" | bc); y=$(echo "$screen_height * 0.625" | bc); found=true
+                            ;;
+                        "sign in"|"log in"|"login")
+                            # Mid-lower screen
+                            x=$(echo "$screen_width / 2" | bc); y=$(echo "$screen_height * 0.56" | bc); found=true
+                            ;;
+                        "sign up"|"register"|"create account")
+                            # Lower screen  
+                            x=$(echo "$screen_width / 2" | bc); y=$(echo "$screen_height * 0.625" | bc); found=true
+                            ;;
+                        "skip"|"skip for now"|"maybe later")
+                            # Top area, left-ish
+                            x=$(echo "$screen_width * 0.2" | bc); y=$(echo "$screen_height * 0.125" | bc); found=true
+                            ;;
+                        "allow"|"allow access"|"ok"|"okay")
+                            # Dialog right side  
+                            x=$(echo "$screen_width * 0.75" | bc); y=$(echo "$screen_height * 0.5" | bc); found=true
+                            ;;
+                        "don't allow"|"deny"|"not now")
+                            # Dialog left side
+                            x=$(echo "$screen_width * 0.25" | bc); y=$(echo "$screen_height * 0.5" | bc); found=true
+                            ;;
+                        "agree"|"accept"|"i agree")
+                            # Bottom area
+                            x=$(echo "$screen_width / 2" | bc); y=$(echo "$screen_height * 0.625" | bc); found=true
+                            ;;
+                        "try again"|"retry")
+                            # Mid screen
+                            x=$(echo "$screen_width / 2" | bc); y=$(echo "$screen_height * 0.56" | bc); found=true
+                            ;;
+                        # Navigation elements with device-aware coordinates 
+                        "back"|"< back"|"back button"|"←"|"<")
+                            # Top-left corner
+                            x=$(echo "$screen_width * 0.075" | bc); y=$(echo "$screen_height * 0.125" | bc); found=true
+                            ;;
+                        "close"|"×"|"x"|"close button")
+                            # Top-right corner  
+                            x=$(echo "$screen_width * 0.875" | bc); y=$(echo "$screen_height * 0.125" | bc); found=true
+                            ;;
+                        "done"|"done button")
+                            # Top-right
+                            x=$(echo "$screen_width * 0.875" | bc); y=$(echo "$screen_height * 0.125" | bc); found=true
+                            ;;
+                        "share"|"share button")
+                            x=350; y=100; found=true
+                            ;;
+                        "add"|"+ add"|"add item")
+                            x=350; y=100; found=true
+                            ;;
+                        "delete"|"remove"|"trash")
+                            x=350; y=100; found=true
+                            ;;
+                        "search"|"🔍 search")
+                            x=200; y=150; found=true
+                            ;;
+                        "more"|"more options"|"⋯"|"...")
+                            x=350; y=100; found=true
+                            ;;
+                        "info"|"ⓘ"|"information")
+                            x=350; y=100; found=true
+                            ;;
+                        *)
+                            found=false
+                            ;;
+                    esac
+                    
+                    if [ "$found" = "true" ]; then
+                        echo "${log_prefix} ✅ Using known coordinates for '$text': ($x, $y)"
+                        
+                        # Use CORRECT WebDriverAgent endpoint - try multiple methods
+                        echo "${log_prefix} Trying Method 1: W3C Actions API..."
+                        local actions_payload='{
+                            "actions": [
+                                {
+                                    "type": "pointer",
+                                    "id": "finger1", 
+                                    "parameters": {"pointerType": "touch"},
+                                    "actions": [
+                                        {"type": "pointerMove", "duration": 0, "x": '$x', "y": '$y'},
+                                        {"type": "pointerDown", "button": 0},
+                                        {"type": "pause", "duration": 100},
+                                        {"type": "pointerUp", "button": 0}
+                                    ]
+                                }
+                            ]
+                        }'
+                        
+                        local tap_response=$(curl -s -X POST "http://localhost:${port}/session/$session/actions" \
+                            -H 'Content-Type: application/json' \
+                            -d "$actions_payload" 2>/dev/null)
+                        
+                        echo "${log_prefix} Method 1 Response: '$tap_response'"
+                        
+                        if echo "$tap_response" | grep -q '"sessionId"' && ! echo "$tap_response" | grep -q '"error"'; then
+                            echo "${log_prefix} ✅ Successfully clicked '$text' at ($x, $y) - W3C Actions"
+                        else
+                            # Method 2: Try WebDriverAgent touch endpoint
+                            echo "${log_prefix} Trying Method 2: WDA touch endpoint..."
+                            local touch_response=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/touch/perform" \
+                                -H 'Content-Type: application/json' \
+                                -d '[{"action": "press", "options": {"x": '$x', "y": '$y'}}, {"action": "wait", "options": {"ms": 100}}, {"action": "release"}]' 2>/dev/null)
+                            
+                            echo "${log_prefix} Method 2 Response: '$touch_response'"
+                            
+                            if echo "$touch_response" | grep -q '"sessionId"' && ! echo "$touch_response" | grep -q '"error"'; then
+                                echo "${log_prefix} ✅ Successfully clicked '$text' at ($x, $y) - WDA Touch"
+                            else
+                                # Method 3: Try dragFromToForDuration with same point (acts as tap)
+                                echo "${log_prefix} Trying Method 3: Drag endpoint as tap..."
+                                local drag_response=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/dragfromtoforduration" \
+                                    -H 'Content-Type: application/json' \
+                                    -d '{"fromX": '$x', "fromY": '$y', "toX": '$x', "toY": '$y', "duration": 0.1}' 2>/dev/null)
+                                
+                                echo "${log_prefix} Method 3 Response: '$drag_response'"
+                                
+                                if echo "$drag_response" | grep -q '"sessionId"' && ! echo "$drag_response" | grep -q '"error"'; then
+                                    echo "${log_prefix} ✅ Successfully clicked '$text' at ($x, $y) - Drag Method"
+                                else
+                                    # Method 4: Try element-based approach with known coordinates
+                                    echo "${log_prefix} Trying Method 4: Element at coordinates..."
+                                    local element_response=$(curl -s -X POST "http://localhost:${port}/session/$session/element" \
+                                        -H 'Content-Type: application/json' \
+                                        -d '{"using": "xpath", "value": "//XCUIElementTypeApplication"}' 2>/dev/null)
+                                    
+                                    if echo "$element_response" | grep -q '"ELEMENT"'; then
+                                        local element_id=$(echo "$element_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    print(data.get('value', {}).get('ELEMENT', ''))
+except: pass" 2>/dev/null)
+                                        
+                                        if [ -n "$element_id" ]; then
+                                            local click_response=$(curl -s -X POST "http://localhost:${port}/session/$session/element/$element_id/click" \
+                                                -H 'Content-Type: application/json' \
+                                                -d "{\"x\": $x, \"y\": $y}" 2>/dev/null)
+                                            
+                                            echo "${log_prefix} Method 4 Response: '$click_response'"
+                                            
+                                            if echo "$click_response" | grep -q '"sessionId"' && ! echo "$click_response" | grep -q '"error"'; then
+                                                echo "${log_prefix} ✅ Successfully clicked '$text' at ($x, $y) - Element Click"
+                                            else
+                                                echo "${log_prefix} ❌ All click methods failed for '$text' at ($x, $y)"
+                                                echo "${log_prefix} 💡 WebDriverAgent version may not support standard tap endpoints"
+                                                echo "${log_prefix} 🔍 Debug info - WDA Response: $tap_response"
+                                            fi
+                                        fi
+                                    else
+                                        echo "${log_prefix} ❌ All click methods failed - no supported endpoints found"
+                                        echo "${log_prefix} 💡 Check WebDriverAgent version and capabilities"
+                                    fi
+                                fi
+                            fi
+                        fi
+                    else
+                        # Advanced fallback: Try element detection with multiple strategies
+                        echo "${log_prefix} Unknown element '$text' - using advanced detection..."
+                        
+                        # Strategy 1: Try direct accessibility ID (most common)
+                        local element_found=false
+                        local element_response=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+                            -H "Content-Type: application/json" \
+                            -d "{\"using\": \"accessibility id\", \"value\": \"$text\"}" 2>/dev/null)
+                        
+                        if echo "$element_response" | grep -q '"ELEMENT"'; then
+                            echo "${log_prefix} ✅ Found via accessibility ID"
+                            # Extract element ID and try multiple interaction methods
+                            local element_id=$(echo "$element_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements: print(elements[0].get('ELEMENT', ''))
+except: pass" 2>/dev/null)
+                            
+                            if [ -n "$element_id" ]; then
+                                echo "${log_prefix} Element ID: $element_id"
+                                
+                                # Method 1: Try direct element click
+                                echo "${log_prefix} Trying element click method..."
+                                local click_response=$(curl -s -X POST "http://localhost:${port}/session/$session/element/$element_id/click" \
+                                    -H 'Content-Type: application/json' \
+                                    -d '{}' 2>/dev/null)
+                                
+                                if echo "$click_response" | grep -q '"sessionId"' && ! echo "$click_response" | grep -q '"error"'; then
+                                    echo "${log_prefix} ✅ Successfully clicked '$text' (Element click method)"
+                                    element_found=true
+                                else
+                                    # Method 2: Get element coordinates and use W3C Actions
+                                    echo "${log_prefix} Trying coordinate extraction..."
+                                    local rect_response=$(curl -s -X GET "http://localhost:${port}/session/$session/element/$element_id/rect" \
+                                        -H 'Content-Type: application/json' 2>/dev/null)
+                                    
+                                    local center_x=$(echo "$rect_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    rect = data.get('value', {})
+    x = rect.get('x', 0)
+    width = rect.get('width', 0)
+    print(int(x + width/2))
+except: print('0')" 2>/dev/null)
+                                    
+                                    local center_y=$(echo "$rect_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    rect = data.get('value', {})
+    y = rect.get('y', 0)
+    height = rect.get('height', 0)
+    print(int(y + height/2))
+except: print('0')" 2>/dev/null)
+                                    
+                                    if [[ "$center_x" =~ ^[0-9]+$ ]] && [[ "$center_y" =~ ^[0-9]+$ ]] && [ "$center_x" -gt 0 ] && [ "$center_y" -gt 0 ]; then
+                                        echo "${log_prefix} Element center: ($center_x, $center_y)"
+                                        
+                                        # Use W3C Actions with extracted coordinates
+                                        local actions_payload='{
+                                            "actions": [
+                                                {
+                                                    "type": "pointer",
+                                                    "id": "finger1",
+                                                    "parameters": {"pointerType": "touch"},
+                                                    "actions": [
+                                                        {"type": "pointerMove", "duration": 0, "x": '$center_x', "y": '$center_y'},
+                                                        {"type": "pointerDown", "button": 0},
+                                                        {"type": "pause", "duration": 100},
+                                                        {"type": "pointerUp", "button": 0}
+                                                    ]
+                                                }
+                                            ]
+                                        }'
+                                        
+                                        local tap_response=$(curl -s -X POST "http://localhost:${port}/session/$session/actions" \
+                                            -H 'Content-Type: application/json' \
+                                            -d "$actions_payload" 2>/dev/null)
+                                        
+                                        if echo "$tap_response" | grep -q '"sessionId"' && ! echo "$tap_response" | grep -q '"error"'; then
+                                            echo "${log_prefix} ✅ Successfully clicked '$text' at ($center_x, $center_y) (Coordinate method)"
+                                            element_found=true
+                                        else
+                                            # Method 3: Fallback to Enter key (for text fields)
+                                            echo "${log_prefix} Trying Enter key fallback..."
+                                            local key_response=$(curl -s -X POST "http://localhost:${port}/session/$session/element/$element_id/value" \
+                                                -H 'Content-Type: application/json' \
+                                                -d '{"value":["\n"]}' 2>/dev/null)
+                                            
+                                            if echo "$key_response" | grep -q '"sessionId"' && ! echo "$key_response" | grep -q '"error"'; then
+                                                echo "${log_prefix} ✅ Successfully activated '$text' (Enter key method)"
+                                                element_found=true
+                                            fi
+                                        fi
+                                    else
+                                        echo "${log_prefix} ❌ Could not extract valid coordinates from element"
+                                    fi
+                                fi
+                            else
+                                echo "${log_prefix} ❌ Could not extract element ID"
+                            fi
+                        fi
+                        
+                        # Strategy 2: Try partial name matching if not found
+                        if [ "$element_found" = "false" ]; then
+                            local name_response=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+                                -H "Content-Type: application/json" \
+                                -d "{\"using\": \"name\", \"value\": \"$text\"}" 2>/dev/null)
+                            
+                            if echo "$name_response" | grep -q '"ELEMENT"'; then
+                                echo "${log_prefix} ✅ Found via name attribute"
+                                local element_id=$(echo "$name_response" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    elements = data.get('value', [])
+    if elements: print(elements[0].get('ELEMENT', ''))
+except: pass" 2>/dev/null)
+                                
+                                if [ -n "$element_id" ]; then
+                                    local key_response=$(curl -s -X POST "http://localhost:${port}/session/$session/element/$element_id/value" \
+                                        -H 'Content-Type: application/json' \
+                                        -d '{"value":["\n"]}' 2>/dev/null)
+                                    
+                                    if echo "$key_response" | grep -q '"sessionId"' && ! echo "$key_response" | grep -q '"error"'; then
+                                        echo "${log_prefix} ✅ Successfully activated '$text' (Enter key method)"
+                                        element_found=true
+                                    fi
+                                fi
+                            fi
+                        fi
+                        
+                        # Strategy 3: Suggest coordinate-based approach if all fails
+                        if [ "$element_found" = "false" ]; then
+                            echo "${log_prefix} ❌ Element '$text' not found with any method"
+                            echo "${log_prefix} 💡 Try using coordinates: click 200,300"
+                            echo "${log_prefix} 💡 Or add '$text' to the coordinate mapping system"
+                        fi
+                    fi
+                else
+                    echo "${log_prefix} ❌ No session available"
+                fi
+            fi
+            ;;
+            
+        "longpress"|"longclick")
+            echo "${log_prefix} CASE: Longpress matched!"
+            local coords="$cmd_args"
+            local duration="1.5"  # Default 1.5 seconds
+            
+            # Check if duration is specified (e.g., "100,200,2.0")
+            if [[ "$coords" =~ ^[0-9]+,[0-9]+,[0-9.]+$ ]]; then
+                duration=$(echo "$coords" | cut -d',' -f3)
+                coords=$(echo "$coords" | cut -d',' -f1,2)
+            fi
+            
+            if [[ "$coords" =~ ^[0-9]+,[0-9]+$ ]]; then
+                # Direct coordinates - use W3C Actions API for more reliable long press
+                local x=$(echo "$coords" | cut -d',' -f1)
+                local y=$(echo "$coords" | cut -d',' -f2)
+                echo "${log_prefix} Long pressing at coordinates: ($x, $y) for ${duration}s"
+                
+                local session=$(get_device_session "$device_name")
+                if [ -n "$session" ]; then
+                    # Use W3C Actions API for precise long press
+                    local duration_ms=$(python3 -c "print(int(float('$duration') * 1000))" 2>/dev/null || echo "1500")
+                    local actions_payload='{
+                        "actions": [
+                            {
+                                "type": "pointer",
+                                "id": "finger1",
+                                "parameters": {"pointerType": "touch"},
+                                "actions": [
+                                    {"type": "pointerMove", "duration": 0, "x": '$x', "y": '$y'},
+                                    {"type": "pointerDown", "button": 0},
+                                    {"type": "pause", "duration": '$duration_ms'},
+                                    {"type": "pointerUp", "button": 0}
+                                ]
+                            }
+                        ]
+                    }'
+                    
+                    local response=$(curl -s -X POST "http://localhost:${port}/session/$session/actions" \
+                        -H 'Content-Type: application/json' \
+                        -d "$actions_payload")
+                    
+                    if echo "$response" | grep -q '"sessionId"' && ! echo "$response" | grep -q '"error"'; then
+                        echo "${log_prefix} ✅ Long pressed at ($x, $y) for ${duration}s"
+                    else
+                        # Fallback to touchAndHold endpoint
+                        echo "${log_prefix} Trying fallback touchAndHold..."
+                        response=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/touchAndHold" \
+                            -H 'Content-Type: application/json' \
+                            -d "{\"x\":$x,\"y\":$y,\"duration\":$duration}")
+                        
+                        if echo "$response" | grep -q '"sessionId"' && ! echo "$response" | grep -q '"error"'; then
+                            echo "${log_prefix} ✅ Long pressed at ($x, $y)"
+                        else
+                            echo "${log_prefix} ❌ Long press failed"
+                            echo "${log_prefix} Response: $response"
+                        fi
+                    fi
+                else
+                    echo "${log_prefix} ❌ No session available"
+                fi
+            else
+                # Search for element by text - PROFESSIONAL APPIUM WAY  
+                local text="$coords"
+                echo "${log_prefix} Searching for element to long press: '$text'"
+                
+                local session=$(get_device_session "$device_name")
+                if [ -n "$session" ]; then
+                    # Use helper function to find element
+                    local search_result=$(find_element_by_text "$session" "$host" "$text" "$device_name")
+                    local element_id=$(echo "$search_result" | cut -d'|' -f1)
+                    local found_strategy=$(echo "$search_result" | cut -d'|' -f2)
+                    
+                    if [ -n "$element_id" ]; then
+                        echo "${log_prefix} ✅ Found element using: $found_strategy"
+                        
+                        # Get element center coordinates
+                        local coordinates=$(get_element_center "$session" "$host" "$element_id")
+                        local x=$(echo "$coordinates" | cut -d',' -f1)
+                        local y=$(echo "$coordinates" | cut -d',' -f2)
+                        
+                        if [[ "$x" =~ ^[0-9]+$ ]] && [[ "$y" =~ ^[0-9]+$ ]] && [ "$x" -gt 0 ] && [ "$y" -gt 0 ]; then
+                            echo "${log_prefix} Element center: ($x, $y)"
+                            
+                            # Use W3C Actions API for precise long press
+                            local duration_ms=$(python3 -c "print(int(float('$duration') * 1000))" 2>/dev/null || echo "1500")
+                            local actions_payload='{
+                                "actions": [
+                                    {
+                                        "type": "pointer",
+                                        "id": "finger1",
+                                        "parameters": {"pointerType": "touch"},
+                                        "actions": [
+                                            {"type": "pointerMove", "duration": 0, "x": '$x', "y": '$y'},
+                                            {"type": "pointerDown", "button": 0},
+                                            {"type": "pause", "duration": '$duration_ms'},
+                                            {"type": "pointerUp", "button": 0}
+                                        ]
+                                    }
+                                ]
+                            }'
+                            
+                            local longpress_response=$(curl -s -X POST "http://localhost:${port}/session/$session/actions" \
+                                -H 'Content-Type: application/json' \
+                                -d "$actions_payload")
+                            
+                            if echo "$longpress_response" | grep -q '"sessionId"' && ! echo "$longpress_response" | grep -q '"error"'; then
+                                echo "${log_prefix} ✅ Successfully long pressed '$text' for ${duration}s"
+                            else
+                                echo "${log_prefix} ❌ Long press failed on '$text'"
+                                echo "${log_prefix} Response: $longpress_response"
+                            fi
+                        else
+                            echo "${log_prefix} ❌ Could not get valid element coordinates"
+                        fi
+                    else
+                        echo "${log_prefix} ❌ Element '$text' not found with any locator strategy"
+                    fi
+                else
+                    echo "${log_prefix} ❌ No session available"
+                fi
+            fi
+            ;;
+            
+        "swipe"|"swipe_up"|"swipe_down"|"swipe_left"|"swipe_right"|"scroll")
+            echo "${log_prefix} CASE: Swipe gesture matched!"
+            local swipe_params="$cmd_args"
+            local direction=""
+            local start_x="" start_y="" end_x="" end_y=""
+            local duration="300"  # Default 300ms
+            
+            # Get device screen dimensions for optimal coordinates
+            local screen_width screen_height
+            
+            # Device-specific coordinate profiles (fallback when session detection fails)
+            case "$device_name" in
+                "iphone16p")
+                    screen_width=430; screen_height=932  # iPhone 16 Pro actual resolution
+                    echo "${log_prefix} 📱 Using iPhone 16 Pro profile: ${screen_width}×${screen_height}"
+                    ;;
+                "iphone17")
+                    screen_width=402; screen_height=874  # iPhone 17 actual resolution  
+                    echo "${log_prefix} 📱 Using iPhone 17 profile: ${screen_width}×${screen_height}"
+                    ;;
+                "ipad")
+                    screen_width=834; screen_height=1210  # iPad actual resolution
+                    echo "${log_prefix} 📱 Using iPad profile: ${screen_width}×${screen_height}"
+                    ;;
+                *)
+                    # Try to get from session first, then fallback
+                    if [ -n "$session" ]; then
+                        local screen_info=$(curl -s "http://localhost:${port}/session/$session/window/size" 2>/dev/null)
+                        if echo "$screen_info" | grep -q '"width"' 2>/dev/null; then
+                            screen_width=$(echo "$screen_info" | python3 -c "import sys,json; data=json.load(sys.stdin); print(data['value']['width']) if 'value' in data else print('400')" 2>/dev/null || echo "400")
+                            screen_height=$(echo "$screen_info" | python3 -c "import sys,json; data=json.load(sys.stdin); print(data['value']['height']) if 'value' in data else print('800')" 2>/dev/null || echo "800")
+                            echo "${log_prefix} 📱 Detected via session: ${screen_width}×${screen_height}"
+                        fi
+                    fi
+                    ;;
+            esac
+            
+            # Default fallback dimensions
+            screen_width=${screen_width:-400}
+            screen_height=${screen_height:-800}
+            
+            # Parse swipe parameters
+            if [[ "$swipe_params" =~ ^(up|down|left|right)$ ]]; then
+                # Device-optimized directional swipes based on actual screen dimensions
+                direction="$swipe_params"
+                local center_x=$((screen_width / 2))
+                local quarter_height=$((screen_height / 4))
+                local three_quarter_height=$((screen_height * 3 / 4))
+                local left_edge=$((screen_width / 8))
+                local right_edge=$((screen_width * 7 / 8))
+                local mid_height=$((screen_height / 2))
+                
+                case "$direction" in
+                    "up")
+                        # Scroll up - start from 75% height, swipe to 25% height
+                        start_x=$center_x; start_y=$three_quarter_height; end_x=$center_x; end_y=$quarter_height
+                        duration="600"  # Slower for better recognition
+                        echo "${log_prefix} 👆 Optimized swipe up for ${screen_width}×${screen_height}"
+                        ;;
+                    "down") 
+                        # Scroll down - start from 25% height, swipe to 75% height
+                        start_x=$center_x; start_y=$quarter_height; end_x=$center_x; end_y=$three_quarter_height
+                        duration="600"  # Slower for better recognition
+                        echo "${log_prefix} 👇 Optimized swipe down for ${screen_width}×${screen_height}"
+                        ;;
+                    "left")
+                        # Swipe left - from right edge to left edge at mid height
+                        start_x=$right_edge; start_y=$mid_height; end_x=$left_edge; end_y=$mid_height
+                        duration="500"  # Medium speed for page transitions
+                        echo "${log_prefix} 👈 Optimized swipe left for ${screen_width}×${screen_height}"
+                        ;;
+                    "right")
+                        # Swipe right - from left edge to right edge at mid height
+                        start_x=$left_edge; start_y=$mid_height; end_x=$right_edge; end_y=$mid_height
+                        duration="500"  # Medium speed for page transitions
+                        echo "${log_prefix} 👉 Optimized swipe right for ${screen_width}×${screen_height}"
+                        ;;
+                esac
+            elif [[ "$swipe_params" =~ ^[0-9]+,[0-9]+,[0-9]+,[0-9]+$ ]]; then
+                # Custom coordinates: "x1,y1,x2,y2"
+                start_x=$(echo "$swipe_params" | cut -d',' -f1)
+                start_y=$(echo "$swipe_params" | cut -d',' -f2)
+                end_x=$(echo "$swipe_params" | cut -d',' -f3)
+                end_y=$(echo "$swipe_params" | cut -d',' -f4)
+                direction="custom"
+            elif [[ "$swipe_params" =~ ^[0-9]+,[0-9]+,[0-9]+,[0-9]+,[0-9]+$ ]]; then
+                # Custom coordinates with duration: "x1,y1,x2,y2,duration_ms"
+                start_x=$(echo "$swipe_params" | cut -d',' -f1)
+                start_y=$(echo "$swipe_params" | cut -d',' -f2)
+                end_x=$(echo "$swipe_params" | cut -d',' -f3)
+                end_y=$(echo "$swipe_params" | cut -d',' -f4)
+                duration=$(echo "$swipe_params" | cut -d',' -f5)
+                direction="custom"
+            else
+                echo "${log_prefix} ❌ Invalid swipe format. Use: swipe up/down/left/right OR swipe x1,y1,x2,y2[,duration]"
+                echo "${log_prefix} Examples: swipe up, swipe 100,200,300,400, swipe 50,50,350,600,500"
+                continue
+            fi
+            
+            local session=$(get_device_session "$device_name")
+            if [ -n "$session" ]; then
+                if [ "$direction" = "custom" ]; then
+                    echo "${log_prefix} 👆 Swiping custom from ($start_x,$start_y) to ($end_x,$end_y) [${duration}ms]"
+                else
+                    echo "${log_prefix} 👆 Swiping ${direction} from ($start_x,$start_y) to ($end_x,$end_y) [${duration}ms] - Screen ${screen_width}×${screen_height}"
+                fi
+                
+                # Use W3C Actions API for precise swipe gesture
+                local swipe_payload='{
+                    "actions": [
+                        {
+                            "type": "pointer",
+                            "id": "finger1",
+                            "parameters": {"pointerType": "touch"},
+                            "actions": [
+                                {"type": "pointerMove", "duration": 0, "x": '$start_x', "y": '$start_y'},
+                                {"type": "pointerDown", "button": 0},
+                                {"type": "pointerMove", "duration": '$duration', "x": '$end_x', "y": '$end_y'},
+                                {"type": "pointerUp", "button": 0}
+                            ]
+                        }
+                    ]
+                }'
+                
+                local response=$(curl -s -X POST "http://localhost:${port}/session/$session/actions" \
+                    -H 'Content-Type: application/json' \
+                    -d "$swipe_payload" 2>/dev/null)
+                
+                if echo "$response" | grep -q '"sessionId"' && ! echo "$response" | grep -q '"error"'; then
+                    echo "${log_prefix} ✅ Swipe gesture successful"
+                else
+                    # Fallback: Try WebDriverAgent drag endpoint
+                    echo "${log_prefix} Trying fallback drag method..."
+                    local duration_sec=$(python3 -c "print(float('$duration')/1000)" 2>/dev/null || echo "0.3")
+                    local drag_response=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/dragfromtoforduration" \
+                        -H 'Content-Type: application/json' \
+                        -d "{\"fromX\": $start_x, \"fromY\": $start_y, \"toX\": $end_x, \"toY\": $end_y, \"duration\": $duration_sec}" 2>/dev/null)
+                    
+                    if echo "$drag_response" | grep -q '"sessionId"' && ! echo "$drag_response" | grep -q '"error"'; then
+                        echo "${log_prefix} ✅ Swipe gesture successful (drag method)"
+                    else
+                        echo "${log_prefix} ❌ Swipe gesture failed"
+                        echo "${log_prefix} Response: $response"
+                    fi
+                fi
+            else
+                echo "${log_prefix} ❌ No session available"
+            fi
+            ;;
+            
+        "getLocators"|"getlocators"|"locators")
+            echo "${log_prefix} 🔍 Getting all locators from current screen"
+            
+            local session=$(get_device_session "$device_name")
+            if [ -n "$session" ]; then
+                # Check what app is currently active (don't disrupt it)
+                echo "${log_prefix} 📱 Checking active app..."
+                local active_app_info=$(curl -s -X GET "http://localhost:$port/wda/activeAppInfo" 2>/dev/null)
+                local bundle_id=$(echo "$active_app_info" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    print(data.get('value', {}).get('bundleId', 'com.apple.springboard'))
+except:
+    print('com.apple.springboard')
+" 2>/dev/null)
+                
+                if [ "$bundle_id" = "com.apple.springboard" ]; then
+                    echo "${log_prefix} ℹ️  Currently on Home Screen"
+                else
+                    echo "${log_prefix} ℹ️  Active app: $bundle_id"
+                fi
+                
+                echo "${log_prefix} 📱 Fetching page source..."
+                local page_source=$(curl -s -X GET "http://localhost:$port/session/$session/source" 2>/dev/null)
+                
+                if [ -n "$page_source" ] && ! echo "$page_source" | grep -q '"error"'; then
+                    echo "${log_prefix} 🔍 Extracting locators..."
+                    
+                    # Extract all locator information using Python
+                    local locators=$(echo "$page_source" | python3 -c "
+import sys
+import json
+import xml.etree.ElementTree as ET
+
+try:
+    data = json.load(sys.stdin)
+    xml_str = data.get('value', '')
+    
+    if not xml_str:
+        print('❌ No page source found')
+        sys.exit(1)
+    
+    root = ET.fromstring(xml_str)
+    locators = []
+    
+    # Extract locators from all elements
+    for elem in root.iter():
+        locator_info = {}
+        
+        # Get element type
+        elem_type = elem.tag
+        locator_info['type'] = elem_type
+        
+        # Get name/label
+        name = elem.get('name', '')
+        label = elem.get('label', '')
+        value = elem.get('value', '')
+        
+        if name:
+            locator_info['name'] = name
+        if label:
+            locator_info['label'] = label
+        if value:
+            locator_info['value'] = value
+        
+        # Get accessible property
+        accessible = elem.get('accessible', 'false')
+        locator_info['accessible'] = accessible
+        
+        # Get visible property
+        visible = elem.get('visible', 'false')
+        locator_info['visible'] = visible
+        
+        # Get enabled property
+        enabled = elem.get('enabled', 'true')
+        locator_info['enabled'] = enabled
+        
+        # Get coordinates
+        x = elem.get('x', '')
+        y = elem.get('y', '')
+        width = elem.get('width', '')
+        height = elem.get('height', '')
+        
+        if x and y and width and height:
+            locator_info['coordinates'] = f'({x},{y}) {width}x{height}'
+        
+        # Only add if we have meaningful locator information
+        if name or label or value:
+            locators.append(locator_info)
+    
+    # Print formatted output
+    if locators:
+        print(f'\\n📋 Found {len(locators)} interactive elements:\\n')
+        for i, loc in enumerate(locators, 1):
+            # Build single line output with Name first, better formatting
+            parts = []
+            
+            # Start with number and Name (most important for clicking)
+            name = loc.get('name', '')
+            if name:
+                parts.append(f'{i:3d}. 📍 {name:40s}')
+            else:
+                parts.append(f'{i:3d}. 📍 {\"(no name)\":40s}')
+            
+            # Add Type (shortened for readability)
+            elem_type = loc.get('type', 'unknown').replace('XCUIElementType', '')
+            parts.append(f'[{elem_type:15s}]')
+            
+            # Add Label if different from Name
+            label = loc.get('label', '')
+            if label and label != name:
+                parts.append(f'Label:{label:30s}' if len(label) <= 30 else f'Label:{label[:27]}...')
+            
+            # Add Value if present
+            value = loc.get('value', '')
+            if value and value != name and value != label:
+                parts.append(f'Val:{value:20s}' if len(value) <= 20 else f'Val:{value[:17]}...')
+            
+            # Add Position
+            if loc.get('coordinates'):
+                parts.append(f'@ {loc[\"coordinates\"]}')
+            
+            # Add status flags (compact)
+            flags = []
+            if loc.get('visible') == 'true':
+                flags.append('✓Vis')
+            if loc.get('enabled') == 'true':
+                flags.append('✓En')
+            if flags:
+                parts.append(' '.join(flags))
+            
+            print(' │ '.join(parts))
+    else:
+        print('❌ No interactive elements found with locator information')
+        
+except Exception as e:
+    print(f'❌ Error parsing page source: {e}')
+    sys.exit(1)
+" 2>&1)
+                    
+                    if [ $? -eq 0 ]; then
+                        echo "${log_prefix} $locators"
+                        echo "${log_prefix} ✅ Locators extraction complete"
+                    else
+                        echo "${log_prefix} ❌ Failed to extract locators: $locators"
+                    fi
+                else
+                    echo "${log_prefix} ❌ Failed to get page source"
+                fi
+            else
+                echo "${log_prefix} ❌ No session available"
+            fi
+            ;;
+            
+        *)
+            # Text input - use existing persistent session (like original script)
+            echo "${log_prefix} CASE: Default text input"
+            echo "${log_prefix} Sending text: $command"
+            
+            # Convert text to JSON array format (properly escape for shell safety)
+            local json_array=$(python3 -c "
+import json
+import sys
+text = sys.argv[1] if len(sys.argv) > 1 else ''
+print(json.dumps([text]))" "$command" 2>/dev/null)
+            
+            if [ -n "$json_array" ]; then
+                # Use the persistent session for this device
+                local session=$(get_device_session "$device_name")
+                
+                if [ -n "$session" ]; then
+                    # Send text using existing session (preserves current app context)
+                    local response=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/keys" \
+                        -H 'Content-Type: application/json' \
+                        -d "{\"value\":$json_array}")
+                    
+                    if echo "$response" | grep -q '"sessionId"' && ! echo "$response" | grep -q '"error"'; then
+                        echo "${log_prefix} ✅ Text sent"
+                        
+                        # Auto-press Enter after text with minimal delay
+                        sleep 0.1
+                        local enter_array=$(python3 -c "import json; print(json.dumps(['\\n']))" 2>/dev/null)
+                        local enter_response=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/keys" \
+                            -H 'Content-Type: application/json' \
+                            -d "{\"value\":$enter_array}")
+                        
+                        if echo "$enter_response" | grep -q '"sessionId"' && ! echo "$enter_response" | grep -q '"error"'; then
+                            echo "${log_prefix} ✅ Auto-pressed Enter"
+                        fi
+                    else
+                        echo "${log_prefix} ❌ Text send failed"
+                    fi
+                    
+                    # DO NOT clean up session - keep it for future commands!
+                else
+                    echo "${log_prefix} ❌ No session available"
+                fi
+            else
+                echo "${log_prefix} ❌ JSON encoding failed"
+            fi
+            ;;
+    esac
+}
+
+# Check current appearance mode (helper function)
+check_appearance_mode() {
+    local device="$1"
+    
+    local device_details
+    device_details=$(get_device_details "$device")
+    if [ $? -ne 0 ]; then
+        print_color "$RED" "❌ Device not found: $device"
+        return 1
+    fi
+    
+    local port=$(echo "$device_details" | cut -d',' -f1)
+    local session=$(get_device_session "$device")
+    
+    if [ -n "$session" ]; then
+        # Try to get current appearance info via WDA
+        local appearance_info=$(curl -s -X GET "http://localhost:${port}/session/$session/appium/device/current_activity" 2>/dev/null)
+        
+        if echo "$appearance_info" | grep -q "dark\|Dark"; then
+            print_color "$BLUE" "🌙 $device: Currently in Dark Mode"
+        elif echo "$appearance_info" | grep -q "light\|Light"; then
+            print_color "$YELLOW" "☀️ $device: Currently in Light Mode"  
+        else
+            print_color "$CYAN" "❓ $device: Appearance mode unknown"
+        fi
+    else
+        print_color "$RED" "❌ $device: No session available to check appearance"
+    fi
+}
+
+# Dark Mode / Light Mode Toggle
+toggle_dark_mode() {
+    local device="$1"
+    local mode="${2:-toggle}"  # toggle, dark, light
+    
+    local device_details
+    device_details=$(get_device_details "$device")
+    if [ $? -ne 0 ]; then
+        print_color "$RED" "❌ Device not found: $device"
+        return 1
+    fi
+    
+    local port=$(echo "$device_details" | cut -d',' -f1)
+    local udid=$(echo "$device_details" | cut -d',' -f2)
+    
+    # Method 1: Try using xcrun devicectl (iOS 17+)
+    if command -v xcrun >/dev/null 2>&1; then
+        print_color "$CYAN" "$device: Trying xcrun devicectl for appearance..."
+        
+        case "$mode" in
+            "dark")
+                local result=$(xcrun devicectl device install app --device "$udid" --json 2>/dev/null || echo "not_supported")
+                if [ "$result" != "not_supported" ]; then
+                    # Try using xcrun to set appearance (if supported)
+                    xcrun simctl ui "$udid" appearance dark 2>/dev/null && {
+                        print_color "$GREEN" "✅ $device: Set to Dark Mode via xcrun"
+                        return 0
+                    }
+                fi
+                ;;
+            "light")
+                xcrun simctl ui "$udid" appearance light 2>/dev/null && {
+                    print_color "$GREEN" "✅ $device: Set to Light Mode via xcrun"
+                    return 0
+                }
+                ;;
+        esac
+    fi
+    
+    # Method 2: Try using idevice tools with terminal commands
+    if command -v idevice-app-runner >/dev/null 2>&1 || command -v ios-deploy >/dev/null 2>&1; then
+        print_color "$CYAN" "$device: Trying iOS terminal commands..."
+        
+        # Use shortcuts if available (requires Shortcuts app)
+        local shortcuts_bundle="com.apple.shortcuts"
+        local session=$(get_device_session "$device")
+        
+        if [ -n "$session" ]; then
+            # Try to create a simple shortcut command via WDA
+            local shortcut_url="http://localhost:${port}/session/$session/url"
+            
+            case "$mode" in
+                "dark")
+                    # Use URL scheme to trigger shortcuts or settings
+                    local result=$(curl -s -X POST "$shortcut_url" \
+                        -H "Content-Type: application/json" \
+                        -d '{"url": "prefs:root=DISPLAY&path=APPEARANCE"}' 2>/dev/null)
+                    
+                    if echo "$result" | grep -q '"sessionId"'; then
+                        sleep 1
+                        # Try to tap the Dark option
+                        local tap_result=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/tap/0" \
+                            -H "Content-Type: application/json" \
+                            -d '{"x": 100, "y": 400}' 2>/dev/null)
+                        
+                        print_color "$GREEN" "✅ $device: Attempted Dark Mode via Settings URL"
+                        execute_wda_command "$device" "home" >/dev/null
+                        return 0
+                    fi
+                    ;;
+                "light")
+                    local result=$(curl -s -X POST "$shortcut_url" \
+                        -H "Content-Type: application/json" \
+                        -d '{"url": "prefs:root=DISPLAY&path=APPEARANCE"}' 2>/dev/null)
+                    
+                    if echo "$result" | grep -q '"sessionId"'; then
+                        sleep 1
+                        # Try to tap the Light option
+                        local tap_result=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/tap/0" \
+                            -H "Content-Type: application/json" \
+                            -d '{"x": 100, "y": 300}' 2>/dev/null)
+                        
+                        print_color "$GREEN" "✅ $device: Attempted Light Mode via Settings URL"
+                        execute_wda_command "$device" "home" >/dev/null
+                        return 0
+                    fi
+                    ;;
+            esac
+        fi
+    fi
+    
+    # Method 3: Enhanced WDA approach with better element detection
+    local session=$(get_device_session "$device")
+    if [ -n "$session" ]; then
+        print_color "$CYAN" "$device: Using enhanced WDA method..."
+        
+        # Open Settings using URL scheme first
+        local settings_result=$(curl -s -X POST "http://localhost:${port}/session/$session/url" \
+            -H "Content-Type: application/json" \
+            -d '{"url": "App-prefs:DISPLAY"}' 2>/dev/null)
+        
+        if ! echo "$settings_result" | grep -q '"sessionId"'; then
+            # Fallback: Launch Settings app manually
+            execute_wda_command "$device" "launch com.apple.Preferences" >/dev/null
+            sleep 2
+            
+            # Try to find and tap Display & Brightness
+            local search_url="http://localhost:${port}/session/$session/elements"
+            local elements_result=$(curl -s -X POST "$search_url" \
+                -H "Content-Type: application/json" \
+                -d '{"using": "partial link text", "value": "Display"}' 2>/dev/null)
+            
+            if ! echo "$elements_result" | grep -q '"ELEMENT"'; then
+                # Try alternative search methods
+                elements_result=$(curl -s -X POST "$search_url" \
+                    -H "Content-Type: application/json" \
+                    -d '{"using": "accessibility id", "value": "Display & Brightness"}' 2>/dev/null)
+            fi
+            
+            if echo "$elements_result" | grep -q '"ELEMENT"'; then
+                local element_id=$(echo "$elements_result" | grep -o '"ELEMENT":"[^"]*"' | head -1 | cut -d'"' -f4)
+                curl -s -X POST "http://localhost:${port}/session/$session/element/$element_id/click" >/dev/null
+                sleep 1
+            fi
+        fi
+        
+        sleep 2
+        
+        # Now try to find and click the appearance option
+        case "$mode" in
+            "dark")
+                # Look for Dark mode option with multiple strategies
+                local dark_elements=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+                    -H "Content-Type: application/json" \
+                    -d '{"using": "accessibility id", "value": "Dark"}' 2>/dev/null)
+                
+                if echo "$dark_elements" | grep -q '"ELEMENT"'; then
+                    local dark_id=$(echo "$dark_elements" | grep -o '"ELEMENT":"[^"]*"' | head -1 | cut -d'"' -f4)
+                    curl -s -X POST "http://localhost:${port}/session/$session/element/$dark_id/click" >/dev/null
+                    print_color "$GREEN" "✅ $device: Switched to Dark Mode"
+                else
+                    # Fallback: Try coordinates (approximate location of Dark option)
+                    curl -s -X POST "http://localhost:${port}/session/$session/wda/tap/0" \
+                        -H "Content-Type: application/json" \
+                        -d '{"x": 60, "y": 450}' >/dev/null
+                    print_color "$YELLOW" "⚠️ $device: Attempted Dark Mode (coordinate fallback)"
+                fi
+                ;;
+            "light")
+                local light_elements=$(curl -s -X POST "http://localhost:${port}/session/$session/elements" \
+                    -H "Content-Type: application/json" \
+                    -d '{"using": "accessibility id", "value": "Light"}' 2>/dev/null)
+                
+                if echo "$light_elements" | grep -q '"ELEMENT"'; then
+                    local light_id=$(echo "$light_elements" | grep -o '"ELEMENT":"[^"]*"' | head -1 | cut -d'"' -f4)
+                    curl -s -X POST "http://localhost:${port}/session/$session/element/$light_id/click" >/dev/null
+                    print_color "$GREEN" "✅ $device: Switched to Light Mode"
+                else
+                    # Fallback: Try coordinates (approximate location of Light option)
+                    curl -s -X POST "http://localhost:${port}/session/$session/wda/tap/0" \
+                        -H "Content-Type: application/json" \
+                        -d '{"x": 60, "y": 350}' >/dev/null
+                    print_color "$YELLOW" "⚠️ $device: Attempted Light Mode (coordinate fallback)"
+                fi
+                ;;
+            *)
+                # Toggle mode - try to detect current and switch
+                print_color "$YELLOW" "⚠️ $device: Toggle mode - manual selection may be needed"
+                ;;
+        esac
+        
+        # Go back to home
+        sleep 1
+        execute_wda_command "$device" "home" >/dev/null
+        return 0
+    else
+        print_color "$RED" "❌ $device: No WDA session available"
+        return 1
+    fi
+}
+
+# Screen Rotation Functions
+rotate_screen() {
+    local device="$1"
+    local orientation="${2:-toggle}"  # portrait, landscape-left, landscape-right, portrait-upside-down, toggle
+    
+    local device_details
+    device_details=$(get_device_details "$device")
+    if [ $? -ne 0 ]; then
+        print_color "$RED" "❌ Device not found: $device"
+        return 1
+    fi
+    
+    local port=$(echo "$device_details" | cut -d',' -f1)
+    local udid=$(echo "$device_details" | cut -d',' -f2)
+    
+    # Method 1: Try using xcrun devicectl for rotation (iOS 17+)
+    if command -v xcrun >/dev/null 2>&1; then
+        case "$orientation" in
+            "portrait"|"1")
+                if xcrun simctl status_bar "$udid" override --orientation portrait 2>/dev/null; then
+                    print_color "$GREEN" "✅ $device: Rotated to Portrait via xcrun"
+                    return 0
+                fi
+                ;;
+            "landscape-left"|"landscape"|"3")
+                if xcrun simctl status_bar "$udid" override --orientation landscapeLeft 2>/dev/null; then
+                    print_color "$GREEN" "✅ $device: Rotated to Landscape Left via xcrun"
+                    return 0
+                fi
+                ;;
+            "landscape-right"|"4")
+                if xcrun simctl status_bar "$udid" override --orientation landscapeRight 2>/dev/null; then
+                    print_color "$GREEN" "✅ $device: Rotated to Landscape Right via xcrun"
+                    return 0
+                fi
+                ;;
+        esac
+    fi
+    
+    # Method 2: Use WDA orientation API
+    local session=$(get_device_session "$device")
+    if [ -n "$session" ]; then
+        local orientation_url="http://localhost:${port}/session/$session/orientation"
+        
+        # Get current orientation first
+        local current_orientation=$(curl -s -X GET "$orientation_url" | grep -o '"value":"[^"]*"' | cut -d'"' -f4)
+        
+        # Map orientation names to WDA values
+        local orientation_value
+        case "$orientation" in
+            "portrait"|"1") 
+                orientation_value="PORTRAIT" 
+                ;;
+            "landscape-left"|"landscape"|"3") 
+                orientation_value="LANDSCAPE" 
+                ;;
+            "landscape-right"|"4") 
+                orientation_value="UIA_DEVICE_ORIENTATION_LANDSCAPERIGHT" 
+                ;;
+            "portrait-upside-down"|"2") 
+                orientation_value="UIA_DEVICE_ORIENTATION_PORTRAIT_UPSIDEDOWN" 
+                ;;
+            "toggle"|*)
+                # Toggle between portrait and landscape
+                case "$current_orientation" in
+                    "PORTRAIT") orientation_value="LANDSCAPE" ;;
+                    "LANDSCAPE") orientation_value="PORTRAIT" ;;
+                    *) orientation_value="LANDSCAPE" ;;  # Default to landscape if unknown
+                esac
+                ;;
+        esac
+        
+        # Set orientation via WDA
+        local response=$(curl -s -X POST "$orientation_url" \
+            -H "Content-Type: application/json" \
+            -d "{\"orientation\": \"$orientation_value\"}")
+        
+        if echo "$response" | grep -q '"value":null\|"sessionId"'; then
+            print_color "$GREEN" "✅ $device: Rotated to $orientation_value"
+            return 0
+        else
+            print_color "$YELLOW" "⚠️ $device: Rotation may not be supported or device is locked"
+        fi
+    fi
+    
+    # Method 3: Try using idevice tools if available
+    if command -v idevice-app-runner >/dev/null 2>&1; then
+        print_color "$CYAN" "$device: Trying idevice rotation tools..."
+        # Note: Most idevice tools don't support rotation directly
+        print_color "$YELLOW" "⚠️ $device: idevice rotation not directly supported"
+    fi
+    
+    print_color "$RED" "❌ $device: Could not rotate screen - may need manual rotation"
+    return 1
+}
+
+# Lock/Unlock Rotation
+toggle_rotation_lock() {
+    local device="$1"
+    local lock_state="${2:-toggle}"  # lock, unlock, toggle
+    
+    local device_details
+    device_details=$(get_device_details "$device")
+    if [ $? -ne 0 ]; then
+        print_color "$RED" "❌ Device not found: $device"
+        return 1
+    fi
+    
+    local port=$(echo "$device_details" | cut -d',' -f1)
+    local udid=$(echo "$device_details" | cut -d',' -f2)
+    
+    # Method 1: Try using terminal/xcrun commands
+    if command -v xcrun >/dev/null 2>&1; then
+        # Note: xcrun doesn't directly support rotation lock for real devices
+        print_color "$CYAN" "$device: Rotation lock via terminal not directly supported for physical devices"
+    fi
+    
+    # Method 2: Use WDA to access Control Center
+    local session=$(get_device_session "$device")
+    if [ -n "$session" ]; then
+        print_color "$CYAN" "$device: Opening Control Center to toggle rotation lock..."
+        
+        # Open Control Center by swiping from top-right (iOS 12+) or bottom (older iOS)
+        # Try modern swipe first (from top-right corner)
+        local swipe_result=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/dragfromtoforduration" \
+            -H "Content-Type: application/json" \
+            -d '{"fromX": 350, "fromY": 10, "toX": 350, "toY": 200, "duration": 0.5}' 2>/dev/null)
+        
+        if ! echo "$swipe_result" | grep -q '"sessionId"'; then
+            # Fallback: Try swipe up from bottom (older iOS)
+            swipe_result=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/dragfromtoforduration" \
+                -H "Content-Type: application/json" \
+                -d '{"fromX": 200, "fromY": 800, "toX": 200, "toY": 400, "duration": 0.5}' 2>/dev/null)
+        fi
+        
+        sleep 2
+        
+        # Look for rotation lock button with multiple strategies
+        local search_url="http://localhost:${port}/session/$session/elements"
+        
+        # Strategy 1: Find by accessibility identifier
+        local rotation_elements=$(curl -s -X POST "$search_url" \
+            -H "Content-Type: application/json" \
+            -d '{"using": "accessibility id", "value": "portrait-orientation-lock"}' 2>/dev/null)
+        
+        if ! echo "$rotation_elements" | grep -q '"ELEMENT"'; then
+            # Strategy 2: Find by name
+            rotation_elements=$(curl -s -X POST "$search_url" \
+                -H "Content-Type: application/json" \
+                -d '{"using": "name", "value": "Portrait Orientation Lock"}' 2>/dev/null)
+        fi
+        
+        if ! echo "$rotation_elements" | grep -q '"ELEMENT"'; then
+            # Strategy 3: Find by partial name match
+            rotation_elements=$(curl -s -X POST "$search_url" \
+                -H "Content-Type: application/json" \
+                -d '{"using": "partial link text", "value": "orientation"}' 2>/dev/null)
+        fi
+        
+        if echo "$rotation_elements" | grep -q '"ELEMENT"'; then
+            local rotation_id=$(echo "$rotation_elements" | grep -o '"ELEMENT":"[^"]*"' | head -1 | cut -d'"' -f4)
+            local tap_result=$(curl -s -X POST "http://localhost:${port}/session/$session/element/$rotation_id/click" 2>/dev/null)
+            
+            if echo "$tap_result" | grep -q '"sessionId"'; then
+                print_color "$GREEN" "✅ $device: Toggled rotation lock"
+            else
+                print_color "$YELLOW" "⚠️ $device: Rotation lock button found but tap may have failed"
+            fi
+        else
+            # Fallback: Try common coordinates for rotation lock button
+            print_color "$YELLOW" "$device: Using coordinate fallback for rotation lock..."
+            
+            # Common positions for rotation lock in Control Center
+            local coords=("60,300" "60,350" "80,320" "100,340")
+            
+            for coord in "${coords[@]}"; do
+                local x=$(echo "$coord" | cut -d',' -f1)
+                local y=$(echo "$coord" | cut -d',' -f2)
+                
+                local tap_result=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/tap/0" \
+                    -H "Content-Type: application/json" \
+                    -d "{\"x\": $x, \"y\": $y}" 2>/dev/null)
+                
+                if echo "$tap_result" | grep -q '"sessionId"'; then
+                    print_color "$YELLOW" "⚠️ $device: Attempted rotation lock toggle at ($x,$y)"
+                    break
+                fi
+            done
+        fi
+        
+        # Close Control Center by tapping outside or swiping down
+        sleep 1
+        local close_result=$(curl -s -X POST "http://localhost:${port}/session/$session/wda/tap/0" \
+            -H "Content-Type: application/json" \
+            -d '{"x": 200, "y": 600}' 2>/dev/null)
+        
+        # Alternative: Swipe down to close Control Center
+        if ! echo "$close_result" | grep -q '"sessionId"'; then
+            curl -s -X POST "http://localhost:${port}/session/$session/wda/dragfromtoforduration" \
+                -H "Content-Type: application/json" \
+                -d '{"fromX": 200, "fromY": 200, "toX": 200, "toY": 600, "duration": 0.3}' >/dev/null
+        fi
+        
+        return 0
+    else
+        print_color "$RED" "❌ $device: No WDA session available for rotation lock"
+        return 1
+    fi
+}
+
+# Auto-start WDA on USB device
+start_wda_usb() {
+    local device_name="$1"
+    local port="$2"
+    local udid="$3"
+    
+    print_color "$YELLOW" "   🔧 Auto-starting WDA for $device_name..."
+    
+    # Try multiple common WDA paths
+    local WDA_PATHS=(
+        "$HOME/Downloads/WebDriverAgent-10.2.1"
+        "$HOME/Downloads/WebDriverAgent"
+        "$HOME/WebDriverAgent"
+        "$(dirname "$0")/WebDriverAgent"
+        "/tmp/WebDriverAgent"
+    )
+    
+    local WDA_PATH=""
+    for path in "${WDA_PATHS[@]}"; do
+        if [ -d "$path" ] && [ -f "$path/WebDriverAgent.xcodeproj/project.pbxproj" ]; then
+            WDA_PATH="$path"
+            break
+        fi
+    done
+    
+    if [ -z "$WDA_PATH" ]; then
+        print_color "$RED" "   ❌ WebDriverAgent not found in common locations"
+        print_color "$YELLOW" "   📝 Searched:"
+        for path in "${WDA_PATHS[@]}"; do
+            echo "      - $path"
+        done
+        return 1
+    fi
+    
+    print_color "$CYAN" "   → Using WDA: $WDA_PATH"
+    
+    # Check if already building for this device
+    if pgrep -f "xcodebuild.*${udid}" >/dev/null 2>&1; then
+        print_color "$YELLOW" "   ⚠️  WDA build already in progress for this device"
+        print_color "$YELLOW" "   ⏳ Waiting for existing build..."
+    else
+        # Start WDA build in background
+        local wda_log="/tmp/wda_${device_name}_$$.log"
+        (
+            cd "$WDA_PATH" && \
+            xcodebuild -project WebDriverAgent.xcodeproj \
+                      -scheme WebDriverAgentRunner \
+                      -destination "platform=iOS,id=$udid" \
+                      test > "$wda_log" 2>&1
+        ) &
+        print_color "$CYAN" "   → WDA build started (log: $wda_log)"
+    fi
+    
+    # Wait for WDA to become available
+    print_color "$YELLOW" "   ⏳ Waiting for WDA to start (max 60s)..."
+    local waited=0
+    for i in {1..60}; do
+        if curl -s --connect-timeout 1 --max-time 2 "http://localhost:${port}/status" 2>/dev/null | grep -q '"state"'; then
+            print_color "$GREEN" "   ✅ WDA started successfully in ${i}s!"
+            return 0
+        fi
+        sleep 1
+        waited=$i
+        if [ $((i % 15)) -eq 0 ]; then
+            print_color "$YELLOW" "      Still waiting... (${i}s elapsed)"
+        fi
+    done
+    
+    print_color "$RED" "   ❌ WDA failed to start after ${waited}s"
+    print_color "$YELLOW" "   💡 Check log: tail -50 /tmp/wda_${device_name}_$$.log"
+    return 1
+}
+
+# Discover and connect USB devices
+discover_and_connect_devices() {
+    print_color "$BLUE" "🔍 Discovering USB iOS devices..."
+    echo ""
+    
+    local ALL_DEVICES=($(get_all_device_names))
+    
+    if [ ${#ALL_DEVICES[@]} -eq 0 ]; then
+        print_color "$RED" "❌ No USB iOS devices found"
+        print_color "$YELLOW" "   Make sure:"
+        print_color "$YELLOW" "   - Devices are connected via USB"
+        print_color "$YELLOW" "   - Devices are unlocked"
+        print_color "$YELLOW" "   - You trust this computer on the devices"
+        exit 1
+    fi
+    
+    print_color "$YELLOW" "Found USB devices:"
+    local port_offset=0
+    for device in "${ALL_DEVICES[@]}"; do
+        local port=$((WDA_PORT_BASE + port_offset))
+        print_color "$CYAN" "  • $device (port: $port)"
+        ((port_offset++))
+    done
+    echo ""
+    
+    print_color "$YELLOW" "Setting up USB connections..."
+    echo ""
+    
+    CONNECTED_DEVICES=()
+    local failed_devices=()
+    
+    # Start all iproxy processes in parallel first
+    print_color "$YELLOW" "   🔌 Starting iproxy for all devices..."
+    for device in "${ALL_DEVICES[@]}"; do
+        local details=$(get_device_details "$device")
+        local port=$(echo "$details" | cut -d',' -f1)
+        local udid=$(echo "$details" | cut -d',' -f2)
+        print_color "$CYAN" "      $device -> localhost:$port (UDID: ${udid:0:20}...)"
+        pkill -f "iproxy.*${port}:8100" 2>/dev/null
+        iproxy ${port} 8100 -u "$udid" >/dev/null 2>&1 &
+        local iproxy_pid=$!
+        echo "$device:$iproxy_pid" >> "$IPROXY_PIDS_FILE"
+    done
+    
+    # Give all iproxy instances time to start
+    sleep 1
+    
+    # Now test all devices in parallel
+    for device in "${ALL_DEVICES[@]}"; do
+        local details=$(get_device_details "$device")
+        local port=$(echo "$details" | cut -d',' -f1)
+        local udid=$(echo "$details" | cut -d',' -f2)
+        print_color "$CYAN" "📱 Setting up $device (USB port: $port):"
+        
+        # Test WDA connection
+        print_color "$YELLOW" "   🔍 Testing WDA connection..."
+        if curl -s --connect-timeout 2 --max-time 3 "http://localhost:${port}/status" 2>/dev/null | grep -q '"state"'; then
+            CONNECTED_DEVICES+=("$device")
+            print_color "$GREEN" "   ✅ $device ready (USB)"
+        else
+            print_color "$YELLOW" "   ⚠️  WDA not responding, attempting auto-start..."
+            
+            # Try to auto-start WDA
+            if start_wda_usb "$device" "$port" "$udid"; then
+                CONNECTED_DEVICES+=("$device")
+                print_color "$GREEN" "   ✅ $device ready (USB - WDA auto-started)"
+            else
+                failed_devices+=("$device")
+                print_color "$RED" "   ❌ $device - Failed to start WDA"
+                print_color "$YELLOW" "   💡 You may need to manually start WebDriverAgent on this device"
+            fi
+        fi
+        echo ""
+    done
+    
+    print_color "$YELLOW" "📋 Connection Summary:"
+    echo ""
+    
+    if [ ${#CONNECTED_DEVICES[@]} -gt 0 ]; then
+        print_color "$GREEN" "🎉 ${#CONNECTED_DEVICES[@]} device(s) ready via USB!"
+        print_color "$CYAN" "Connected: $(IFS=', '; echo "${CONNECTED_DEVICES[*]}")"
+        if [ ${#failed_devices[@]} -gt 0 ]; then
+            print_color "$YELLOW" "⚠️  Not ready: $(IFS=', '; echo "${failed_devices[*]}")"
+            print_color "$YELLOW" "   💡 Continuing with available devices..."
+        fi
+    else
+        print_color "$RED" "❌ No devices are ready"
+        print_color "$YELLOW" ""
+        print_color "$YELLOW" "🔧 Troubleshooting:"
+        print_color "$YELLOW" "   1. Make sure devices are unlocked"
+        print_color "$YELLOW" "   2. Trust this computer on your devices"
+        print_color "$YELLOW" "   3. Check WebDriverAgent is in one of these locations:"
+        print_color "$CYAN" "      • ~/Downloads/WebDriverAgent-10.2.1"
+        print_color "$CYAN" "      • ~/Downloads/WebDriverAgent"
+        print_color "$CYAN" "      • ~/WebDriverAgent"
+        print_color "$YELLOW" "   4. Check WDA logs: tail -50 /tmp/wda_*.log"
+        exit 1
+    fi
+    
+    echo ""
+}
+
+# Send command to multiple devices
+send_to_all_devices() {
+    local devices=("$@")
+    local pids=()
+    
+    print_color "$YELLOW" "🚀 Executing on ${#devices[@]} device(s)..."
+    echo ""
+    
+    for device in "${devices[@]}"; do
+        {
+            execute_wda_command "$device" "$TEXT"
+            echo "[${device}] Completed"
+        } &
+        pids+=($!)
+        print_color "$CYAN" "📱 Started: $device (PID: $!)"
+    done
+    
+    echo ""
+    print_color "$YELLOW" "⏳ Waiting for completion..."
+    
+    for pid in "${pids[@]}"; do
+        wait "$pid"
+    done
+    
+    echo ""
+    print_color "$GREEN" "✅ All devices completed!"
+}
+
+# Cleanup all sessions and terminate iproxy processes
+# Graceful cleanup function for USB
+graceful_cleanup() {
+    local preserve_trust="${1:-true}"
+    
+    if [ -f "$DEVICE_SESSIONS_FILE" ]; then
+        print_color "$YELLOW" "🧹 Gracefully closing sessions..."
+        
+        # Only close WebDriver sessions, don't terminate WDA processes
+        while IFS=':' read -r device session; do
+            if [ -n "$device" ] && [ -n "$session" ]; then
+                local device_details
+                device_details=$(get_device_details "$device")
+                local port=$(echo "$device_details" | cut -d',' -f1)
+                
+                # Just close the WebDriver session, keep WDA running
+                curl -s -X DELETE "http://localhost:${port}/session/$session" >/dev/null 2>&1 || true
+                echo "   ✅ Session closed: $device"
+            fi
+        done < "$DEVICE_SESSIONS_FILE" 2>/dev/null || true
+        
+        rm -f "$DEVICE_SESSIONS_FILE" 2>/dev/null || true
+    fi
+    
+    # Kill iproxy processes
+    print_color "$YELLOW" "🔌 Stopping USB port forwarding..."
+    if [ -f "$IPROXY_PIDS_FILE" ]; then
+        while IFS=':' read -r device pid; do
+            if [ -n "$pid" ]; then
+                kill -9 "$pid" 2>/dev/null || true
+                echo "   ✅ iproxy stopped: $device"
+            fi
+        done < "$IPROXY_PIDS_FILE"
+        rm -f "$IPROXY_PIDS_FILE"
+    fi
+    
+    # Clean up port mapping cache
+    rm -f "$DEVICE_PORT_MAP_FILE" 2>/dev/null || true
+    
+    if [ "$preserve_trust" = "true" ]; then
+        print_color "$GREEN" "✅ USB connections closed gracefully"
+        print_color "$CYAN" "💡 WebDriverAgent processes left running on devices to preserve trust"
+        print_color "$YELLOW" "   Note: Devices should remain trusted and ready for reconnection"
+    else
+        # Call the full cleanup if explicitly requested
+        cleanup_all_sessions_full
+    fi
+}
+
+# Full cleanup function (original behavior - may affect trust)
+cleanup_all_sessions_full() {
+    if [ -f "$DEVICE_SESSIONS_FILE" ]; then
+        print_color "$YELLOW" "🧹 Cleaning up sessions and stopping WDA on devices..."
+        
+        # Collect device UDIDs for WDA termination
+        local device_udids=()
+        
+        while IFS=':' read -r device session; do
+            if [ -n "$device" ] && [ -n "$session" ]; then
+                local device_details
+                device_details=$(get_device_details "$device")
+                local port=$(echo "$device_details" | cut -d',' -f1)
+                local udid=$(echo "$device_details" | cut -d',' -f2)
+                
+                # Close WebDriver session first
+                curl -s -X DELETE "http://localhost:${port}/session/$session" >/dev/null 2>&1 || true
+                echo "   ✅ Session closed: $device"
+                
+                # Collect UDID for WDA process termination
+                if [ -n "$udid" ]; then
+                    device_udids+=("$udid")
+                fi
+            fi
+        done < "$DEVICE_SESSIONS_FILE" 2>/dev/null || true
+        
+        rm -f "$DEVICE_SESSIONS_FILE" 2>/dev/null || true
+        
+        # Terminate WDA processes for the connected devices
+        print_color "$CYAN" "🛑 Terminating WDA processes on respective devices..."
+        
+        if [ ${#device_udids[@]} -gt 0 ]; then
+            for udid in "${device_udids[@]}"; do
+                # Kill WDA process for this specific device UDID
+                local killed_count=$(pkill -f "WebDriverAgentRunner.*$udid" 2>/dev/null; echo $?)
+                if [ $killed_count -eq 0 ]; then
+                    echo "   ✅ WDA terminated on device: ${udid:0:8}..."
+                else
+                    echo "   ℹ️  No WDA process found for: ${udid:0:8}..."
+                fi
+            done
+        else
+            # Fallback: stop all WDA processes if no specific devices found
+            print_color "$YELLOW" "   → No specific devices found, stopping all WDA processes..."
+            pkill -f "WebDriverAgentRunner" 2>/dev/null || true
+        fi
+        
+        # Also terminate any lingering WDA processes (in case other scripts left them)
+        print_color "$CYAN" "🧹 Cleaning up any remaining WDA processes..."
+        local remaining=$(pgrep -f "WebDriverAgentRunner" 2>/dev/null | wc -l)
+        if [ "$remaining" -gt 0 ]; then
+            pkill -TERM -f "WebDriverAgentRunner" 2>/dev/null || true
+            sleep 1
+            pkill -KILL -f "WebDriverAgentRunner" 2>/dev/null || true
+            echo "   ✅ Cleaned up $remaining remaining WDA processes"
+        else
+            echo "   ✅ No remaining WDA processes found"
+        fi
+        
+        print_color "$GREEN" "✅ All WDA sessions and processes terminated"
+        print_color "$CYAN" "💡 Ready for manual testing - completely clean environment"
+        print_color "$YELLOW" "   Note: You may need to re-establish wireless connections in Xcode"
+    fi
+}
+
+# Legacy cleanup function name (redirects to graceful cleanup)
+cleanup_all_sessions() {
+    graceful_cleanup true
+}
+
+# Signal cleanup function (preserves device trust on interruption)
+cleanup_on_signal() {
+    echo ""
+    print_color "$YELLOW" "⚠️  Script interrupted - cleaning up gracefully..."
+    graceful_cleanup true
+    exit 0
+}
+
+# Signal handlers for proper cleanup (only on interruption, not normal exit)
+trap cleanup_on_signal INT
+trap cleanup_on_signal TERM
+
+# Main execution
+if [ -n "$DEVICE_NAME_REQUEST" ]; then
+    # Single device mode
+    if ! get_device_details "$DEVICE_NAME_REQUEST" >/dev/null; then
+        print_color "$RED" "❌ Device '$DEVICE_NAME_REQUEST' not found"
+        exit 1
+    fi
+    
+    print_color "$BLUE" "🎯 Single device: $DEVICE_NAME_REQUEST"
+    echo ""
+    
+    # Setup USB device (iproxy + WDA)
+    if setup_single_usb_device "$DEVICE_NAME_REQUEST"; then
+        if [ -n "$TEXT" ]; then
+            # Single command mode - execute and exit
+            # Check if session already exists (e.g., from a launched app)
+            existing_session=$(get_device_session "$DEVICE_NAME_REQUEST")
+            session="$existing_session"
+            
+            if [ -z "$session" ]; then
+                # No existing session, create new SpringBoard session
+                session=$(create_persistent_session "$DEVICE_NAME_REQUEST")
+            else
+                echo "   ℹ️  Using existing session: $session"
+            fi
+            
+            if [ -n "$session" ]; then
+                execute_wda_command "$DEVICE_NAME_REQUEST" "$TEXT"
+            fi
+            # DON'T cleanup session - keep app running!
+            # cleanup_wda_session "$DEVICE_NAME_REQUEST"
+            exit 0
+        else
+            # Single device interactive mode
+            print_color "$YELLOW" "🔧 Initializing interactive session..."
+            session=$(create_persistent_session "$DEVICE_NAME_REQUEST")
+            if [ -n "$session" ]; then
+                print_color "$GREEN" "   ✅ Session ready: $DEVICE_NAME_REQUEST"
+            else
+                print_color "$RED" "   ❌ Session failed: $DEVICE_NAME_REQUEST"
+                exit 1
+            fi
+            
+            echo ""
+            load_text_history
+            
+            print_color "$CYAN" "🔄 Single-device Interactive Mode: $DEVICE_NAME_REQUEST"
+            print_color "$YELLOW" "   Commands: launch/kill/home/url/screenshot + text input"
+            print_color "$YELLOW" "   Type 'help' for commands • 'quit' to exit"
+            echo ""
+            
+            while true; do
+                # Enable readline for this input with custom history
+                set -o history
+                HISTFILE="$HISTORY_FILE"
+                HISTSIZE="$HISTORY_MAX"
+                HISTFILESIZE="$HISTORY_MAX"
+                
+                # Load history from file for this session
+                if [ -f "$HISTORY_FILE" ]; then
+                    history -r "$HISTORY_FILE"
+                fi
+                
+                read -e -p "$DEVICE_NAME_REQUEST > " INPUT_TEXT
+                
+                # Add any non-empty input to history (except quit commands)
+                if [ -n "$INPUT_TEXT" ] && [[ "$INPUT_TEXT" != "quit" ]] && [[ "$INPUT_TEXT" != "exit" ]] && [[ "$INPUT_TEXT" != "q" ]] && [[ "$INPUT_TEXT" != "help" ]]; then
+                    add_to_history "$INPUT_TEXT"
+                fi
+                
+                # Disable history again to avoid shell command pollution
+                set +o history
+                unset HISTFILE
+                
+                case "$INPUT_TEXT" in
+                    "quit"|"q"|"exit")
+                        print_color "$YELLOW" "👋 Goodbye!"
+                        cleanup_wda_session "$DEVICE_NAME_REQUEST"
+                        exit 0
+                        ;;
+                    "forcecleanup"|"killwda")
+                        print_color "$YELLOW" "🛑 Force cleaning up - this may affect device trust..."
+                        cleanup_all_sessions_full
+                        print_color "$YELLOW" "👋 Goodbye!"
+                        exit 0
+                        ;;
+                    "help"|"commands")
+                        print_color "$YELLOW" "📱 Available Commands:"
+                        echo ""
+                        print_color "$CYAN" "🚀 App Control:"
+                        print_color "$YELLOW" "  launch <app>    - Launch application"
+                        print_color "$YELLOW" "  open <app>      - Same as launch"
+                        print_color "$YELLOW" "  kill <app>      - Terminate application"
+                        print_color "$YELLOW" "  close <app>     - Same as kill"
+                        print_color "$YELLOW" "  install <path>  - Install IPA file (requires iOS tools)"
+                        print_color "$YELLOW" "  uninstall <id>  - Uninstall app by bundle ID (requires iOS tools)"
+                        print_color "$YELLOW" "  appinfo <id>    - Check app version/info by bundle ID"
+                        print_color "$YELLOW" "  version <id>    - Same as appinfo"
+                        print_color "$YELLOW" "  listapps [word] - List all apps or search by name/word"
+                        print_color "$YELLOW" "  apps [word]     - Same as listapps (search any installed app)"
+                        print_color "$YELLOW" "  debug           - Test device connection and tools"
+                        echo ""
+                        print_color "$CYAN" "🌐 Navigation:"
+                        print_color "$YELLOW" "  home            - Go to home screen"
+                        print_color "$YELLOW" "  back [context]  - Smart back navigation (button/swipe/context)"
+                        print_color "$YELLOW" "  goback          - Same as back"
+                        print_color "$YELLOW" "  url <url>       - Open URL in Safari"
+                        print_color "$YELLOW" "  screenshot      - Take screenshot"
+                        print_color "$YELLOW" "  click <element> - Click on element or coordinates"
+                        print_color "$YELLOW" "  longpress <el>  - Long press on element"
+                        print_color "$YELLOW" "  swipe <dir>     - Swipe up/down/left/right or custom coordinates"
+                        print_color "$YELLOW" "  scroll <dir>    - Same as swipe"
+                        echo ""
+                        print_color "$CYAN" "⚙️  Device Control:"
+                        print_color "$YELLOW" "  restart         - Restart device (wireless + USB supported)"
+                        print_color "$YELLOW" "  reboot          - Same as restart"
+                        print_color "$YELLOW" "  shutdown        - Shutdown device (USB only, wireless does restart)"
+                        print_color "$YELLOW" "  poweroff        - Same as shutdown"
+                        echo ""
+                        print_color "$CYAN" "🎨 Display & Appearance:"
+                        print_color "$YELLOW" "  darkmode        - Switch to dark mode"
+                        print_color "$YELLOW" "  lightmode       - Switch to light mode"
+                        print_color "$YELLOW" "  theme <mode>    - Set theme (dark/light/toggle)"
+                        print_color "$YELLOW" "  appearance      - Check current appearance mode"
+                        print_color "$CYAN" "                    Note: May open Settings for manual selection"
+                        echo ""
+                        print_color "$CYAN" "🔄 Screen Rotation:"
+                        print_color "$YELLOW" "  rotate          - Toggle orientation (portrait/landscape)"
+                        print_color "$YELLOW" "  rotate <orient> - Set orientation (portrait/landscape-left/landscape-right)"
+                        print_color "$YELLOW" "  rotationlock    - Toggle rotation lock (opens Control Center)"
+                        print_color "$YELLOW" "  lockrotation    - Toggle rotation lock (same as rotationlock)"
+                        print_color "$CYAN" "                    Note: May require manual interaction in Control Center"
+                        echo ""
+                        print_color "$CYAN" "📝 Text & Control:"
+                        print_color "$YELLOW" "  any text        - Send to active field"
+                        print_color "$YELLOW" "  click <x,y>     - Click at coordinates (e.g., click 100,200)"
+                        print_color "$YELLOW" "  click <text>    - Click on button/text element"
+                        print_color "$YELLOW" "  tap <x,y>       - Same as click"
+                        print_color "$YELLOW" "  longpress <x,y> - Long press at coordinates (1.5s default)"
+                        print_color "$YELLOW" "  longpress <text>- Long press on text element"
+                        print_color "$YELLOW" "  longclick <x,y> - Same as longpress"
+                        print_color "$YELLOW" "  getLocators     - Get all UI element locators from current screen"
+                        print_color "$YELLOW" "  -d device cmd   - Run command on specific device only"
+                        print_color "$YELLOW" "  help            - Show this help"
+                        print_color "$YELLOW" "  quit            - Exit and cleanup (preserves device trust)"
+                        print_color "$YELLOW" "  forcecleanup    - Force kill WDA processes (may affect trust)"
+                        echo ""
+                        print_color "$CYAN" "💡 Examples:"
+                        print_color "$YELLOW" "  launch safari"
+                        print_color "$YELLOW" "  url google.com"
+                        print_color "$YELLOW" "  click 200,300"
+                        print_color "$YELLOW" "  click 'Sign In'"
+                        print_color "$YELLOW" "  longpress 'Settings'"
+                        print_color "$YELLOW" "  longpress 100,150,2.0"
+                        print_color "$YELLOW" "  getLocators"
+                        print_color "$YELLOW" "  -d iPhone17 getLocators  # Get locators only from iPhone17"
+                        print_color "$YELLOW" "  darkmode"
+                        print_color "$YELLOW" "  rotate landscape-left"
+                        print_color "$YELLOW" "  rotationlock"
+                        print_color "$YELLOW" "  restart"
+                        print_color "$YELLOW" "  shutdown"
+                        print_color "$YELLOW" "  install /path/to/app.ipa"
+                        print_color "$YELLOW" "  uninstall com.example.app"
+                        print_color "$YELLOW" "  appinfo com.example.app"
+                        print_color "$YELLOW" "  listapps mobileiron"
+                        print_color "$YELLOW" "  Hello World"
+                        print_color "$YELLOW" "  kill safari"
+                        continue
+                        ;;
+                    "")
+                        continue
+                        ;;
+                    *)
+                        execute_wda_command "$DEVICE_NAME_REQUEST" "$INPUT_TEXT"
+                        echo ""
+                        ;;
+                esac
+            done
+        fi
+    else
+        # Setup failed
+        print_color "$RED" "❌ Failed to connect to device: $DEVICE_NAME_REQUEST"
+        print_color "$YELLOW" ""
+        print_color "$YELLOW" "💡 Troubleshooting:"
+        print_color "$YELLOW" "   1. Make sure device is unlocked"
+        print_color "$YELLOW" "   2. Trust this computer on your device"
+        print_color "$YELLOW" "   3. Check WebDriverAgent is installed"
+        print_color "$YELLOW" "   4. Try: idevice_id -l  (to verify USB connection)"
+        exit 1
+    fi
+    exit 0
+fi
+
+# Multi-device mode
+discover_and_connect_devices
+
+if [ -z "$TEXT" ]; then
+    # Interactive mode - create persistent sessions for all devices in parallel
+    print_color "$YELLOW" "🔧 Initializing persistent sessions..."
+    
+    session_pids=()
+    for device in "${CONNECTED_DEVICES[@]}"; do
+        {
+            session=$(create_persistent_session "$device")
+            if [ -n "$session" ]; then
+                print_color "$GREEN" "   ✅ Session ready: $device"
+            else
+                print_color "$RED" "   ❌ Session failed: $device"
+            fi
+        } &
+        session_pids+=($!)
+    done
+    
+    # Wait for all session creations to complete
+    for pid in "${session_pids[@]}"; do
+        wait "$pid"
+    done
+    
+    echo ""
+    # Load history at startup
+    load_text_history
+    
+    # Initialize device selection (start with all devices selected)
+    SELECTED_DEVICES=("${CONNECTED_DEVICES[@]}")
+    
+    print_color "$CYAN" "🔄 Multi-device Interactive Mode"
+    print_color "$YELLOW" "   Commands: launch/kill/home/url/screenshot + text input"
+    print_color "$YELLOW" "   Type 'help' for commands • 'select' for device targeting • 'quit' to exit"
+    print_color "$CYAN" "   Available: $(IFS=', '; echo "${CONNECTED_DEVICES[*]}")"
+    print_color "$GREEN" "   Active: $(IFS=', '; echo "${SELECTED_DEVICES[*]}")"
+    echo ""
+    
+    while true; do
+        # Enable readline for this input with custom history
+        set -o history
+        HISTFILE="$HISTORY_FILE"
+        HISTSIZE="$HISTORY_MAX"
+        HISTFILESIZE="$HISTORY_MAX"
+        
+        # Load history from file for this session
+        if [ -f "$HISTORY_FILE" ]; then
+            history -r "$HISTORY_FILE"
+        fi
+        
+        read -e -p "Multi-device [${#SELECTED_DEVICES[@]}/${#CONNECTED_DEVICES[@]}] > " INPUT_TEXT
+        
+        # Add any non-empty input to history (except quit commands)
+        if [ -n "$INPUT_TEXT" ] && [[ "$INPUT_TEXT" != "quit" ]] && [[ "$INPUT_TEXT" != "exit" ]] && [[ "$INPUT_TEXT" != "q" ]] && [[ "$INPUT_TEXT" != "help" ]]; then
+            add_to_history "$INPUT_TEXT"
+        fi
+        
+        # Disable history again to avoid shell command pollution
+        set +o history
+        unset HISTFILE
+        
+        case "$INPUT_TEXT" in
+            "quit"|"q"|"exit")
+                print_color "$YELLOW" "👋 Goodbye!"
+                cleanup_all_sessions
+                exit 0
+                ;;
+            "forcecleanup"|"killwda")
+                print_color "$YELLOW" "🛑 Force cleaning up - this may affect device trust..."
+                cleanup_all_sessions_full
+                print_color "$YELLOW" "👋 Goodbye!"
+                exit 0
+                ;;
+            "help"|"commands")
+                print_color "$YELLOW" "📱 Available Commands:"
+                echo ""
+                print_color "$CYAN" "🚀 App Control:"
+                print_color "$YELLOW" "  launch <app>    - Launch application"
+                print_color "$YELLOW" "  open <app>      - Same as launch"
+                print_color "$YELLOW" "  kill <app>      - Terminate application"
+                print_color "$YELLOW" "  close <app>     - Same as kill"
+                print_color "$YELLOW" "  install <path>  - Install IPA file (requires iOS tools)"
+                print_color "$YELLOW" "  uninstall <id>  - Uninstall app by bundle ID (requires iOS tools)"
+                print_color "$YELLOW" "  appinfo <id>    - Check app version/info by bundle ID"
+                print_color "$YELLOW" "  version <id>    - Same as appinfo"
+                print_color "$YELLOW" "  listapps [word] - List all apps or search by name/word"
+                print_color "$YELLOW" "  apps [word]     - Same as listapps (search any installed app)"
+                print_color "$YELLOW" "  debug           - Test device connection and tools"
+                echo ""
+                print_color "$CYAN" "🌐 Navigation:"
+                print_color "$YELLOW" "  home            - Go to home screen"
+                print_color "$YELLOW" "  back [context]  - Smart back navigation (button/swipe/context)"
+                print_color "$YELLOW" "  goback          - Same as back"
+                print_color "$YELLOW" "  url <url>       - Open URL in Safari"
+                print_color "$YELLOW" "  screenshot      - Take screenshot"
+                print_color "$YELLOW" "  click <element> - Click on element or coordinates"
+                print_color "$YELLOW" "  longpress <el>  - Long press on element"
+                print_color "$YELLOW" "  swipe <dir>     - Swipe up/down/left/right or custom coordinates"
+                print_color "$YELLOW" "  scroll <dir>    - Same as swipe"
+                echo ""
+                print_color "$CYAN" "⚙️  Device Control:"
+                print_color "$YELLOW" "  restart         - Restart device (wireless + USB supported)"
+                print_color "$YELLOW" "  reboot          - Same as restart"
+                print_color "$YELLOW" "  shutdown        - Shutdown device (USB only, wireless does restart)"
+                print_color "$YELLOW" "  poweroff        - Same as shutdown"
+                echo ""
+                print_color "$CYAN" "🎨 Display & Appearance:"
+                print_color "$YELLOW" "  darkmode        - Switch to dark mode"
+                print_color "$YELLOW" "  lightmode       - Switch to light mode"
+                print_color "$YELLOW" "  theme <mode>    - Set theme (dark/light/toggle)"
+                print_color "$YELLOW" "  appearance      - Check current appearance mode"
+                print_color "$CYAN" "                    Note: May open Settings for manual selection"
+                echo ""
+                print_color "$CYAN" "🔄 Screen Rotation:"
+                print_color "$YELLOW" "  rotate          - Toggle orientation (portrait/landscape)"
+                print_color "$YELLOW" "  rotate <orient> - Set orientation (portrait/landscape-left/landscape-right)"
+                print_color "$YELLOW" "  rotationlock    - Toggle rotation lock (opens Control Center)"
+                print_color "$YELLOW" "  lockrotation    - Toggle rotation lock (same as rotationlock)"
+                print_color "$CYAN" "                    Note: May require manual interaction in Control Center"
+                echo ""
+                print_color "$CYAN" "📝 Text & Control:"
+                print_color "$YELLOW" "  any text        - Send to active field"
+                print_color "$YELLOW" "  click <x,y>     - Click at coordinates (e.g., click 100,200)"
+                print_color "$YELLOW" "  click <text>    - Click on button/text element"
+                print_color "$YELLOW" "  tap <x,y>       - Same as click"
+                print_color "$YELLOW" "  longpress <x,y> - Long press at coordinates (1.5s default)"
+                print_color "$YELLOW" "  longpress <text>- Long press on text element"
+                print_color "$YELLOW" "  longclick <x,y> - Same as longpress"
+                print_color "$YELLOW" "  help            - Show this help"
+                print_color "$YELLOW" "  quit            - Exit and cleanup (preserves device trust)"
+                print_color "$YELLOW" "  forcecleanup    - Force kill WDA processes (may affect trust)"
+                echo ""
+                print_color "$CYAN" "🎯 Device Targeting:"
+                print_color "$YELLOW" "  select          - Choose which devices to target"
+                print_color "$YELLOW" "  status          - Show connected devices"
+                echo ""
+                print_color "$CYAN" "💡 Examples:"
+                print_color "$YELLOW" "  launch safari"
+                print_color "$YELLOW" "  url google.com"
+                print_color "$YELLOW" "  click 200,300"
+                print_color "$YELLOW" "  click 'Sign In'"
+                print_color "$YELLOW" "  longpress 'Settings'"
+                print_color "$YELLOW" "  longpress 100,150,2.0"
+                print_color "$YELLOW" "  darkmode"
+                print_color "$YELLOW" "  rotate landscape-left"
+                print_color "$YELLOW" "  rotationlock"
+                print_color "$YELLOW" "  restart"
+                print_color "$YELLOW" "  shutdown"
+                print_color "$YELLOW" "  install /path/to/app.ipa"
+                print_color "$YELLOW" "  uninstall com.example.app"
+                print_color "$YELLOW" "  appinfo com.example.app"
+                print_color "$YELLOW" "  listapps mobileiron"
+                print_color "$YELLOW" "  Hello World"
+                print_color "$YELLOW" "  kill safari"
+                continue
+                ;;
+            "status"|"devices")
+                print_color "$CYAN" "📱 Connected: $(IFS=', '; echo "${CONNECTED_DEVICES[*]}")"
+                continue
+                ;;
+            "")
+                continue
+                ;;
+            "select"|"devices"|"target")
+                print_color "$CYAN" "📱 Device Selection Menu:"
+                echo ""
+                print_color "$YELLOW" "Available devices:"
+                for i in "${!CONNECTED_DEVICES[@]}"; do
+                    local device="${CONNECTED_DEVICES[$i]}"
+                    local is_selected=""
+                    if [[ " ${SELECTED_DEVICES[*]} " == *" $device "* ]]; then
+                        is_selected="✅"
+                    else
+                        is_selected="⬜"
+                    fi
+                    echo "  $((i+1)). $is_selected $device"
+                done
+                echo ""
+                print_color "$CYAN" "Commands:"
+                print_color "$YELLOW" "  all           - Select all devices"
+                print_color "$YELLOW" "  none          - Deselect all devices"
+                print_color "$YELLOW" "  1,2,3         - Select devices by numbers"
+                print_color "$YELLOW" "  +1,2          - Add devices to selection"
+                print_color "$YELLOW" "  -1,2          - Remove devices from selection"
+                print_color "$YELLOW" "  toggle 1,2    - Toggle device selection"
+                print_color "$YELLOW" "  list          - Show current selection"
+                print_color "$YELLOW" "  done          - Finish selection"
+                echo ""
+                
+                while true; do
+                    read -e -p "Device Selection > " DEVICE_CMD
+                    
+                    case "$DEVICE_CMD" in
+                        "done"|"exit"|"")
+                            break
+                            ;;
+                        "all")
+                            SELECTED_DEVICES=("${CONNECTED_DEVICES[@]}")
+                            print_color "$GREEN" "✅ All devices selected: $(IFS=', '; echo "${SELECTED_DEVICES[*]}")"
+                            ;;
+                        "none"|"clear")
+                            SELECTED_DEVICES=()
+                            print_color "$YELLOW" "🔄 All devices deselected"
+                            ;;
+                        "list"|"show")
+                            if [ ${#SELECTED_DEVICES[@]} -eq 0 ]; then
+                                print_color "$RED" "❌ No devices selected"
+                            else
+                                print_color "$GREEN" "✅ Selected: $(IFS=', '; echo "${SELECTED_DEVICES[*]}")"
+                            fi
+                            ;;
+                        +*)
+                            # Add devices
+                            local add_nums="${DEVICE_CMD:1}"
+                            IFS=',' read -ra NUMS <<< "$add_nums"
+                            for num in "${NUMS[@]}"; do
+                                num=$(echo "$num" | xargs) # trim whitespace
+                                if [[ "$num" =~ ^[0-9]+$ ]] && [ "$num" -ge 1 ] && [ "$num" -le ${#CONNECTED_DEVICES[@]} ]; then
+                                    local device="${CONNECTED_DEVICES[$((num-1))]}"
+                                    if [[ ! " ${SELECTED_DEVICES[*]} " == *" $device "* ]]; then
+                                        SELECTED_DEVICES+=("$device")
+                                        print_color "$GREEN" "✅ Added: $device"
+                                    fi
+                                fi
+                            done
+                            ;;
+                        -*)
+                            # Remove devices
+                            local remove_nums="${DEVICE_CMD:1}"
+                            IFS=',' read -ra NUMS <<< "$remove_nums"
+                            for num in "${NUMS[@]}"; do
+                                num=$(echo "$num" | xargs)
+                                if [[ "$num" =~ ^[0-9]+$ ]] && [ "$num" -ge 1 ] && [ "$num" -le ${#CONNECTED_DEVICES[@]} ]; then
+                                    local device="${CONNECTED_DEVICES[$((num-1))]}"
+                                    local new_selected=()
+                                    for selected in "${SELECTED_DEVICES[@]}"; do
+                                        if [ "$selected" != "$device" ]; then
+                                            new_selected+=("$selected")
+                                        fi
+                                    done
+                                    SELECTED_DEVICES=("${new_selected[@]}")
+                                    print_color "$YELLOW" "➖ Removed: $device"
+                                fi
+                            done
+                            ;;
+                        toggle*)
+                            # Toggle devices
+                            local toggle_nums="${DEVICE_CMD#toggle }"
+                            IFS=',' read -ra NUMS <<< "$toggle_nums"
+                            for num in "${NUMS[@]}"; do
+                                num=$(echo "$num" | xargs)
+                                if [[ "$num" =~ ^[0-9]+$ ]] && [ "$num" -ge 1 ] && [ "$num" -le ${#CONNECTED_DEVICES[@]} ]; then
+                                    local device="${CONNECTED_DEVICES[$((num-1))]}"
+                                    if [[ " ${SELECTED_DEVICES[*]} " == *" $device "* ]]; then
+                                        # Remove from selection
+                                        local new_selected=()
+                                        for selected in "${SELECTED_DEVICES[@]}"; do
+                                            if [ "$selected" != "$device" ]; then
+                                                new_selected+=("$selected")
+                                            fi
+                                        done
+                                        SELECTED_DEVICES=("${new_selected[@]}")
+                                        print_color "$YELLOW" "⬜ Deselected: $device"
+                                    else
+                                        # Add to selection
+                                        SELECTED_DEVICES+=("$device")
+                                        print_color "$GREEN" "✅ Selected: $device"
+                                    fi
+                                fi
+                            done
+                            ;;
+                        *)
+                            # Direct number selection (replace existing selection)
+                            if [[ "$DEVICE_CMD" =~ ^[0-9,[:space:]]+$ ]]; then
+                                SELECTED_DEVICES=()
+                                IFS=',' read -ra NUMS <<< "$DEVICE_CMD"
+                                for num in "${NUMS[@]}"; do
+                                    num=$(echo "$num" | xargs)
+                                    if [[ "$num" =~ ^[0-9]+$ ]] && [ "$num" -ge 1 ] && [ "$num" -le ${#CONNECTED_DEVICES[@]} ]; then
+                                        local device="${CONNECTED_DEVICES[$((num-1))]}"
+                                        if [[ ! " ${SELECTED_DEVICES[*]} " == *" $device "* ]]; then
+                                            SELECTED_DEVICES+=("$device")
+                                        fi
+                                    fi
+                                done
+                                if [ ${#SELECTED_DEVICES[@]} -gt 0 ]; then
+                                    print_color "$GREEN" "✅ Selected: $(IFS=', '; echo "${SELECTED_DEVICES[*]}")"
+                                else
+                                    print_color "$RED" "❌ No valid device numbers provided"
+                                fi
+                            else
+                                print_color "$RED" "❌ Unknown command: $DEVICE_CMD"
+                            fi
+                            ;;
+                    esac
+                done
+                
+                # Update the prompt to show selected devices
+                if [ ${#SELECTED_DEVICES[@]} -eq 0 ]; then
+                    SELECTED_DEVICES=("${CONNECTED_DEVICES[@]}")
+                    print_color "$YELLOW" "⚠️  No devices selected, using all devices"
+                fi
+                
+                print_color "$CYAN" "🎯 Active devices: $(IFS=', '; echo "${SELECTED_DEVICES[*]}")"
+                continue
+                ;;
+            *)
+                # Check if this is a runtime device selection: -d devicename command
+                if [[ "$INPUT_TEXT" =~ ^-d[[:space:]]+([^[:space:]]+)[[:space:]]+(.+)$ ]]; then
+                    runtime_device="${BASH_REMATCH[1]}"
+                    runtime_command="${BASH_REMATCH[2]}"
+                    
+                    # Validate device exists in connected devices
+                    device_found=false
+                    for device in "${CONNECTED_DEVICES[@]}"; do
+                        if [ "$device" = "$runtime_device" ]; then
+                            device_found=true
+                            break
+                        fi
+                    done
+                    
+                    if [ "$device_found" = true ]; then
+                        print_color "$YELLOW" "🎯 Executing on single device: $runtime_device"
+                        print_color "$CYAN" "   Command: $runtime_command"
+                        echo ""
+                        
+                        execute_wda_command "$runtime_device" "$runtime_command"
+                        echo ""
+                        print_color "$GREEN" "✅ Completed on $runtime_device"
+                    else
+                        print_color "$RED" "❌ Device '$runtime_device' not found in connected devices"
+                        print_color "$YELLOW" "   Available devices: $(IFS=', '; echo "${CONNECTED_DEVICES[*]}")"
+                    fi
+                    echo ""
+                    continue
+                fi
+                
+                # Check if this is a command (starts with known command keywords)
+                first_word="${INPUT_TEXT%% *}"  # More reliable word extraction
+                # echo "DEBUG: Input text: '$INPUT_TEXT'"
+                # echo "DEBUG: First word: '$first_word'"
+                
+                case "$first_word" in
+                    "launch"|"open"|"kill"|"close"|"home"|"url"|"screenshot"|"restart"|"reboot"|"shutdown"|"poweroff"|"darkmode"|"lightmode"|"theme"|"appearance"|"rotate"|"rotationlock"|"lockrotation"|"install"|"uninstall"|"appinfo"|"version"|"listapps"|"apps"|"debug"|"click"|"tap"|"longpress"|"longclick"|"back"|"goback"|"swipe"|"scroll"|"getLocators"|"getlocators"|"locators")
+                        # This is a command - send to execute_wda_command for each device
+                        # echo "DEBUG: Command detected!"
+                        print_color "$YELLOW" "🚀 Executing command on ${#SELECTED_DEVICES[@]} device(s): $INPUT_TEXT"
+                        echo ""
+                        
+                        pids=()
+                        for device in "${SELECTED_DEVICES[@]}"; do
+                            {
+                                execute_wda_command "$device" "$INPUT_TEXT"
+                                echo "[${device}] Completed"
+                            } &
+                            pids+=($!)
+                            print_color "$CYAN" "📱 Started: $device (PID: $!)"
+                        done
+                        
+                        echo ""
+                        print_color "$YELLOW" "⏳ Waiting for completion..."
+                        
+                        for pid in "${pids[@]}"; do
+                            wait "$pid"
+                        done
+                        
+                        echo ""
+                        print_color "$GREEN" "✅ All devices completed!"
+                        ;;
+                    *)
+                        # This is regular text - send as text input
+                        # echo "DEBUG: Treating as text input"
+                        TEXT="$INPUT_TEXT"
+                        # Use selected devices instead of all devices
+                        if [ ${#SELECTED_DEVICES[@]} -eq 0 ]; then
+                            send_to_all_devices "${CONNECTED_DEVICES[@]}"
+                        else
+                            send_to_all_devices "${SELECTED_DEVICES[@]}"
+                        fi
+                        TEXT=""
+                        ;;
+                esac
+                echo ""
+                ;;
+        esac
+    done
+else
+    # Single command mode - create temporary sessions
+    print_color "$YELLOW" "🎯 Command: $TEXT"
+    print_color "$CYAN" "   Targets: $(IFS=', '; echo "${CONNECTED_DEVICES[*]}")"
+    echo ""
+    
+    # Create sessions for all devices
+    for device in "${CONNECTED_DEVICES[@]}"; do
+        create_persistent_session "$device" >/dev/null
+    done
+    
+    send_to_all_devices "${CONNECTED_DEVICES[@]}"
+fi
+# Cleanup on normal exit
+graceful_cleanup true