@wdio/mcp 1.4.0

package/lib/server.js

@@ -0,0 +1,2130 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/browser.tool.ts
+import { remote } from "webdriverio";
+import { z } from "zod";
+var startBrowserToolArguments = {
+  headless: z.boolean().optional(),
+  windowWidth: z.number().min(400).max(3840).optional(),
+  windowHeight: z.number().min(400).max(2160).optional()
+};
+var closeSessionToolArguments = {
+  detach: z.boolean().optional().describe("If true, disconnect from session without terminating it (preserves app state). Default: false")
+};
+var state = {
+  browsers: /* @__PURE__ */ new Map(),
+  currentSession: null,
+  sessionMetadata: /* @__PURE__ */ new Map()
+};
+var getBrowser = () => {
+  const browser = state.browsers.get(state.currentSession);
+  if (!browser) {
+    throw new Error("No active browser session");
+  }
+  return browser;
+};
+getBrowser.__state = state;
+var startBrowserTool = async ({ headless = false, windowWidth = 1280, windowHeight = 1080 }) => {
+  const chromeArgs = [
+    `--window-size=${windowWidth},${windowHeight}`,
+    "--no-sandbox",
+    "--disable-search-engine-choice-screen",
+    "--disable-infobars",
+    "--log-level=3",
+    "--use-fake-device-for-media-stream",
+    "--use-fake-ui-for-media-stream",
+    "--disable-web-security",
+    "--allow-running-insecure-content"
+  ];
+  if (headless) {
+    chromeArgs.push("--headless=new");
+    chromeArgs.push("--disable-gpu");
+    chromeArgs.push("--disable-dev-shm-usage");
+  }
+  const browser = await remote({
+    capabilities: {
+      browserName: "chrome",
+      "goog:chromeOptions": {
+        args: chromeArgs
+      },
+      acceptInsecureCerts: true
+    }
+  });
+  const { sessionId } = browser;
+  state.browsers.set(sessionId, browser);
+  state.currentSession = sessionId;
+  state.sessionMetadata.set(sessionId, {
+    type: "browser",
+    capabilities: browser.capabilities,
+    isAttached: false
+  });
+  const modeText = headless ? "headless" : "headed";
+  return {
+    content: [{
+      type: "text",
+      text: `Browser started in ${modeText} mode with sessionId: ${sessionId} (${windowWidth}x${windowHeight})`
+    }]
+  };
+};
+var closeSessionTool = async (args = {}) => {
+  try {
+    const browser = getBrowser();
+    const sessionId = state.currentSession;
+    const metadata = state.sessionMetadata.get(sessionId);
+    if (!args.detach) {
+      await browser.deleteSession();
+    }
+    state.browsers.delete(sessionId);
+    state.sessionMetadata.delete(sessionId);
+    state.currentSession = null;
+    const action = args.detach ? "detached from" : "closed";
+    const note = args.detach && !metadata?.isAttached ? "\nNote: Session will remain active on Appium server." : "";
+    return {
+      content: [{ type: "text", text: `Session ${sessionId} ${action}${note}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error closing session: ${e}` }]
+    };
+  }
+};
+
+// src/tools/navigate.tool.ts
+import { z as z2 } from "zod";
+var navigateToolArguments = {
+  url: z2.string().nonempty("URL must be provided")
+};
+var navigateTool = async ({ url }) => {
+  try {
+    const browser = getBrowser();
+    await browser.url(url);
+    return {
+      content: [{ type: "text", text: `Navigated to ${url}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error navigating: ${e}` }]
+    };
+  }
+};
+
+// src/tools/click.tool.ts
+import { z as z3 } from "zod";
+var defaultTimeout = 3e3;
+var clickToolArguments = {
+  selector: z3.string().describe(`Value for the selector, in the form of css selector or xpath ("button.my-class" or "//button[@class='my-class']" or "button=Exact text with spaces" or "a*=Link containing text")`),
+  scrollToView: z3.boolean().optional().describe("Whether to scroll the element into view before clicking").default(true),
+  timeout: z3.number().optional().describe("Maximum time to wait for element in milliseconds")
+};
+var clickAction = async (selector, timeout, scrollToView = true) => {
+  try {
+    const browser = getBrowser();
+    await browser.waitUntil(browser.$(selector).isExisting, { timeout });
+    if (scrollToView) {
+      await browser.$(selector).scrollIntoView({ block: "center", inline: "center" });
+    }
+    await browser.$(selector).click();
+    return {
+      content: [{ type: "text", text: `Element clicked (selector: ${selector})` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error clicking element: ${e}` }]
+    };
+  }
+};
+var clickTool = async ({ selector, scrollToView, timeout = defaultTimeout }) => clickAction(selector, timeout, scrollToView);
+var clickToolViaText = async ({ text, scrollToView, timeout = defaultTimeout }) => clickAction(`//a[contains(text(), '${text}')]`, timeout, scrollToView);
+
+// src/tools/set-value.tool.ts
+import { z as z4 } from "zod";
+var defaultTimeout2 = 3e3;
+var setValueToolArguments = {
+  selector: z4.string().describe(`Value for the selector, in the form of css selector or xpath ("button.my-class" or "//button[@class='my-class']")`),
+  value: z4.string().describe("Text to enter into the element"),
+  scrollToView: z4.boolean().optional().describe("Whether to scroll the element into view before typing").default(true),
+  timeout: z4.number().optional().describe("Maximum time to wait for element in milliseconds")
+};
+var setValueTool = async ({ selector, value, scrollToView = true, timeout = defaultTimeout2 }) => {
+  try {
+    const browser = getBrowser();
+    await browser.waitUntil(browser.$(selector).isExisting, { timeout });
+    if (scrollToView) {
+      await browser.$(selector).scrollIntoView({ block: "center", inline: "center" });
+    }
+    await browser.$(selector).clearValue();
+    await browser.$(selector).setValue(value);
+    return {
+      content: [{ type: "text", text: `Text "${value}" entered into element` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error entering text: ${e}` }]
+    };
+  }
+};
+
+// src/tools/find-element.tool.ts
+import { z as z5 } from "zod";
+var defaultTimeout3 = 3e3;
+var findElementToolArguments = {
+  selector: z5.string().describe(`Value for the selector, in the form of css selector or xpath ("button.my-class" or "//button[@class='my-class']")`),
+  timeout: z5.number().optional().describe("Maximum time to wait for element in milliseconds")
+};
+var findElementTool = async ({ selector, timeout = defaultTimeout3 }) => {
+  try {
+    const browser = getBrowser();
+    await browser.waitUntil(browser.$(selector).isExisting, { timeout });
+    return {
+      content: [{ type: "text", text: "Element found" }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error finding element: ${e}` }]
+    };
+  }
+};
+
+// src/tools/get-element-text.tool.ts
+import { z as z6 } from "zod";
+var defaultTimeout4 = 3e3;
+var getElementTextToolArguments = {
+  selector: z6.string().describe(`Value for the selector, in the form of css selector or xpath ("button.my-class" or "//button[@class='my-class']")`),
+  timeout: z6.number().optional().describe("Maximum time to wait for element in milliseconds")
+};
+var getElementTextTool = async ({ selector, timeout = defaultTimeout4 }) => {
+  try {
+    const browser = getBrowser();
+    await browser.waitUntil(browser.$(selector).isExisting, { timeout });
+    const text = await browser.$(selector).getText();
+    return {
+      content: [{ type: "text", text: `Text from element "${selector}": ${text}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error getting element text: ${e}` }]
+    };
+  }
+};
+
+// src/tools/is-displayed.tool.ts
+import { z as z7 } from "zod";
+var defaultTimeout5 = 3e3;
+var isDisplayedToolArguments = {
+  selector: z7.string().describe(`Value for the selector, in the form of css selector or xpath ("button.my-class" or "//button[@class='my-class']")`),
+  timeout: z7.number().optional().describe("Maximum time to wait for element in milliseconds")
+};
+var isDisplayedTool = async ({ selector, timeout = defaultTimeout5 }) => {
+  try {
+    const browser = getBrowser();
+    await browser.waitUntil(browser.$(selector).isExisting, { timeout });
+    const displayed = await browser.$(selector).isDisplayed();
+    return {
+      content: [{
+        type: "text",
+        text: `Element with selector "${selector}" is ${displayed ? "displayed" : "not displayed"}`
+      }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error checking if element is displayed: ${e}` }]
+    };
+  }
+};
+
+// src/tools/scroll-down.tool.ts
+import { z as z8 } from "zod";
+var scrollDownToolArguments = {
+  pixels: z8.number().optional().default(500)
+};
+var scrollDownTool = async ({ pixels = 500 }) => {
+  try {
+    const browser = getBrowser();
+    await browser.execute((scrollPixels) => {
+      window.scrollBy(0, scrollPixels);
+    }, pixels);
+    return {
+      content: [{ type: "text", text: `Scrolled down ${pixels} pixels` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error scrolling down: ${e}` }]
+    };
+  }
+};
+
+// src/tools/scroll-up.tool.ts
+import { z as z9 } from "zod";
+var scrollUpToolArguments = {
+  pixels: z9.number().optional().default(500)
+};
+var scrollUpTool = async ({ pixels = 500 }) => {
+  try {
+    const browser = getBrowser();
+    await browser.execute((scrollPixels) => {
+      window.scrollBy(0, -scrollPixels);
+    }, pixels);
+    return {
+      content: [{ type: "text", text: `Scrolled up ${pixels} pixels` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error scrolling up: ${e}` }]
+    };
+  }
+};
+
+// src/scripts/get-interactable-elements.ts
+var elementsScript = () => (function() {
+  const interactableSelectors = [
+    "a[href]",
+    // Links with href
+    "button",
+    // Buttons
+    'input:not([type="hidden"])',
+    // Input fields (except hidden)
+    "select",
+    // Select dropdowns
+    "textarea",
+    // Text areas
+    '[role="button"]',
+    // Elements with button role
+    '[role="link"]',
+    // Elements with link role
+    '[role="checkbox"]',
+    // Elements with checkbox role
+    '[role="radio"]',
+    // Elements with radio role
+    '[role="tab"]',
+    // Elements with tab role
+    '[role="menuitem"]',
+    // Elements with menuitem role
+    '[role="combobox"]',
+    // Elements with combobox role
+    '[role="option"]',
+    // Elements with option role
+    '[role="switch"]',
+    // Elements with switch role
+    '[role="slider"]',
+    // Elements with slider role
+    '[role="textbox"]',
+    // Elements with textbox role
+    '[role="searchbox"]',
+    // Elements with searchbox role
+    '[contenteditable="true"]',
+    // Editable content
+    '[tabindex]:not([tabindex="-1"])'
+    // Elements with tabindex
+  ];
+  function isVisible(element) {
+    if (typeof element.checkVisibility === "function") {
+      return element.checkVisibility({
+        opacityProperty: true,
+        visibilityProperty: true,
+        contentVisibilityAuto: true
+      });
+    }
+    const style = window.getComputedStyle(element);
+    return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0" && element.offsetWidth > 0 && element.offsetHeight > 0;
+  }
+  function getCssSelector(element) {
+    if (element.id) {
+      return `#${CSS.escape(element.id)}`;
+    }
+    if (element.className) {
+      const classes = element.className.trim().split(/\s+/).filter(Boolean);
+      if (classes.length > 0) {
+        const classSelector = classes.slice(0, 2).map((c) => `.${CSS.escape(c)}`).join("");
+        const tagWithClass = `${element.tagName.toLowerCase()}${classSelector}`;
+        if (document.querySelectorAll(tagWithClass).length === 1) {
+          return tagWithClass;
+        }
+      }
+    }
+    let current = element;
+    const path = [];
+    while (current && current !== document.documentElement) {
+      let selector = current.tagName.toLowerCase();
+      if (current.id) {
+        selector = `#${CSS.escape(current.id)}`;
+        path.unshift(selector);
+        break;
+      }
+      const parent = current.parentElement;
+      if (parent) {
+        const siblings = Array.from(parent.children).filter(
+          (child) => child.tagName === current.tagName
+        );
+        if (siblings.length > 1) {
+          const index = siblings.indexOf(current) + 1;
+          selector += `:nth-child(${index})`;
+        }
+      }
+      path.unshift(selector);
+      current = current.parentElement;
+      if (path.length >= 4) {
+        break;
+      }
+    }
+    return path.join(" > ");
+  }
+  function getInteractableElements() {
+    const allElements = [];
+    interactableSelectors.forEach((selector) => {
+      const elements = document.querySelectorAll(selector);
+      elements.forEach((element) => {
+        if (!allElements.includes(element)) {
+          allElements.push(element);
+        }
+      });
+    });
+    const elementInfos = allElements.filter((element) => isVisible(element) && !element.disabled).map((element) => {
+      const rect = element.getBoundingClientRect();
+      const isInViewport = rect.top >= 0 && rect.left >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && rect.right <= (window.innerWidth || document.documentElement.clientWidth);
+      return {
+        tagName: element.tagName.toLowerCase(),
+        type: element.getAttribute("type") || void 0,
+        id: element.id || void 0,
+        className: element.className || void 0,
+        textContent: element.textContent?.trim() || void 0,
+        value: element.value || void 0,
+        placeholder: element.placeholder || void 0,
+        href: element.getAttribute("href") || void 0,
+        ariaLabel: element.getAttribute("aria-label") || void 0,
+        role: element.getAttribute("role") || void 0,
+        cssSelector: getCssSelector(element),
+        isInViewport
+      };
+    });
+    return [
+      ...elementInfos
+    ];
+  }
+  return getInteractableElements();
+})();
+var get_interactable_elements_default = elementsScript;
+
+// src/locators/source-parsing.ts
+import { DOMParser } from "@xmldom/xmldom";
+function childNodesOf(node) {
+  const children = [];
+  if (node.childNodes) {
+    for (let i = 0; i < node.childNodes.length; i++) {
+      const child = node.childNodes.item(i);
+      if (child?.nodeType === 1) {
+        children.push(child);
+      }
+    }
+  }
+  return children;
+}
+function translateRecursively(domNode, parentPath = "", index = null) {
+  const attributes = {};
+  const element = domNode;
+  if (element.attributes) {
+    for (let attrIdx = 0; attrIdx < element.attributes.length; attrIdx++) {
+      const attr = element.attributes.item(attrIdx);
+      if (attr) {
+        attributes[attr.name] = attr.value.replace(/(\n)/gm, "\\n");
+      }
+    }
+  }
+  const path = index === null ? "" : `${parentPath ? parentPath + "." : ""}${index}`;
+  return {
+    children: childNodesOf(domNode).map(
+      (childNode, childIndex) => translateRecursively(childNode, path, childIndex)
+    ),
+    tagName: domNode.nodeName,
+    attributes,
+    path
+  };
+}
+function xmlToJSON(sourceXML) {
+  try {
+    const parser = new DOMParser();
+    const sourceDoc = parser.parseFromString(sourceXML, "text/xml");
+    const parseErrors = sourceDoc.getElementsByTagName("parsererror");
+    if (parseErrors.length > 0) {
+      console.error("[xmlToJSON] XML parsing error:", parseErrors[0].textContent);
+      return null;
+    }
+    const children = childNodesOf(sourceDoc);
+    const firstChild = children[0] || (sourceDoc.documentElement ? childNodesOf(sourceDoc.documentElement)[0] : null);
+    return firstChild ? translateRecursively(firstChild) : { children: [], tagName: "", attributes: {}, path: "" };
+  } catch (e) {
+    console.error("[xmlToJSON] Failed to parse XML:", e);
+    return null;
+  }
+}
+function parseAndroidBounds(bounds) {
+  const match = bounds.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+  if (!match) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  const x1 = parseInt(match[1], 10);
+  const y1 = parseInt(match[2], 10);
+  const x2 = parseInt(match[3], 10);
+  const y2 = parseInt(match[4], 10);
+  return {
+    x: x1,
+    y: y1,
+    width: x2 - x1,
+    height: y2 - y1
+  };
+}
+function parseIOSBounds(attributes) {
+  return {
+    x: parseInt(attributes.x || "0", 10),
+    y: parseInt(attributes.y || "0", 10),
+    width: parseInt(attributes.width || "0", 10),
+    height: parseInt(attributes.height || "0", 10)
+  };
+}
+function countAttributeOccurrences(sourceXML, attribute, value) {
+  const escapedValue = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`${attribute}=["']${escapedValue}["']`, "g");
+  const matches = sourceXML.match(pattern);
+  return matches ? matches.length : 0;
+}
+function isAttributeUnique(sourceXML, attribute, value) {
+  return countAttributeOccurrences(sourceXML, attribute, value) === 1;
+}
+
+// src/locators/element-filter.ts
+var ANDROID_INTERACTABLE_TAGS = [
+  // Input elements
+  "android.widget.EditText",
+  "android.widget.AutoCompleteTextView",
+  "android.widget.MultiAutoCompleteTextView",
+  "android.widget.SearchView",
+  // Button-like elements
+  "android.widget.Button",
+  "android.widget.ImageButton",
+  "android.widget.ToggleButton",
+  "android.widget.CompoundButton",
+  "android.widget.RadioButton",
+  "android.widget.CheckBox",
+  "android.widget.Switch",
+  "android.widget.FloatingActionButton",
+  "com.google.android.material.button.MaterialButton",
+  "com.google.android.material.floatingactionbutton.FloatingActionButton",
+  // Text elements (often tappable)
+  "android.widget.TextView",
+  "android.widget.CheckedTextView",
+  // Image elements (often tappable)
+  "android.widget.ImageView",
+  "android.widget.QuickContactBadge",
+  // Selection elements
+  "android.widget.Spinner",
+  "android.widget.SeekBar",
+  "android.widget.RatingBar",
+  "android.widget.ProgressBar",
+  "android.widget.DatePicker",
+  "android.widget.TimePicker",
+  "android.widget.NumberPicker",
+  // List/grid items
+  "android.widget.AdapterView"
+];
+var IOS_INTERACTABLE_TAGS = [
+  // Input elements
+  "XCUIElementTypeTextField",
+  "XCUIElementTypeSecureTextField",
+  "XCUIElementTypeTextView",
+  "XCUIElementTypeSearchField",
+  // Button-like elements
+  "XCUIElementTypeButton",
+  "XCUIElementTypeLink",
+  // Text elements (often tappable)
+  "XCUIElementTypeStaticText",
+  // Image elements
+  "XCUIElementTypeImage",
+  "XCUIElementTypeIcon",
+  // Selection elements
+  "XCUIElementTypeSwitch",
+  "XCUIElementTypeSlider",
+  "XCUIElementTypeStepper",
+  "XCUIElementTypeSegmentedControl",
+  "XCUIElementTypePicker",
+  "XCUIElementTypePickerWheel",
+  "XCUIElementTypeDatePicker",
+  "XCUIElementTypePageIndicator",
+  // Table/list items
+  "XCUIElementTypeCell",
+  "XCUIElementTypeMenuItem",
+  "XCUIElementTypeMenuBarItem",
+  // Toggle elements
+  "XCUIElementTypeCheckBox",
+  "XCUIElementTypeRadioButton",
+  "XCUIElementTypeToggle",
+  // Other interactive
+  "XCUIElementTypeKey",
+  "XCUIElementTypeKeyboard",
+  "XCUIElementTypeAlert",
+  "XCUIElementTypeSheet"
+];
+var ANDROID_LAYOUT_CONTAINERS = [
+  // Core ViewGroup classes
+  "android.view.ViewGroup",
+  "android.view.View",
+  "android.widget.FrameLayout",
+  "android.widget.LinearLayout",
+  "android.widget.RelativeLayout",
+  "android.widget.GridLayout",
+  "android.widget.TableLayout",
+  "android.widget.TableRow",
+  "android.widget.AbsoluteLayout",
+  // AndroidX layout classes
+  "androidx.constraintlayout.widget.ConstraintLayout",
+  "androidx.coordinatorlayout.widget.CoordinatorLayout",
+  "androidx.appcompat.widget.LinearLayoutCompat",
+  "androidx.cardview.widget.CardView",
+  "androidx.appcompat.widget.ContentFrameLayout",
+  "androidx.appcompat.widget.FitWindowsFrameLayout",
+  // Scrolling containers
+  "android.widget.ScrollView",
+  "android.widget.HorizontalScrollView",
+  "android.widget.NestedScrollView",
+  "androidx.core.widget.NestedScrollView",
+  "androidx.recyclerview.widget.RecyclerView",
+  "android.widget.ListView",
+  "android.widget.GridView",
+  "android.widget.AbsListView",
+  // App chrome / system elements
+  "android.widget.ActionBarContainer",
+  "android.widget.ActionBarOverlayLayout",
+  "android.view.ViewStub",
+  "androidx.appcompat.widget.ActionBarContainer",
+  "androidx.appcompat.widget.ActionBarContextView",
+  "androidx.appcompat.widget.ActionBarOverlayLayout",
+  // Decor views
+  "com.android.internal.policy.DecorView",
+  "android.widget.DecorView"
+];
+var IOS_LAYOUT_CONTAINERS = [
+  // Generic containers
+  "XCUIElementTypeOther",
+  "XCUIElementTypeGroup",
+  "XCUIElementTypeLayoutItem",
+  // Scroll containers
+  "XCUIElementTypeScrollView",
+  "XCUIElementTypeTable",
+  "XCUIElementTypeCollectionView",
+  "XCUIElementTypeScrollBar",
+  // Navigation chrome
+  "XCUIElementTypeNavigationBar",
+  "XCUIElementTypeTabBar",
+  "XCUIElementTypeToolbar",
+  "XCUIElementTypeStatusBar",
+  "XCUIElementTypeMenuBar",
+  // Windows and views
+  "XCUIElementTypeWindow",
+  "XCUIElementTypeSheet",
+  "XCUIElementTypeDrawer",
+  "XCUIElementTypeDialog",
+  "XCUIElementTypePopover",
+  "XCUIElementTypePopUpButton",
+  // Outline elements
+  "XCUIElementTypeOutline",
+  "XCUIElementTypeOutlineRow",
+  "XCUIElementTypeBrowser",
+  "XCUIElementTypeSplitGroup",
+  "XCUIElementTypeSplitter",
+  // Application root
+  "XCUIElementTypeApplication"
+];
+function matchesTagList(tagName, tagList) {
+  if (tagList.includes(tagName)) {
+    return true;
+  }
+  for (const tag of tagList) {
+    if (tagName.endsWith(tag) || tagName.includes(tag)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchesTagFilters(element, includeTagNames, excludeTagNames) {
+  if (includeTagNames.length > 0 && !matchesTagList(element.tagName, includeTagNames)) {
+    return false;
+  }
+  if (matchesTagList(element.tagName, excludeTagNames)) {
+    return false;
+  }
+  return true;
+}
+function matchesAttributeFilters(element, requireAttributes, minAttributeCount) {
+  if (requireAttributes.length > 0) {
+    const hasRequiredAttr = requireAttributes.some((attr) => element.attributes?.[attr]);
+    if (!hasRequiredAttr) return false;
+  }
+  if (element.attributes && minAttributeCount > 0) {
+    const attrCount = Object.values(element.attributes).filter(
+      (v) => v !== void 0 && v !== null && v !== ""
+    ).length;
+    if (attrCount < minAttributeCount) {
+      return false;
+    }
+  }
+  return true;
+}
+function isInteractableElement(element, isNative, automationName) {
+  const isAndroid = automationName.toLowerCase().includes("uiautomator");
+  const interactableTags = isAndroid ? ANDROID_INTERACTABLE_TAGS : IOS_INTERACTABLE_TAGS;
+  if (matchesTagList(element.tagName, interactableTags)) {
+    return true;
+  }
+  if (isAndroid) {
+    if (element.attributes?.clickable === "true" || element.attributes?.focusable === "true" || element.attributes?.checkable === "true" || element.attributes?.["long-clickable"] === "true") {
+      return true;
+    }
+  }
+  if (!isAndroid) {
+    if (element.attributes?.accessible === "true") {
+      return true;
+    }
+  }
+  return false;
+}
+function isLayoutContainer(element, platform) {
+  const containerList = platform === "android" ? ANDROID_LAYOUT_CONTAINERS : IOS_LAYOUT_CONTAINERS;
+  return matchesTagList(element.tagName, containerList);
+}
+function hasMeaningfulContent(element, platform) {
+  const attrs = element.attributes;
+  if (attrs.text && attrs.text.trim() !== "" && attrs.text !== "null") {
+    return true;
+  }
+  if (platform === "android") {
+    if (attrs["content-desc"] && attrs["content-desc"].trim() !== "" && attrs["content-desc"] !== "null") {
+      return true;
+    }
+  } else {
+    if (attrs.label && attrs.label.trim() !== "" && attrs.label !== "null") {
+      return true;
+    }
+    if (attrs.name && attrs.name.trim() !== "" && attrs.name !== "null") {
+      return true;
+    }
+  }
+  return false;
+}
+function shouldIncludeElement(element, filters, isNative, automationName) {
+  const {
+    includeTagNames = [],
+    excludeTagNames = ["hierarchy"],
+    // Always exclude root hierarchy node
+    requireAttributes = [],
+    minAttributeCount = 0,
+    fetchableOnly = false,
+    clickableOnly = false,
+    visibleOnly = true
+  } = filters;
+  if (!matchesTagFilters(element, includeTagNames, excludeTagNames)) {
+    return false;
+  }
+  if (!matchesAttributeFilters(element, requireAttributes, minAttributeCount)) {
+    return false;
+  }
+  if (clickableOnly && element.attributes?.clickable !== "true") {
+    return false;
+  }
+  if (visibleOnly) {
+    const isAndroid = automationName.toLowerCase().includes("uiautomator");
+    if (isAndroid && element.attributes?.displayed === "false") {
+      return false;
+    }
+    if (!isAndroid && element.attributes?.visible === "false") {
+      return false;
+    }
+  }
+  if (fetchableOnly && !isInteractableElement(element, isNative, automationName)) {
+    return false;
+  }
+  return true;
+}
+function getDefaultFilters(platform, includeContainers = false) {
+  const layoutContainers = platform === "android" ? ANDROID_LAYOUT_CONTAINERS : IOS_LAYOUT_CONTAINERS;
+  return {
+    excludeTagNames: includeContainers ? ["hierarchy"] : ["hierarchy", ...layoutContainers],
+    fetchableOnly: !includeContainers,
+    visibleOnly: true,
+    clickableOnly: false
+  };
+}
+
+// src/locators/locator-generation.ts
+function isValidValue(value) {
+  return value !== void 0 && value !== null && value !== "null" && value.trim() !== "";
+}
+function escapeText(text) {
+  return text.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+function getSimpleSuggestedLocators(element, sourceXML, isNative, automationName) {
+  const results = [];
+  const isAndroid = automationName.toLowerCase().includes("uiautomator");
+  const attrs = element.attributes;
+  if (isAndroid) {
+    const resourceId = attrs["resource-id"];
+    if (isValidValue(resourceId) && isAttributeUnique(sourceXML, "resource-id", resourceId)) {
+      results.push(["id", `android=new UiSelector().resourceId("${resourceId}")`]);
+    }
+    const contentDesc = attrs["content-desc"];
+    if (isValidValue(contentDesc) && isAttributeUnique(sourceXML, "content-desc", contentDesc)) {
+      results.push(["accessibility-id", `~${contentDesc}`]);
+    }
+    const text = attrs.text;
+    if (isValidValue(text) && text.length < 100 && isAttributeUnique(sourceXML, "text", text)) {
+      results.push(["text", `android=new UiSelector().text("${escapeText(text)}")`]);
+    }
+  } else {
+    const name = attrs.name;
+    if (isValidValue(name) && isAttributeUnique(sourceXML, "name", name)) {
+      results.push(["accessibility-id", `~${name}`]);
+    }
+    const label = attrs.label;
+    if (isValidValue(label) && label !== name && isAttributeUnique(sourceXML, "label", label)) {
+      results.push(["predicate-string", `-ios predicate string:label == "${escapeText(label)}"`]);
+    }
+    const value = attrs.value;
+    if (isValidValue(value) && isAttributeUnique(sourceXML, "value", value)) {
+      results.push(["predicate-string", `-ios predicate string:value == "${escapeText(value)}"`]);
+    }
+  }
+  return results;
+}
+function buildUiAutomatorSelector(element) {
+  const attrs = element.attributes;
+  const parts = [];
+  if (isValidValue(attrs["resource-id"])) {
+    parts.push(`resourceId("${attrs["resource-id"]}")`);
+  }
+  if (isValidValue(attrs.text) && attrs.text.length < 100) {
+    parts.push(`text("${escapeText(attrs.text)}")`);
+  }
+  if (isValidValue(attrs["content-desc"])) {
+    parts.push(`description("${attrs["content-desc"]}")`);
+  }
+  if (isValidValue(attrs.class)) {
+    parts.push(`className("${attrs.class}")`);
+  }
+  if (parts.length === 0) return null;
+  return `android=new UiSelector().${parts.join(".")}`;
+}
+function buildPredicateString(element) {
+  const attrs = element.attributes;
+  const conditions = [];
+  if (isValidValue(attrs.name)) {
+    conditions.push(`name == "${escapeText(attrs.name)}"`);
+  }
+  if (isValidValue(attrs.label)) {
+    conditions.push(`label == "${escapeText(attrs.label)}"`);
+  }
+  if (isValidValue(attrs.value)) {
+    conditions.push(`value == "${escapeText(attrs.value)}"`);
+  }
+  if (attrs.visible === "true") {
+    conditions.push("visible == 1");
+  }
+  if (attrs.enabled === "true") {
+    conditions.push("enabled == 1");
+  }
+  if (conditions.length === 0) return null;
+  return `-ios predicate string:${conditions.join(" AND ")}`;
+}
+function buildClassChain(element) {
+  const attrs = element.attributes;
+  const tagName = element.tagName;
+  if (!tagName.startsWith("XCUI")) return null;
+  let selector = `**/${tagName}`;
+  if (isValidValue(attrs.label)) {
+    selector += `[\`label == "${escapeText(attrs.label)}"\`]`;
+  } else if (isValidValue(attrs.name)) {
+    selector += `[\`name == "${escapeText(attrs.name)}"\`]`;
+  }
+  return `-ios class chain:${selector}`;
+}
+function buildXPath(element, sourceXML, isAndroid) {
+  const attrs = element.attributes;
+  const tagName = element.tagName;
+  const conditions = [];
+  if (isAndroid) {
+    if (isValidValue(attrs["resource-id"])) {
+      conditions.push(`@resource-id="${attrs["resource-id"]}"`);
+    }
+    if (isValidValue(attrs["content-desc"])) {
+      conditions.push(`@content-desc="${attrs["content-desc"]}"`);
+    }
+    if (isValidValue(attrs.text) && attrs.text.length < 100) {
+      conditions.push(`@text="${escapeText(attrs.text)}"`);
+    }
+  } else {
+    if (isValidValue(attrs.name)) {
+      conditions.push(`@name="${attrs.name}"`);
+    }
+    if (isValidValue(attrs.label)) {
+      conditions.push(`@label="${attrs.label}"`);
+    }
+    if (isValidValue(attrs.value)) {
+      conditions.push(`@value="${attrs.value}"`);
+    }
+  }
+  if (conditions.length === 0) {
+    return `//${tagName}`;
+  }
+  return `//${tagName}[${conditions.join(" and ")}]`;
+}
+function getComplexSuggestedLocators(element, sourceXML, isNative, automationName) {
+  const results = [];
+  const isAndroid = automationName.toLowerCase().includes("uiautomator");
+  if (isAndroid) {
+    const uiAutomator = buildUiAutomatorSelector(element);
+    if (uiAutomator) {
+      results.push(["uiautomator", uiAutomator]);
+    }
+    const xpath = buildXPath(element, sourceXML, true);
+    if (xpath) {
+      results.push(["xpath", xpath]);
+    }
+    if (isValidValue(element.attributes.class)) {
+      results.push([
+        "class-name",
+        `android=new UiSelector().className("${element.attributes.class}")`
+      ]);
+    }
+  } else {
+    const predicate = buildPredicateString(element);
+    if (predicate) {
+      results.push(["predicate-string", predicate]);
+    }
+    const classChain = buildClassChain(element);
+    if (classChain) {
+      results.push(["class-chain", classChain]);
+    }
+    const xpath = buildXPath(element, sourceXML, false);
+    if (xpath) {
+      results.push(["xpath", xpath]);
+    }
+    const type = element.tagName;
+    if (type.startsWith("XCUIElementType")) {
+      results.push(["class-name", `-ios class chain:**/${type}`]);
+    }
+  }
+  return results;
+}
+function getSuggestedLocators(element, sourceXML, isNative, automationName) {
+  const simpleLocators = getSimpleSuggestedLocators(element, sourceXML, isNative, automationName);
+  const complexLocators = getComplexSuggestedLocators(element, sourceXML, isNative, automationName);
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const locator of [...simpleLocators, ...complexLocators]) {
+    if (!seen.has(locator[1])) {
+      seen.add(locator[1]);
+      results.push(locator);
+    }
+  }
+  return results;
+}
+function locatorsToObject(locators) {
+  const result = {};
+  for (const [strategy, value] of locators) {
+    if (!result[strategy]) {
+      result[strategy] = value;
+    }
+  }
+  return result;
+}
+
+// src/locators/generate-all-locators.ts
+function parseBounds(element, platform) {
+  return platform === "android" ? parseAndroidBounds(element.attributes.bounds || "") : parseIOSBounds(element.attributes);
+}
+function isWithinViewport(bounds, viewport) {
+  return bounds.x >= 0 && bounds.y >= 0 && bounds.width > 0 && bounds.height > 0 && bounds.x + bounds.width <= viewport.width && bounds.y + bounds.height <= viewport.height;
+}
+function transformElement(element, locators, ctx) {
+  const attrs = element.attributes;
+  const bounds = parseBounds(element, ctx.platform);
+  return {
+    tagName: element.tagName,
+    locators: locatorsToObject(locators),
+    text: attrs.text || attrs.label || "",
+    contentDesc: attrs["content-desc"] || "",
+    resourceId: attrs["resource-id"] || "",
+    accessibilityId: attrs.name || attrs["content-desc"] || "",
+    label: attrs.label || "",
+    value: attrs.value || "",
+    className: attrs.class || element.tagName,
+    clickable: attrs.clickable === "true" || attrs.accessible === "true" || attrs["long-clickable"] === "true",
+    enabled: attrs.enabled !== "false",
+    displayed: ctx.platform === "android" ? attrs.displayed !== "false" : attrs.visible !== "false",
+    bounds,
+    isInViewport: isWithinViewport(bounds, ctx.viewportSize)
+  };
+}
+function shouldProcess(element, ctx) {
+  if (shouldIncludeElement(element, ctx.filters, ctx.isNative, ctx.automationName)) {
+    return true;
+  }
+  return isLayoutContainer(element, ctx.platform) && hasMeaningfulContent(element, ctx.platform);
+}
+function processElement(element, ctx) {
+  if (!shouldProcess(element, ctx)) return;
+  try {
+    const locators = getSuggestedLocators(element, ctx.sourceXML, ctx.isNative, ctx.automationName);
+    if (locators.length === 0) return;
+    const transformed = transformElement(element, locators, ctx);
+    if (Object.keys(transformed.locators).length === 0) return;
+    ctx.results.push(transformed);
+  } catch (error) {
+    console.error(`[processElement] Error at path ${element.path}:`, error);
+  }
+}
+function traverseTree(element, ctx) {
+  if (!element) return;
+  processElement(element, ctx);
+  for (const child of element.children || []) {
+    traverseTree(child, ctx);
+  }
+}
+function generateAllElementLocators(sourceXML, options) {
+  const sourceJSON = xmlToJSON(sourceXML);
+  if (!sourceJSON) {
+    console.error("[generateAllElementLocators] Failed to parse page source XML");
+    return [];
+  }
+  const ctx = {
+    sourceXML,
+    platform: options.platform,
+    automationName: options.platform === "android" ? "uiautomator2" : "xcuitest",
+    isNative: options.isNative ?? true,
+    viewportSize: options.viewportSize ?? { width: 9999, height: 9999 },
+    filters: options.filters ?? {},
+    results: []
+  };
+  traverseTree(sourceJSON, ctx);
+  return ctx.results;
+}
+
+// src/utils/mobile-elements.ts
+function toMobileElementInfo(element) {
+  const locatorValues = Object.values(element.locators);
+  return {
+    selector: locatorValues[0] || "",
+    alternativeSelectors: locatorValues.length > 1 ? locatorValues.slice(1, 3) : void 0,
+    locators: element.locators,
+    isInViewport: element.isInViewport,
+    isEnabled: element.enabled,
+    bounds: element.bounds,
+    tagName: element.tagName || void 0,
+    text: element.text || void 0,
+    resourceId: element.resourceId || void 0,
+    contentDesc: element.contentDesc || void 0,
+    accessibilityId: element.accessibilityId || void 0,
+    label: element.label || void 0,
+    value: element.value || void 0,
+    className: element.className || void 0
+  };
+}
+async function getViewportSize(browser) {
+  try {
+    const size = await browser.getWindowSize();
+    return { width: size.width, height: size.height };
+  } catch {
+    return { width: 9999, height: 9999 };
+  }
+}
+async function getMobileVisibleElements(browser, platform, options = {}) {
+  const { includeContainers = false, filterOptions } = options;
+  const viewportSize = await getViewportSize(browser);
+  const pageSource = await browser.getPageSource();
+  const filters = {
+    ...getDefaultFilters(platform, includeContainers),
+    ...filterOptions
+  };
+  const elements = generateAllElementLocators(pageSource, {
+    platform,
+    viewportSize,
+    filters
+  });
+  return elements.map(toMobileElementInfo);
+}
+
+// src/tools/get-visible-elements.tool.ts
+import { encode } from "@toon-format/toon";
+import { z as z10 } from "zod";
+var getVisibleElementsToolArguments = {
+  inViewportOnly: z10.boolean().optional().describe(
+    "Only return elements within the visible viewport. Default: true. Set to false to get ALL elements on the page."
+  ),
+  includeContainers: z10.boolean().optional().describe(
+    "Include layout containers (ViewGroup, FrameLayout, ScrollView, etc). Default: false. Set to true to see all elements including layouts."
+  )
+};
+var getVisibleElementsTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { inViewportOnly = true, includeContainers = false } = args || {};
+    if (browser.isAndroid || browser.isIOS) {
+      const platform = browser.isAndroid ? "android" : "ios";
+      let elements2 = await getMobileVisibleElements(browser, platform, {
+        includeContainers
+      });
+      if (inViewportOnly) {
+        elements2 = elements2.filter((el) => el.isInViewport);
+      }
+      return {
+        content: [{ type: "text", text: encode(elements2) }]
+      };
+    }
+    const elements = await browser.execute(get_interactable_elements_default);
+    if (inViewportOnly) {
+      const filteredElements = elements.filter((el) => el.isInViewport !== false);
+      return {
+        content: [{ type: "text", text: encode(filteredElements) }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: encode(elements) }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error getting visible elements: ${e}` }]
+    };
+  }
+};
+
+// src/tools/take-screenshot.tool.ts
+import { z as z11 } from "zod";
+var takeScreenshotToolArguments = {
+  outputPath: z11.string().optional().describe("Optional path where to save the screenshot. If not provided, returns base64 data.")
+};
+var takeScreenshotTool = async ({ outputPath }) => {
+  try {
+    const browser = getBrowser();
+    const screenshot = await browser.takeScreenshot();
+    if (outputPath) {
+      const fs = await import("fs");
+      await fs.promises.writeFile(outputPath, screenshot, "base64");
+      return {
+        content: [{ type: "text", text: `Screenshot saved to ${outputPath}` }]
+      };
+    }
+    return {
+      content: [
+        { type: "text", text: "Screenshot captured as base64:" },
+        { type: "image", data: screenshot.toString(), mimeType: "image/png" }
+      ]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error taking screenshot: ${e.message}` }]
+    };
+  }
+};
+
+// src/tools/cookies.tool.ts
+import { z as z12 } from "zod";
+var getCookiesToolArguments = {
+  name: z12.string().optional().describe("Optional cookie name to retrieve a specific cookie. If not provided, returns all cookies")
+};
+var getCookiesTool = async ({ name }) => {
+  try {
+    const browser = getBrowser();
+    if (name) {
+      const cookie = await browser.getCookies([name]);
+      if (cookie.length === 0) {
+        return {
+          content: [{ type: "text", text: `Cookie "${name}" not found` }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(cookie[0], null, 2) }]
+      };
+    }
+    const cookies = await browser.getCookies();
+    if (cookies.length === 0) {
+      return {
+        content: [{ type: "text", text: "No cookies found" }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(cookies, null, 2) }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error getting cookies: ${e}` }]
+    };
+  }
+};
+var setCookieToolArguments = {
+  name: z12.string().describe("Cookie name"),
+  value: z12.string().describe("Cookie value"),
+  domain: z12.string().optional().describe("Cookie domain (defaults to current domain)"),
+  path: z12.string().optional().describe('Cookie path (defaults to "/")'),
+  expires: z12.number().optional().describe("Expiry date as Unix timestamp in seconds"),
+  httpOnly: z12.boolean().optional().describe("HttpOnly flag"),
+  secure: z12.boolean().optional().describe("Secure flag"),
+  sameSite: z12.enum(["Strict", "Lax", "None"]).optional().describe("SameSite attribute")
+};
+var setCookieTool = async ({
+  name,
+  value,
+  domain,
+  path = "/",
+  expires,
+  httpOnly,
+  secure,
+  sameSite
+}) => {
+  try {
+    const browser = getBrowser();
+    const cookie = {
+      name,
+      value,
+      path,
+      domain,
+      expiry: expires,
+      httpOnly,
+      secure,
+      sameSite
+    };
+    await browser.setCookies(cookie);
+    return {
+      content: [{ type: "text", text: `Cookie "${name}" set successfully` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error setting cookie: ${e}` }]
+    };
+  }
+};
+var deleteCookiesToolArguments = {
+  name: z12.string().optional().describe("Optional cookie name to delete a specific cookie. If not provided, deletes all cookies")
+};
+var deleteCookiesTool = async ({ name }) => {
+  try {
+    const browser = getBrowser();
+    if (name) {
+      await browser.deleteCookies([name]);
+      return {
+        content: [{ type: "text", text: `Cookie "${name}" deleted successfully` }]
+      };
+    }
+    await browser.deleteCookies();
+    return {
+      content: [{ type: "text", text: "All cookies deleted successfully" }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error deleting cookies: ${e}` }]
+    };
+  }
+};
+
+// src/tools/get-accessibility-tree.tool.ts
+import { encode as encode2 } from "@toon-format/toon";
+function flattenAccessibilityTree(node, result = []) {
+  if (!node) return result;
+  if (node.role !== "WebArea" || node.name) {
+    result.push({
+      role: node.role,
+      name: node.name,
+      value: node.value,
+      description: node.description,
+      keyshortcuts: node.keyshortcuts,
+      roledescription: node.roledescription,
+      valuetext: node.valuetext,
+      disabled: node.disabled,
+      expanded: node.expanded,
+      focused: node.focused,
+      modal: node.modal,
+      multiline: node.multiline,
+      multiselectable: node.multiselectable,
+      readonly: node.readonly,
+      required: node.required,
+      selected: node.selected,
+      checked: node.checked,
+      pressed: node.pressed,
+      level: node.level,
+      valuemin: node.valuemin,
+      valuemax: node.valuemax,
+      autocomplete: node.autocomplete,
+      haspopup: node.haspopup,
+      invalid: node.invalid,
+      orientation: node.orientation
+    });
+  }
+  if (node.children && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      flattenAccessibilityTree(child, result);
+    }
+  }
+  return result;
+}
+var getAccessibilityTreeTool = async () => {
+  try {
+    const browser = getBrowser();
+    const puppeteer = await browser.getPuppeteer();
+    const pages = await puppeteer.pages();
+    if (pages.length === 0) {
+      return {
+        content: [{ type: "text", text: "No active pages found" }]
+      };
+    }
+    const page = pages[0];
+    const snapshot = await page.accessibility.snapshot({
+      interestingOnly: true
+      // Filter to only interesting/semantic nodes
+    });
+    if (!snapshot) {
+      return {
+        content: [{ type: "text", text: "No accessibility tree available" }]
+      };
+    }
+    const flattenedNodes = flattenAccessibilityTree(snapshot);
+    return {
+      content: [{
+        type: "text",
+        text: encode2(flattenedNodes)
+      }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error getting accessibility tree: ${e}` }]
+    };
+  }
+};
+
+// src/tools/app-session.tool.ts
+import { remote as remote2 } from "webdriverio";
+import { z as z13 } from "zod";
+
+// src/config/appium.config.ts
+function getAppiumServerConfig(overrides) {
+  return {
+    hostname: overrides?.hostname || process.env.APPIUM_URL || "127.0.0.1",
+    port: overrides?.port || Number(process.env.APPIUM_URL_PORT) || 4723,
+    path: overrides?.path || process.env.APPIUM_PATH || "/"
+  };
+}
+function buildIOSCapabilities(appPath, options) {
+  const capabilities = {
+    platformName: "iOS",
+    "appium:platformVersion": options.platformVersion,
+    "appium:deviceName": options.deviceName,
+    "appium:automationName": options.automationName || "XCUITest"
+  };
+  if (appPath) {
+    capabilities["appium:app"] = appPath;
+  }
+  if (options.udid) {
+    capabilities["appium:udid"] = options.udid;
+  }
+  if (options.noReset !== void 0) {
+    capabilities["appium:noReset"] = options.noReset;
+  }
+  if (options.fullReset !== void 0) {
+    capabilities["appium:fullReset"] = options.fullReset;
+  }
+  capabilities["appium:autoGrantPermissions"] = options.autoGrantPermissions ?? true;
+  capabilities["appium:autoAcceptAlerts"] = options.autoAcceptAlerts ?? true;
+  if (options.autoDismissAlerts !== void 0) {
+    capabilities["appium:autoDismissAlerts"] = options.autoDismissAlerts;
+    capabilities["appium:autoAcceptAlerts"] = void 0;
+  }
+  for (const [key, value] of Object.entries(options)) {
+    if (!["deviceName", "platformVersion", "automationName", "autoAcceptAlerts", "autoDismissAlerts", "udid", "noReset", "fullReset"].includes(
+      key
+    )) {
+      capabilities[`appium:${key}`] = value;
+    }
+  }
+  return capabilities;
+}
+function buildAndroidCapabilities(appPath, options) {
+  const capabilities = {
+    platformName: "Android",
+    "appium:platformVersion": options.platformVersion,
+    "appium:deviceName": options.deviceName,
+    "appium:automationName": options.automationName || "UiAutomator2"
+  };
+  if (appPath) {
+    capabilities["appium:app"] = appPath;
+  }
+  if (options.noReset !== void 0) {
+    capabilities["appium:noReset"] = options.noReset;
+  }
+  if (options.fullReset !== void 0) {
+    capabilities["appium:fullReset"] = options.fullReset;
+  }
+  capabilities["appium:autoGrantPermissions"] = options.autoGrantPermissions ?? true;
+  capabilities["appium:autoAcceptAlerts"] = options.autoAcceptAlerts ?? true;
+  if (options.autoDismissAlerts !== void 0) {
+    capabilities["appium:autoDismissAlerts"] = options.autoDismissAlerts;
+    capabilities["appium:autoAcceptAlerts"] = void 0;
+  }
+  if (options.appWaitActivity) {
+    capabilities["appium:appWaitActivity"] = options.appWaitActivity;
+  }
+  for (const [key, value] of Object.entries(options)) {
+    if (!["deviceName", "platformVersion", "automationName", "autoGrantPermissions", "appWaitActivity", "noReset", "fullReset"].includes(
+      key
+    )) {
+      capabilities[`appium:${key}`] = value;
+    }
+  }
+  return capabilities;
+}
+
+// src/tools/app-session.tool.ts
+var startAppToolArguments = {
+  platform: z13.enum(["iOS", "Android"]).describe("Mobile platform"),
+  appPath: z13.string().optional().describe("Path to the app file (.app/.apk/.ipa). Required unless noReset=true (connecting to already-running app)"),
+  deviceName: z13.string().describe("Device/emulator/simulator name"),
+  platformVersion: z13.string().optional().describe('OS version (e.g., "17.0", "14")'),
+  automationName: z13.enum(["XCUITest", "UiAutomator2", "Espresso"]).optional().describe("Automation driver name"),
+  appiumHost: z13.string().optional().describe("Appium server hostname (overrides APPIUM_URL env var)"),
+  appiumPort: z13.number().optional().describe("Appium server port (overrides APPIUM_URL_PORT env var)"),
+  appiumPath: z13.string().optional().describe("Appium server path (overrides APPIUM_PATH env var)"),
+  autoGrantPermissions: z13.boolean().optional().describe("Auto-grant app permissions (default: true)"),
+  autoAcceptAlerts: z13.boolean().optional().describe("Auto-accept alerts (default: true)"),
+  autoDismissAlerts: z13.boolean().optional().describe('Auto-dismiss alerts (default: false, will override "autoAcceptAlerts" to undefined if set)'),
+  appWaitActivity: z13.string().optional().describe("Activity to wait for on launch (Android only)"),
+  udid: z13.string().optional().describe('Unique Device Identifier for iOS real device testing (e.g., "00008030-001234567890002E")'),
+  noReset: z13.boolean().optional().describe("Do not reset app state before session (preserves app data). Default: false"),
+  fullReset: z13.boolean().optional().describe("Uninstall app before/after session. Default: true. Set to false with noReset=true to preserve app state completely")
+};
+var getState = () => {
+  const sharedState = getBrowser.__state;
+  if (!sharedState) {
+    throw new Error("Browser state not initialized");
+  }
+  return sharedState;
+};
+var startAppTool = async (args) => {
+  try {
+    const {
+      platform,
+      appPath,
+      deviceName,
+      platformVersion,
+      automationName,
+      appiumHost,
+      appiumPort,
+      appiumPath,
+      autoGrantPermissions = true,
+      autoAcceptAlerts,
+      autoDismissAlerts,
+      appWaitActivity,
+      udid,
+      noReset,
+      fullReset
+    } = args;
+    if (!appPath && noReset !== true) {
+      return {
+        content: [{
+          type: "text",
+          text: 'Error: Either "appPath" must be provided to install an app, or "noReset: true" must be set to connect to an already-running app.'
+        }]
+      };
+    }
+    const serverConfig = getAppiumServerConfig({
+      hostname: appiumHost,
+      port: appiumPort,
+      path: appiumPath
+    });
+    const capabilities = platform === "iOS" ? buildIOSCapabilities(appPath, {
+      deviceName,
+      platformVersion,
+      automationName: automationName || "XCUITest",
+      autoGrantPermissions,
+      autoAcceptAlerts,
+      autoDismissAlerts,
+      udid,
+      noReset,
+      fullReset
+    }) : buildAndroidCapabilities(appPath, {
+      deviceName,
+      platformVersion,
+      automationName: automationName || "UiAutomator2",
+      autoGrantPermissions,
+      autoAcceptAlerts,
+      autoDismissAlerts,
+      appWaitActivity,
+      noReset,
+      fullReset
+    });
+    const browser = await remote2({
+      protocol: "http",
+      hostname: serverConfig.hostname,
+      port: serverConfig.port,
+      path: serverConfig.path,
+      capabilities
+    });
+    const { sessionId } = browser;
+    const shouldAutoDetach = noReset === true || !appPath;
+    const state2 = getState();
+    state2.browsers.set(sessionId, browser);
+    state2.currentSession = sessionId;
+    state2.sessionMetadata.set(sessionId, {
+      type: platform.toLowerCase(),
+      capabilities,
+      isAttached: shouldAutoDetach
+    });
+    const appInfo = appPath ? `
+App: ${appPath}` : "\nApp: (connected to running app)";
+    const detachNote = shouldAutoDetach ? "\n\n(Auto-detach enabled: session will be preserved on close. Use close_session({ detach: false }) to force terminate.)" : "";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `${platform} app session started with sessionId: ${sessionId}
+Device: ${deviceName}${appInfo}
+Appium Server: ${serverConfig.hostname}:${serverConfig.port}${serverConfig.path}${detachNote}`
+        }
+      ]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error starting app session: ${e}` }]
+    };
+  }
+};
+
+// src/tools/gestures.tool.ts
+import { z as z14 } from "zod";
+var tapElementToolArguments = {
+  selector: z14.string().optional().describe("Element selector (CSS, XPath, accessibility ID, or UiAutomator)"),
+  x: z14.number().optional().describe("X coordinate for tap (if no selector provided)"),
+  y: z14.number().optional().describe("Y coordinate for tap (if no selector provided)")
+};
+var tapElementTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { selector, x, y } = args;
+    if (selector) {
+      const element = await browser.$(selector);
+      await element.tap();
+      return {
+        content: [{ type: "text", text: `Tapped element: ${selector}` }]
+      };
+    } else if (x !== void 0 && y !== void 0) {
+      await browser.touchAction({
+        action: "tap",
+        x,
+        y
+      });
+      return {
+        content: [{ type: "text", text: `Tapped at coordinates: (${x}, ${y})` }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: "Error: Must provide either selector or x,y coordinates" }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error tapping element: ${e}` }]
+    };
+  }
+};
+var swipeToolArguments = {
+  direction: z14.enum(["up", "down", "left", "right"]).describe("Swipe direction"),
+  duration: z14.number().min(100).max(5e3).optional().describe("Swipe duration in milliseconds (default: 500)"),
+  startX: z14.number().optional().describe("Start X coordinate (optional, uses screen center)"),
+  startY: z14.number().optional().describe("Start Y coordinate (optional, uses screen center)"),
+  distance: z14.number().optional().describe("Swipe distance in pixels (optional, uses percentage of screen)")
+};
+var swipeTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { direction, duration = 500, startX, startY, distance } = args;
+    const windowSize = await browser.getWindowSize();
+    const screenWidth = windowSize.width;
+    const screenHeight = windowSize.height;
+    const centerX = startX ?? screenWidth / 2;
+    const centerY = startY ?? screenHeight / 2;
+    const swipeDistance = distance ?? Math.min(screenWidth, screenHeight) * 0.5;
+    let endX = centerX;
+    let endY = centerY;
+    switch (direction) {
+      case "up":
+        endY = centerY - swipeDistance;
+        break;
+      case "down":
+        endY = centerY + swipeDistance;
+        break;
+      case "left":
+        endX = centerX - swipeDistance;
+        break;
+      case "right":
+        endX = centerX + swipeDistance;
+        break;
+    }
+    await browser.touchPerform([
+      { action: "press", options: { x: centerX, y: centerY } },
+      { action: "wait", options: { ms: duration } },
+      { action: "moveTo", options: { x: endX, y: endY } },
+      { action: "release", options: {} }
+    ]);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Swiped ${direction} from (${Math.round(centerX)}, ${Math.round(centerY)}) to (${Math.round(endX)}, ${Math.round(endY)}) over ${duration}ms`
+        }
+      ]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error swiping: ${e}` }]
+    };
+  }
+};
+var longPressToolArguments = {
+  selector: z14.string().optional().describe("Element selector (CSS, XPath, accessibility ID, or UiAutomator)"),
+  x: z14.number().optional().describe("X coordinate for long press (if no selector provided)"),
+  y: z14.number().optional().describe("Y coordinate for long press (if no selector provided)"),
+  duration: z14.number().min(500).max(1e4).optional().describe("Long press duration in milliseconds (default: 1000)")
+};
+var longPressTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { selector, x, y, duration = 1e3 } = args;
+    if (selector) {
+      const element = await browser.$(selector);
+      await element.touchAction([
+        { action: "longPress" },
+        { action: "wait", ms: duration },
+        { action: "release" }
+      ]);
+      return {
+        content: [{ type: "text", text: `Long pressed element: ${selector} for ${duration}ms` }]
+      };
+    } else if (x !== void 0 && y !== void 0) {
+      await browser.touchPerform([
+        { action: "press", options: { x, y } },
+        { action: "wait", options: { ms: duration } },
+        { action: "release", options: {} }
+      ]);
+      return {
+        content: [{ type: "text", text: `Long pressed at coordinates: (${x}, ${y}) for ${duration}ms` }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: "Error: Must provide either selector or x,y coordinates" }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error long pressing: ${e}` }]
+    };
+  }
+};
+var dragAndDropToolArguments = {
+  fromSelector: z14.string().optional().describe("Source element selector"),
+  fromX: z14.number().optional().describe("Source X coordinate"),
+  fromY: z14.number().optional().describe("Source Y coordinate"),
+  toSelector: z14.string().optional().describe("Target element selector"),
+  toX: z14.number().optional().describe("Target X coordinate"),
+  toY: z14.number().optional().describe("Target Y coordinate"),
+  duration: z14.number().min(100).max(5e3).optional().describe("Drag duration in milliseconds (default: 500)")
+};
+var dragAndDropTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { fromSelector, fromX, fromY, toSelector, toX, toY, duration = 500 } = args;
+    let startX;
+    let startY;
+    let endX;
+    let endY;
+    if (fromSelector) {
+      const element = await browser.$(fromSelector);
+      const location = await element.getLocation();
+      const size = await element.getSize();
+      startX = location.x + size.width / 2;
+      startY = location.y + size.height / 2;
+    } else if (fromX !== void 0 && fromY !== void 0) {
+      startX = fromX;
+      startY = fromY;
+    } else {
+      return {
+        content: [{ type: "text", text: "Error: Must provide either fromSelector or fromX,fromY coordinates" }]
+      };
+    }
+    if (toSelector) {
+      const element = await browser.$(toSelector);
+      const location = await element.getLocation();
+      const size = await element.getSize();
+      endX = location.x + size.width / 2;
+      endY = location.y + size.height / 2;
+    } else if (toX !== void 0 && toY !== void 0) {
+      endX = toX;
+      endY = toY;
+    } else {
+      return {
+        content: [{ type: "text", text: "Error: Must provide either toSelector or toX,toY coordinates" }]
+      };
+    }
+    await browser.touchPerform([
+      { action: "press", options: { x: startX, y: startY } },
+      { action: "wait", options: { ms: duration } },
+      { action: "moveTo", options: { x: endX, y: endY } },
+      { action: "release", options: {} }
+    ]);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Dragged from (${Math.round(startX)}, ${Math.round(startY)}) to (${Math.round(endX)}, ${Math.round(endY)}) over ${duration}ms`
+        }
+      ]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error dragging and dropping: ${e}` }]
+    };
+  }
+};
+
+// src/tools/app-actions.tool.ts
+import { z as z15 } from "zod";
+var getAppStateToolArguments = {
+  bundleId: z15.string().describe("App bundle ID (e.g., com.example.app)")
+};
+var getAppStateTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { bundleId } = args;
+    const appIdentifier = browser.isAndroid ? { appId: bundleId } : { bundleId };
+    const state2 = await browser.execute("mobile: queryAppState", appIdentifier);
+    const stateMap = {
+      0: "not installed",
+      1: "not running",
+      2: "running in background (suspended)",
+      3: "running in background",
+      4: "running in foreground"
+    };
+    return {
+      content: [
+        {
+          type: "text",
+          text: `App state for ${bundleId}: ${stateMap[state2] || "unknown: " + state2}`
+        }
+      ]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error getting app state: ${e}` }]
+    };
+  }
+};
+var activateAppToolArguments = {
+  bundleId: z15.string().describe("App bundle ID to activate (e.g., com.example.app)")
+};
+var activateAppTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { bundleId } = args;
+    const appIdentifier = browser.isAndroid ? { appId: bundleId } : { bundleId };
+    await browser.execute("mobile: activateApp", appIdentifier);
+    return {
+      content: [{ type: "text", text: `Activated app: ${bundleId}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error activating app: ${e}` }]
+    };
+  }
+};
+var terminateAppToolArguments = {
+  bundleId: z15.string().describe("App bundle ID to terminate (e.g., com.example.app)")
+};
+var terminateAppTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { bundleId } = args;
+    const appIdentifier = browser.isAndroid ? { appId: bundleId } : { bundleId };
+    await browser.execute("mobile: terminateApp", appIdentifier);
+    return {
+      content: [{ type: "text", text: `Terminated app: ${bundleId}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error terminating app: ${e}` }]
+    };
+  }
+};
+
+// src/tools/context.tool.ts
+import { z as z16 } from "zod";
+var getContextsTool = async () => {
+  try {
+    const browser = getBrowser();
+    const contexts = await browser.getContexts();
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Available contexts:
+${contexts.map((ctx, idx) => `${idx + 1}. ${ctx}`).join("\n")}`
+        }
+      ]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error getting contexts: ${e}` }]
+    };
+  }
+};
+var getCurrentContextTool = async () => {
+  try {
+    const browser = getBrowser();
+    const currentContext = await browser.getContext();
+    return {
+      content: [{ type: "text", text: `Current context: ${JSON.stringify(currentContext)}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error getting current context: ${e}` }]
+    };
+  }
+};
+var switchContextToolArguments = {
+  context: z16.string().describe(
+    'Context name to switch to (e.g., "NATIVE_APP", "WEBVIEW_com.example.app", or use index from get_contexts)'
+  )
+};
+var switchContextTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { context } = args;
+    let targetContext = context;
+    if (/^\d+$/.test(context)) {
+      const contexts = await browser.getContexts();
+      const index = parseInt(context, 10) - 1;
+      if (index >= 0 && index < contexts.length) {
+        targetContext = contexts[index];
+      } else {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: Invalid context index ${context}. Available contexts: ${contexts.length}`
+            }
+          ]
+        };
+      }
+    }
+    await browser.switchContext(targetContext);
+    return {
+      content: [{ type: "text", text: `Switched to context: ${targetContext}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error switching context: ${e}` }]
+    };
+  }
+};
+
+// src/tools/device.tool.ts
+import { z as z17 } from "zod";
+var getDeviceInfoTool = async () => {
+  try {
+    const browser = getBrowser();
+    const capabilities = browser.capabilities;
+    const windowSize = await browser.getWindowSize();
+    const info = {
+      platformName: capabilities.platformName,
+      platformVersion: capabilities["appium:platformVersion"],
+      deviceName: capabilities["appium:deviceName"],
+      automationName: capabilities["appium:automationName"],
+      screenSize: `${windowSize.width}x${windowSize.height}`
+    };
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Device Info:
+${Object.entries(info).map(([key, value]) => `  ${key}: ${value}`).join("\n")}`
+        }
+      ]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error getting device info: ${e}` }]
+    };
+  }
+};
+var rotateDeviceToolArguments = {
+  orientation: z17.enum(["PORTRAIT", "LANDSCAPE"]).describe("Device orientation")
+};
+var rotateDeviceTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { orientation } = args;
+    await browser.setOrientation(orientation);
+    return {
+      content: [{ type: "text", text: `Device rotated to: ${orientation}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error rotating device: ${e}` }]
+    };
+  }
+};
+var getOrientationTool = async () => {
+  try {
+    const browser = getBrowser();
+    const orientation = await browser.getOrientation();
+    return {
+      content: [{ type: "text", text: `Current orientation: ${orientation}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error getting orientation: ${e}` }]
+    };
+  }
+};
+var lockDeviceTool = async () => {
+  try {
+    const browser = getBrowser();
+    await browser.lock();
+    return {
+      content: [{ type: "text", text: "Device locked" }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error locking device: ${e}` }]
+    };
+  }
+};
+var unlockDeviceTool = async () => {
+  try {
+    const browser = getBrowser();
+    await browser.unlock();
+    return {
+      content: [{ type: "text", text: "Device unlocked" }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error unlocking device: ${e}` }]
+    };
+  }
+};
+var isDeviceLockedTool = async () => {
+  try {
+    const browser = getBrowser();
+    const isLocked = await browser.isLocked();
+    return {
+      content: [{ type: "text", text: `Device is ${isLocked ? "locked" : "unlocked"}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error checking lock status: ${e}` }]
+    };
+  }
+};
+var shakeDeviceTool = async () => {
+  try {
+    const browser = getBrowser();
+    await browser.shake();
+    return {
+      content: [{ type: "text", text: "Device shaken" }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error shaking device: ${e}` }]
+    };
+  }
+};
+var sendKeysToolArguments = {
+  keys: z17.array(z17.string()).describe('Array of keys to send (e.g., ["h", "e", "l", "l", "o"])')
+};
+var sendKeysTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { keys } = args;
+    await browser.sendKeys(keys);
+    return {
+      content: [{ type: "text", text: `Sent keys: ${keys.join("")}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error sending keys: ${e}` }]
+    };
+  }
+};
+var pressKeyCodeToolArguments = {
+  keyCode: z17.number().describe("Android key code (e.g., 4 for BACK, 3 for HOME)")
+};
+var pressKeyCodeTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { keyCode } = args;
+    await browser.pressKeyCode(keyCode);
+    return {
+      content: [{ type: "text", text: `Pressed key code: ${keyCode}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error pressing key code: ${e}` }]
+    };
+  }
+};
+var hideKeyboardTool = async () => {
+  try {
+    const browser = getBrowser();
+    await browser.hideKeyboard();
+    return {
+      content: [{ type: "text", text: "Keyboard hidden" }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error hiding keyboard: ${e}` }]
+    };
+  }
+};
+var isKeyboardShownTool = async () => {
+  try {
+    const browser = getBrowser();
+    const isShown = await browser.isKeyboardShown();
+    return {
+      content: [{ type: "text", text: `Keyboard is ${isShown ? "shown" : "hidden"}` }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error checking keyboard status: ${e}` }]
+    };
+  }
+};
+var openNotificationsTool = async () => {
+  try {
+    const browser = getBrowser();
+    await browser.openNotifications();
+    return {
+      content: [{ type: "text", text: "Opened notifications panel" }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error opening notifications: ${e}` }]
+    };
+  }
+};
+var getGeolocationTool = async () => {
+  try {
+    const browser = getBrowser();
+    const location = await browser.getGeoLocation();
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Location:
+  Latitude: ${location.latitude}
+  Longitude: ${location.longitude}
+  Altitude: ${location.altitude || "N/A"}`
+        }
+      ]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error getting geolocation: ${e}` }]
+    };
+  }
+};
+var setGeolocationToolArguments = {
+  latitude: z17.number().min(-90).max(90).describe("Latitude coordinate"),
+  longitude: z17.number().min(-180).max(180).describe("Longitude coordinate"),
+  altitude: z17.number().optional().describe("Altitude in meters (optional)")
+};
+var setGeolocationTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { latitude, longitude, altitude } = args;
+    await browser.setGeoLocation({ latitude, longitude, altitude });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Geolocation set to:
+  Latitude: ${latitude}
+  Longitude: ${longitude}${altitude ? `
+  Altitude: ${altitude}m` : ""}`
+        }
+      ]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error setting geolocation: ${e}` }]
+    };
+  }
+};
+
+// src/server.ts
+console.log = (...args) => console.error("[LOG]", ...args);
+console.info = (...args) => console.error("[INFO]", ...args);
+console.warn = (...args) => console.error("[WARN]", ...args);
+console.debug = (...args) => console.error("[DEBUG]", ...args);
+var server = new McpServer({
+  name: "MCP WebdriverIO",
+  version: "1.4.0"
+}, {
+  capabilities: {
+    resources: {},
+    tools: {}
+  }
+});
+server.tool("start_browser", "starts a browser session and sets it to the current state", startBrowserToolArguments, startBrowserTool);
+server.tool("start_app_session", "starts a mobile app session (iOS/Android) via Appium", startAppToolArguments, startAppTool);
+server.tool("close_session", "closes or detaches from the current browser or app session", closeSessionToolArguments, closeSessionTool);
+server.tool("navigate", "navigates to a URL", navigateToolArguments, navigateTool);
+server.tool("get_visible_elements", "get a list of visible (in viewport & displayed) elements on the page, must prefer this to take_screenshot for interactions", getVisibleElementsToolArguments, getVisibleElementsTool);
+server.tool("get_accessibility", "gets accessibility tree snapshot with semantic information about page elements (roles, names, states)", {}, getAccessibilityTreeTool);
+server.tool("scroll_down", "scrolls the page down by specified pixels", scrollDownToolArguments, scrollDownTool);
+server.tool("scroll_up", "scrolls the page up by specified pixels", scrollUpToolArguments, scrollUpTool);
+server.tool("find_element", "finds an element", findElementToolArguments, findElementTool);
+server.tool("click_element", "clicks an element", clickToolArguments, clickTool);
+server.tool("click_via_text", "clicks an element", clickToolArguments, clickToolViaText);
+server.tool("set_value", "set value to an element, aka typing", setValueToolArguments, setValueTool);
+server.tool("get_element_text", "gets the text content of an element", getElementTextToolArguments, getElementTextTool);
+server.tool("is_displayed", "checks if an element is displayed", isDisplayedToolArguments, isDisplayedTool);
+server.tool("take_screenshot", "captures a screenshot of the current page", takeScreenshotToolArguments, takeScreenshotTool);
+server.tool("get_cookies", "gets all cookies or a specific cookie by name", getCookiesToolArguments, getCookiesTool);
+server.tool("set_cookie", "sets a cookie with specified name, value, and optional attributes", setCookieToolArguments, setCookieTool);
+server.tool("delete_cookies", "deletes all cookies or a specific cookie by name", deleteCookiesToolArguments, deleteCookiesTool);
+server.tool("tap_element", "taps an element by selector or coordinates (mobile)", tapElementToolArguments, tapElementTool);
+server.tool("swipe", "performs a swipe gesture in specified direction (mobile)", swipeToolArguments, swipeTool);
+server.tool("long_press", "performs a long press on element or coordinates (mobile)", longPressToolArguments, longPressTool);
+server.tool("drag_and_drop", "drags from one location to another (mobile)", dragAndDropToolArguments, dragAndDropTool);
+server.tool("get_app_state", "gets the state of an app (not installed, not running, background, foreground)", getAppStateToolArguments, getAppStateTool);
+server.tool("activate_app", "activates/brings an app to foreground", activateAppToolArguments, activateAppTool);
+server.tool("terminate_app", "terminates a running app", terminateAppToolArguments, terminateAppTool);
+server.tool("get_contexts", "lists available contexts (NATIVE_APP, WEBVIEW)", {}, getContextsTool);
+server.tool("get_current_context", "shows the currently active context", {}, getCurrentContextTool);
+server.tool("switch_context", "switches between native and webview contexts", switchContextToolArguments, switchContextTool);
+server.tool("get_device_info", "gets device information (platform, version, screen size)", {}, getDeviceInfoTool);
+server.tool("rotate_device", "rotates device to portrait or landscape orientation", rotateDeviceToolArguments, rotateDeviceTool);
+server.tool("get_orientation", "gets current device orientation", {}, getOrientationTool);
+server.tool("lock_device", "locks the device screen", {}, lockDeviceTool);
+server.tool("unlock_device", "unlocks the device screen", {}, unlockDeviceTool);
+server.tool("is_device_locked", "checks if device is locked", {}, isDeviceLockedTool);
+server.tool("shake_device", "shakes the device (iOS only)", {}, shakeDeviceTool);
+server.tool("send_keys", "sends keys to the app (Android only)", sendKeysToolArguments, sendKeysTool);
+server.tool("press_key_code", "presses an Android key code (Android only)", pressKeyCodeToolArguments, pressKeyCodeTool);
+server.tool("hide_keyboard", "hides the on-screen keyboard", {}, hideKeyboardTool);
+server.tool("is_keyboard_shown", "checks if keyboard is visible", {}, isKeyboardShownTool);
+server.tool("open_notifications", "opens the notifications panel (Android only)", {}, openNotificationsTool);
+server.tool("get_geolocation", "gets current device geolocation", {}, getGeolocationTool);
+server.tool("set_geolocation", "sets device geolocation (latitude, longitude, altitude)", setGeolocationToolArguments, setGeolocationTool);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("WebdriverIO MCP Server running on stdio");
+}
+main().catch((error) => {
+  console.error("Fatal error in main():", error);
+  process.exit(1);
+});
+//# sourceMappingURL=server.js.map