devicely 2.2.13 → 2.2.14

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

@@ -1,342 +0,0 @@
-const Logger = require('./logger');
-const { execSync } = require('child_process');
-
-class LocatorStrategy {
-  constructor() {
-    this.logger = new Logger('LocatorStrategy');
-  }
-
-  /**
-   * Capture element information at given coordinates
-   * Returns all possible locators for the element
-   */
-  async captureElementLocators(device, x, y) {
-    const locators = {
-      coordinates: { x, y },
-      timestamp: Date.now()
-    };
-
-    try {
-      if (device.platform === 'Android') {
-        return await this.captureAndroidElement(device, x, y);
-      } else if (device.platform === 'iOS') {
-        return await this.captureIOSElement(device, x, y);
-      }
-    } catch (error) {
-      this.logger.error(`Failed to capture element locators: ${error.message}`);
-      return locators;
-    }
-
-    return locators;
-  }
-
-  /**
-   * Capture Android element using UIAutomator2
-   */
-  async captureAndroidElement(device, x, y) {
-    try {
-      // Use UIAutomator2 to get element at coordinates
-      // This requires active UIAutomator2 session
-      const dumpCommand = `adb -s ${device.udid || device.name} shell uiautomator dump /sdcard/window_dump.xml && adb -s ${device.udid || device.name} shell cat /sdcard/window_dump.xml`;
-      
-      const xmlDump = execSync(dumpCommand, { 
-        encoding: 'utf8',
-        timeout: 10000 
-      });
-
-      const element = this.findElementAtCoordinates(xmlDump, x, y);
-      
-      if (element) {
-        return {
-          xpath: this.buildXPath(element),
-          resourceId: element.resourceId || null,
-          contentDesc: element.contentDesc || null,
-          text: element.text || null,
-          className: element.className || null,
-          index: element.index || 0,
-          bounds: element.bounds || null,
-          coordinates: { x, y },
-          platform: 'Android'
-        };
-      }
-    } catch (error) {
-      this.logger.warn(`Android element capture failed: ${error.message}`);
-    }
-
-    return { coordinates: { x, y }, platform: 'Android' };
-  }
-
-  /**
-   * Capture iOS element using WDA
-   */
-  async captureIOSElement(device, x, y) {
-    try {
-      // Use WDA to get element at coordinates
-      // Requires active WDA session
-      const sessionPort = device.wdaPort || 8100;
-      const axios = require('axios');
-      
-      const response = await axios.get(`http://localhost:${sessionPort}/source`, {
-        params: { format: 'json' },
-        timeout: 5000
-      });
-
-      const pageSource = response.data;
-      const element = this.findIOSElementAtCoordinates(pageSource, x, y);
-
-      if (element) {
-        return {
-          xpath: this.buildIOSXPath(element),
-          accessibilityId: element.name || element.label || null,
-          accessibilityLabel: element.label || null,
-          text: element.value || element.label || null,
-          type: element.type || null,
-          index: element.index || 0,
-          bounds: element.rect || null,
-          coordinates: { x, y },
-          platform: 'iOS'
-        };
-      }
-    } catch (error) {
-      this.logger.warn(`iOS element capture failed: ${error.message}`);
-    }
-
-    return { coordinates: { x, y }, platform: 'iOS' };
-  }
-
-  /**
-   * Find element at coordinates from XML dump
-   */
-  findElementAtCoordinates(xmlDump, x, y) {
-    // Parse XML and find element whose bounds contain (x, y)
-    // This is a simplified implementation
-    const boundsRegex = /bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/g;
-    const resourceIdRegex = /resource-id="([^"]*)"/;
-    const textRegex = /text="([^"]*)"/;
-    const contentDescRegex = /content-desc="([^"]*)"/;
-    const classRegex = /class="([^"]*)"/;
-
-    const lines = xmlDump.split('\n');
-    
-    for (const line of lines) {
-      const boundsMatch = boundsRegex.exec(line);
-      if (boundsMatch) {
-        const [, left, top, right, bottom] = boundsMatch.map(Number);
-        
-        if (x >= left && x <= right && y >= top && y <= bottom) {
-          return {
-            resourceId: (resourceIdRegex.exec(line) || [])[1] || null,
-            text: (textRegex.exec(line) || [])[1] || null,
-            contentDesc: (contentDescRegex.exec(line) || [])[1] || null,
-            className: (classRegex.exec(line) || [])[1] || null,
-            bounds: { left, top, right, bottom }
-          };
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Find iOS element at coordinates from page source
-   */
-  findIOSElementAtCoordinates(pageSource, x, y) {
-    // Recursively search through WDA page source tree
-    const findElement = (node) => {
-      if (node.rect) {
-        const { x: ex, y: ey, width, height } = node.rect;
-        if (x >= ex && x <= (ex + width) && y >= ey && y <= (ey + height)) {
-          return node;
-        }
-      }
-      
-      if (node.children) {
-        for (const child of node.children) {
-          const found = findElement(child);
-          if (found) return found;
-        }
-      }
-      
-      return null;
-    };
-
-    return findElement(pageSource);
-  }
-
-  /**
-   * Build XPath for Android element
-   */
-  buildXPath(element) {
-    const parts = [];
-    
-    if (element.resourceId) {
-      return `//*[@resource-id="${element.resourceId}"]`;
-    }
-    
-    if (element.contentDesc) {
-      return `//*[@content-desc="${element.contentDesc}"]`;
-    }
-    
-    if (element.text) {
-      return `//${element.className || '*'}[@text="${element.text}"]`;
-    }
-    
-    if (element.className) {
-      return `//${element.className}`;
-    }
-    
-    return `//*`;
-  }
-
-  /**
-   * Build XPath for iOS element
-   */
-  buildIOSXPath(element) {
-    if (element.name) {
-      return `//*[@name="${element.name}"]`;
-    }
-    
-    if (element.label) {
-      return `//${element.type || '*'}[@label="${element.label}"]`;
-    }
-    
-    if (element.type) {
-      return `//${element.type}`;
-    }
-    
-    return `//*`;
-  }
-
-  /**
-   * Execute action using specific locator strategy
-   */
-  async executeWithLocator(device, action, locator, input = null) {
-    if (device.platform === 'Android') {
-      return await this.executeAndroidAction(device, action, locator, input);
-    } else if (device.platform === 'iOS') {
-      return await this.executeIOSAction(device, action, locator, input);
-    }
-    
-    throw new Error(`Unsupported platform: ${device.platform}`);
-  }
-
-  /**
-   * Execute action on Android device
-   */
-  async executeAndroidAction(device, action, locator, input) {
-    const deviceId = device.udid || device.name;
-    
-    try {
-      switch (action) {
-        case 'tap':
-          return await this.androidTap(deviceId, locator);
-        case 'swipe':
-          return await this.androidSwipe(deviceId, locator);
-        case 'type':
-          return await this.androidType(deviceId, locator, input);
-        case 'clear':
-          return await this.androidClear(deviceId, locator);
-        default:
-          throw new Error(`Unsupported action: ${action}`);
-      }
-    } catch (error) {
-      this.logger.error(`Android action failed: ${error.message}`);
-      throw error;
-    }
-  }
-
-  /**
-   * Execute action on iOS device
-   */
-  async executeIOSAction(device, action, locator, input) {
-    const sessionPort = device.wdaPort || 8100;
-    
-    try {
-      switch (action) {
-        case 'tap':
-          return await this.iOSTap(sessionPort, locator);
-        case 'swipe':
-          return await this.iOSSwipe(sessionPort, locator);
-        case 'type':
-          return await this.iOSType(sessionPort, locator, input);
-        case 'clear':
-          return await this.iOSClear(sessionPort, locator);
-        default:
-          throw new Error(`Unsupported action: ${action}`);
-      }
-    } catch (error) {
-      this.logger.error(`iOS action failed: ${error.message}`);
-      throw error;
-    }
-  }
-
-  // Android action implementations
-  async androidTap(deviceId, locator) {
-    if (locator.type === 'coordinates') {
-      const { x, y } = locator.value;
-      execSync(`adb -s ${deviceId} shell input tap ${x} ${y}`);
-    } else if (locator.type === 'resource_id') {
-      // Use UIAutomator2 to find and tap element
-      execSync(`adb -s ${deviceId} shell input tap $(uiautomator dump | grep "${locator.value}")`);
-    }
-    return { success: true };
-  }
-
-  async androidSwipe(deviceId, locator) {
-    const { x1, y1, x2, y2, duration = 300 } = locator.value;
-    execSync(`adb -s ${deviceId} shell input swipe ${x1} ${y1} ${x2} ${y2} ${duration}`);
-    return { success: true };
-  }
-
-  async androidType(deviceId, locator, text) {
-    // First tap on element, then input text
-    await this.androidTap(deviceId, locator);
-    const escapedText = text.replace(/\s/g, '%s');
-    execSync(`adb -s ${deviceId} shell input text "${escapedText}"`);
-    return { success: true };
-  }
-
-  async androidClear(deviceId, locator) {
-    // Select all and delete
-    await this.androidTap(deviceId, locator);
-    execSync(`adb -s ${deviceId} shell input keyevent KEYCODE_MOVE_END`);
-    execSync(`adb -s ${deviceId} shell input keyevent --longpress KEYCODE_DEL`);
-    return { success: true };
-  }
-
-  // iOS action implementations (using WDA HTTP API)
-  async iOSTap(sessionPort, locator) {
-    const axios = require('axios');
-    if (locator.type === 'coordinates') {
-      const { x, y } = locator.value;
-      await axios.post(`http://localhost:${sessionPort}/wda/tap/0`, { x, y });
-    }
-    return { success: true };
-  }
-
-  async iOSSwipe(sessionPort, locator) {
-    const axios = require('axios');
-    const { x1, y1, x2, y2 } = locator.value;
-    await axios.post(`http://localhost:${sessionPort}/wda/dragfromtoforduration`, {
-      fromX: x1, fromY: y1, toX: x2, toY: y2, duration: 0.3
-    });
-    return { success: true };
-  }
-
-  async iOSType(sessionPort, locator, text) {
-    const axios = require('axios');
-    await this.iOSTap(sessionPort, locator);
-    await axios.post(`http://localhost:${sessionPort}/wda/keys`, { value: [text] });
-    return { success: true };
-  }
-
-  async iOSClear(sessionPort, locator) {
-    const axios = require('axios');
-    await this.iOSTap(sessionPort, locator);
-    await axios.post(`http://localhost:${sessionPort}/wda/keys`, { value: [''] });
-    return { success: true };
-  }
-}
-
-module.exports = LocatorStrategy;

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

@@ -1,13 +0,0 @@
-const fs = require('fs');
-const { decrypt } = require('./encryption');
-
-/**
- * Decrypt encrypted shell script
- * Uses centralized encryption config for consistency
- */
-function decryptScript(encryptedFilePath) {
-  const encryptedData = fs.readFileSync(encryptedFilePath, 'utf8');
-  return decrypt(encryptedData);
-}
-
-module.exports = { decryptScript };