appium-mcp 1.8.10 → 1.8.12

package/src/devicemanager/ios-manager.ts

@@ -1,145 +0,0 @@
-import { Simctl } from 'node-simctl';
-import { utilities } from 'appium-ios-device';
-import log from '../logger.js';
-
-export interface IOSDevice {
-  name: string;
-  udid: string;
-  state?: string;
-  type: 'simulator' | 'real';
-  platform?: string;
-}
-
-/**
- * iOS Device Manager to list and manage iOS devices and simulators
- */
-export class IOSManager {
-  private static instance: IOSManager;
-  private simctl: Simctl;
-
-  private constructor() {
-    this.simctl = new Simctl();
-  }
-
-  /**
-   * Get the singleton instance of IOSManager
-   */
-  public static getInstance(): IOSManager {
-    if (!IOSManager.instance) {
-      IOSManager.instance = new IOSManager();
-    }
-    return IOSManager.instance;
-  }
-
-  /**
-   * Check if running on macOS (required for iOS development)
-   */
-  public isMac(): boolean {
-    return process.platform === 'darwin';
-  }
-
-  /**
-   * List all iOS simulators
-   * @returns Array of iOS simulators
-   */
-  public async listSimulators(): Promise<IOSDevice[]> {
-    if (!this.isMac()) {
-      log.warn('iOS simulators are only available on macOS');
-      return [];
-    }
-
-    try {
-      const devices = await this.simctl.getDevices();
-      const simulators: IOSDevice[] = [];
-
-      // devices is an object with runtime as key (e.g., "18.2") and array of devices as value
-      // node-simctl returns simplified runtime keys that are already iOS versions
-      for (const [runtime, deviceList] of Object.entries(devices)) {
-        if (Array.isArray(deviceList)) {
-          for (const device of deviceList) {
-            simulators.push({
-              name: device.name,
-              udid: device.udid,
-              state: device.state,
-              type: 'simulator',
-              platform: runtime, // Runtime is already the iOS version (e.g., "18.2")
-            });
-          }
-        }
-      }
-
-      return simulators;
-    } catch (error) {
-      log.error(`Error listing iOS simulators: ${error}`);
-      return [];
-    }
-  }
-
-  /**
-   * List only booted (running) iOS simulators
-   * @returns Array of booted simulators
-   */
-  public async listBootedSimulators(): Promise<IOSDevice[]> {
-    const allSimulators = await this.listSimulators();
-    return allSimulators.filter((simulator) => simulator.state === 'Booted');
-  }
-
-  /**
-   * List all connected real iOS devices
-   * @returns Array of real iOS devices
-   */
-  public async listRealDevices(): Promise<IOSDevice[]> {
-    if (!this.isMac()) {
-      log.warn('iOS real devices are only available on macOS');
-      return [];
-    }
-
-    try {
-      const devices = await utilities.getConnectedDevices();
-      return devices.map((udid: string) => ({
-        name: udid, // We'll use UDID as name for now
-        udid,
-        type: 'real' as const,
-      }));
-    } catch (error) {
-      log.error(`Error listing iOS real devices: ${error}`);
-      return [];
-    }
-  }
-
-  /**
-   * Get all available iOS simulators
-   * @returns Array of all iOS simulators (both booted and shutdown)
-   */
-  public async getAvailableSimulators(): Promise<IOSDevice[]> {
-    return await this.listSimulators();
-  }
-
-  /**
-   * Get all available real devices
-   * @returns Array of real iOS devices
-   */
-  public async getAvailableRealDevices(): Promise<IOSDevice[]> {
-    return await this.listRealDevices();
-  }
-
-  /**
-   * Get devices based on device type
-   * @param deviceType 'simulator' or 'real'
-   * @returns Array of iOS devices
-   */
-  public async getDevicesByType(
-    deviceType: 'simulator' | 'real'
-  ): Promise<IOSDevice[]> {
-    if (deviceType === 'simulator') {
-      return await this.getAvailableSimulators();
-    } else {
-      return await this.getAvailableRealDevices();
-    }
-  }
-}
-
-/**
- * Global iOS Manager instance
- */
-export const iosManager = IOSManager.getInstance();

package/src/index.ts

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-
-import server from './server.js';
-import log from './logger.js';
-
-// Parse command line arguments
-const args = process.argv.slice(2);
-const useHttpStream = args.includes('--httpStream');
-const port =
-  args.find((arg) => arg.startsWith('--port='))?.split('=')[1] || '8080';
-
-async function startServer(): Promise<void> {
-  log.info('Starting MCP Appium MCP Server...');
-
-  try {
-    if (useHttpStream) {
-      server.start({
-        transportType: 'httpStream',
-        httpStream: {
-          endpoint: '/sse',
-          port: parseInt(port, 10),
-        },
-      });
-
-      log.info(
-        `Server started with httpStream transport on http://localhost:${port}/sse`
-      );
-      log.info('Waiting for client connections...');
-    } else {
-      // Start with stdio transport
-      server.start({
-        transportType: 'stdio',
-      });
-
-      log.info('Server started with stdio transport');
-      log.info('Waiting for client connections...');
-    }
-  } catch (error: any) {
-    log.error('Error starting server:', error);
-    process.exit(1);
-  }
-}
-
-// Start the server
-startServer();

package/src/locators/element-filter.ts

@@ -1,136 +0,0 @@
-import { JSONElement } from './source-parsing.js';
-
-export interface FilterOptions {
-  includeTagNames?: string[];
-  excludeTagNames?: string[];
-  requireAttributes?: string[];
-  minAttributeCount?: number;
-  fetchableOnly?: boolean;
-  clickableOnly?: boolean;
-}
-
-/**
- * Determines if an element matches the tag name filters
- */
-function matchesTagFilters(
-  element: JSONElement,
-  includeTagNames: string[],
-  excludeTagNames: string[]
-): boolean {
-  if (
-    includeTagNames.length > 0 &&
-    !includeTagNames.includes(element.tagName)
-  ) {
-    return false;
-  }
-  if (excludeTagNames.includes(element.tagName)) {
-    return false;
-  }
-  return true;
-}
-
-/**
- * Determines if an element matches attribute-based filters
- */
-function matchesAttributeFilters(
-  element: JSONElement,
-  requireAttributes: string[],
-  minAttributeCount: number
-): boolean {
-  if (requireAttributes.length > 0) {
-    const hasRequiredAttr = requireAttributes.some(
-      (attr) => element.attributes && element.attributes[attr]
-    );
-    if (!hasRequiredAttr) {
-      return false;
-    }
-  }
-
-  if (
-    element.attributes &&
-    Object.keys(element.attributes).length < minAttributeCount
-  ) {
-    return false;
-  }
-
-  return true;
-}
-
-/**
- * Determines if an element is interactable/fetchable based on platform
- */
-function isInteractableElement(
-  element: JSONElement,
-  isNative: boolean,
-  automationName: string
-): boolean {
-  const interactableTags =
-    isNative && automationName === 'uiautomator2'
-      ? [
-          'EditText',
-          'Button',
-          'ImageButton',
-          'CheckBox',
-          'RadioButton',
-          'Switch',
-          'ToggleButton',
-          'TextView',
-        ]
-      : [
-          'XCUIElementTypeTextField',
-          'XCUIElementTypeSecureTextField',
-          'XCUIElementTypeButton',
-          'XCUIElementTypeImage',
-          'XCUIElementTypeSwitch',
-          'XCUIElementTypeStaticText',
-          'XCUIElementTypeTextView',
-          'XCUIElementTypeCell',
-          'XCUIElementTypeLink',
-        ];
-
-  return (
-    interactableTags.some((tag) => element.tagName.includes(tag)) ||
-    element.attributes?.clickable === 'true' ||
-    element.attributes?.focusable === 'true'
-  );
-}
-
-/**
- * Determines if an element should be included based on all filter criteria
- */
-export function shouldIncludeElement(
-  element: JSONElement,
-  filters: FilterOptions,
-  isNative: boolean,
-  automationName: string
-): boolean {
-  const {
-    includeTagNames = [],
-    excludeTagNames = ['hierarchy'],
-    requireAttributes = [],
-    minAttributeCount = 0,
-    fetchableOnly = false,
-    clickableOnly = false,
-  } = filters;
-
-  if (!matchesTagFilters(element, includeTagNames, excludeTagNames)) {
-    return false;
-  }
-
-  if (!matchesAttributeFilters(element, requireAttributes, minAttributeCount)) {
-    return false;
-  }
-
-  if (clickableOnly && element.attributes?.clickable !== 'true') {
-    return false;
-  }
-
-  if (
-    fetchableOnly &&
-    !isInteractableElement(element, isNative, automationName)
-  ) {
-    return false;
-  }
-
-  return true;
-}

package/src/locators/generate-all-locators.ts

@@ -1,150 +0,0 @@
-// Standalone Node.js script to generate locators for all elements from sourceXML
-// Using existing functions from src/locators directory
-
-import { getSuggestedLocators } from './locator-generation.js';
-import { xmlToJSON, JSONElement } from './source-parsing.js';
-import { shouldIncludeElement, FilterOptions } from './element-filter.js';
-import * as fs from 'fs';
-import log from '../logger.js';
-
-export interface ElementWithLocators {
-  tagName: string;
-  locators: Record<string, string>;
-  text: string;
-  contentDesc: string;
-  resourceId: string;
-  clickable: boolean;
-  enabled: boolean;
-  displayed: boolean;
-}
-
-/**
- * Transforms a JSONElement with locators into ElementWithLocators format
- */
-function transformElementWithLocators(
-  element: JSONElement,
-  locators: [string, string][]
-): ElementWithLocators {
-  // Filter out any undefined or invalid entries before converting to object
-  const validLocators = locators.filter(
-    (locator): locator is [string, string] =>
-      Array.isArray(locator) &&
-      locator.length === 2 &&
-      typeof locator[0] === 'string' &&
-      typeof locator[1] === 'string'
-  );
-
-  return {
-    tagName: element.tagName,
-    locators: Object.fromEntries(validLocators),
-    text: element.attributes.text || '',
-    contentDesc: element.attributes['content-desc'] || '',
-    resourceId: element.attributes['resource-id'] || '',
-    clickable: element.attributes.clickable === 'true',
-    enabled: element.attributes.enabled === 'true',
-    displayed: element.attributes.displayed === 'true',
-  };
-}
-
-/**
- * Processes a single element: generates locators if it passes filters
- */
-function processElement(
-  element: JSONElement,
-  sourceXML: string,
-  isNative: boolean,
-  automationName: string,
-  filters: FilterOptions,
-  results: ElementWithLocators[]
-): void {
-  if (!shouldIncludeElement(element, filters, isNative, automationName)) {
-    return;
-  }
-
-  try {
-    const strategyMap = getSuggestedLocators(
-      element,
-      sourceXML,
-      isNative,
-      automationName
-    );
-    results.push(transformElementWithLocators(element, strategyMap));
-  } catch (error) {
-    log.error(
-      `Error generating locators for element at path ${element.path}:`,
-      error
-    );
-  }
-}
-
-/**
- * Recursively traverses the element tree and processes each element
- */
-function traverseAndProcessElements(
-  element: JSONElement | null,
-  sourceXML: string,
-  isNative: boolean,
-  automationName: string,
-  filters: FilterOptions,
-  results: ElementWithLocators[]
-): void {
-  if (!element) {
-    return;
-  }
-
-  // Process current element
-  processElement(
-    element,
-    sourceXML,
-    isNative,
-    automationName,
-    filters,
-    results
-  );
-
-  // Recursively process children (even if parent was filtered out)
-  if (element.children && element.children.length > 0) {
-    element.children.forEach((child) =>
-      traverseAndProcessElements(
-        child,
-        sourceXML,
-        isNative,
-        automationName,
-        filters,
-        results
-      )
-    );
-  }
-}
-
-/**
- * Main function to generate locators for all elements from sourceXML
- *
- * @param sourceXML - The XML page source to process
- * @param isNative - Whether this is a native context
- * @param automationName - The automation driver name (uiautomator2, xcuitest, etc.)
- * @param filters - Optional filters to apply when selecting elements
- * @returns Array of elements with their generated locators
- */
-export function generateAllElementLocators(
-  sourceXML: string,
-  isNative: boolean = true,
-  automationName: string,
-  filters: FilterOptions = {}
-): ElementWithLocators[] {
-  const sourceJSON = xmlToJSON(sourceXML);
-  const results: ElementWithLocators[] = [];
-
-  if (sourceJSON) {
-    traverseAndProcessElements(
-      sourceJSON,
-      sourceXML,
-      isNative,
-      automationName,
-      filters,
-      results
-    );
-  }
-
-  return results;
-}