@wdio/mcp 1.6.0 → 2.0.0

package/lib/server.js

@@ -12,8 +12,9 @@ var startBrowserToolDefinition = {
   description: "starts a browser session and sets it to the current state",
   inputSchema: {
     headless: z.boolean().optional(),
-    windowWidth: z.number().min(400).max(3840).optional(),
-    windowHeight: z.number().min(400).max(2160).optional()
+    windowWidth: z.number().min(400).max(3840).optional().default(1920),
+    windowHeight: z.number().min(400).max(2160).optional().default(1080),
+    navigationUrl: z.string().optional().describe("URL to navigate to after starting the browser")
   }
 };
 var closeSessionToolDefinition = {
@@ -36,7 +37,12 @@ var getBrowser = () => {
   return browser;
 };
 getBrowser.__state = state;
-var startBrowserTool = async ({ headless = false, windowWidth = 1280, windowHeight = 1080 }) => {
+var startBrowserTool = async ({
+  headless = false,
+  windowWidth = 1920,
+  windowHeight = 1080,
+  navigationUrl
+}) => {
   const chromeArgs = [
     `--window-size=${windowWidth},${windowHeight}`,
     "--no-sandbox",
@@ -70,11 +76,15 @@ var startBrowserTool = async ({ headless = false, windowWidth = 1280, windowHeig
     capabilities: browser.capabilities,
     isAttached: false
   });
+  if (navigationUrl) {
+    await browser.url(navigationUrl);
+  }
   const modeText = headless ? "headless" : "headed";
+  const urlText = navigationUrl ? ` and navigated to ${navigationUrl}` : "";
   return {
     content: [{
       type: "text",
-      text: `Browser started in ${modeText} mode with sessionId: ${sessionId} (${windowWidth}x${windowHeight})`
+      text: `Browser started in ${modeText} mode with sessionId: ${sessionId} (${windowWidth}x${windowHeight})${urlText}`
     }]
   };
 };
@@ -136,15 +146,6 @@ var clickToolDefinition = {
     timeout: z3.number().optional().describe("Maximum time to wait for element in milliseconds")
   }
 };
-var clickViaTextToolDefinition = {
-  name: "click_via_text",
-  description: "clicks an element",
-  inputSchema: {
-    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();
@@ -163,7 +164,6 @@ var clickAction = async (selector, timeout, scrollToView = true) => {
   }
 };
 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";
@@ -197,137 +197,250 @@ var setValueTool = async ({ selector, value, scrollToView = true, timeout = defa
   }
 };
 
-// src/tools/find-element.tool.ts
+// src/tools/app-session.tool.ts
+import { remote as remote2 } from "webdriverio";
 import { z as z5 } from "zod";
-var defaultTimeout3 = 3e3;
-var findElementToolDefinition = {
-  name: "find_element",
-  description: "finds an element",
-  inputSchema: {
-    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")
+
+// 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;
   }
-};
-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}` }]
-    };
+  if (options.udid) {
+    capabilities["appium:udid"] = options.udid;
   }
-};
-
-// src/tools/get-element-text.tool.ts
-import { z as z6 } from "zod";
-var defaultTimeout4 = 3e3;
-var getElementTextToolDefinition = {
-  name: "get_element_text",
-  description: "gets the text content of an element",
-  inputSchema: {
-    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")
+  if (options.noReset !== void 0) {
+    capabilities["appium:noReset"] = options.noReset;
   }
-};
-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}` }]
-    };
+  if (options.fullReset !== void 0) {
+    capabilities["appium:fullReset"] = options.fullReset;
   }
-};
-
-// src/tools/is-displayed.tool.ts
-import { z as z7 } from "zod";
-var defaultTimeout5 = 3e3;
-var isDisplayedToolDefinition = {
-  name: "is_displayed",
-  description: "checks if an element is displayed",
-  inputSchema: {
-    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")
+  if (options.newCommandTimeout !== void 0) {
+    capabilities["appium:newCommandTimeout"] = options.newCommandTimeout;
   }
-};
-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}` }]
-    };
+  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", "newCommandTimeout"].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;
+  }
+  if (options.newCommandTimeout !== void 0) {
+    capabilities["appium:newCommandTimeout"] = options.newCommandTimeout;
+  }
+  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", "newCommandTimeout"].includes(
+      key
+    )) {
+      capabilities[`appium:${key}`] = value;
+    }
+  }
+  return capabilities;
+}
 
-// src/tools/scroll-down.tool.ts
-import { z as z8 } from "zod";
-var scrollDownToolDefinition = {
-  name: "scroll_down",
-  description: "scrolls the page down by specified pixels",
+// src/tools/app-session.tool.ts
+var startAppToolDefinition = {
+  name: "start_app_session",
+  description: "starts a mobile app session (iOS/Android) via Appium",
   inputSchema: {
-    pixels: z8.number().optional().default(500)
+    platform: z5.enum(["iOS", "Android"]).describe("Mobile platform"),
+    appPath: z5.string().optional().describe("Path to the app file (.app/.apk/.ipa). Required unless noReset=true (connecting to already-running app)"),
+    deviceName: z5.string().describe("Device/emulator/simulator name"),
+    platformVersion: z5.string().optional().describe('OS version (e.g., "17.0", "14")'),
+    automationName: z5.enum(["XCUITest", "UiAutomator2", "Espresso"]).optional().describe("Automation driver name"),
+    appiumHost: z5.string().optional().describe("Appium server hostname (overrides APPIUM_URL env var)"),
+    appiumPort: z5.number().optional().describe("Appium server port (overrides APPIUM_URL_PORT env var)"),
+    appiumPath: z5.string().optional().describe("Appium server path (overrides APPIUM_PATH env var)"),
+    autoGrantPermissions: z5.boolean().optional().describe("Auto-grant app permissions (default: true)"),
+    autoAcceptAlerts: z5.boolean().optional().describe("Auto-accept alerts (default: true)"),
+    autoDismissAlerts: z5.boolean().optional().describe('Auto-dismiss alerts (default: false, will override "autoAcceptAlerts" to undefined if set)'),
+    appWaitActivity: z5.string().optional().describe("Activity to wait for on launch (Android only)"),
+    udid: z5.string().optional().describe('Unique Device Identifier for iOS real device testing (e.g., "00008030-001234567890002E")'),
+    noReset: z5.boolean().optional().describe("Do not reset app state before session (preserves app data). Default: false"),
+    fullReset: z5.boolean().optional().describe("Uninstall app before/after session. Default: true. Set to false with noReset=true to preserve app state completely"),
+    newCommandTimeout: z5.number().min(0).optional().describe("How long (in seconds) Appium will wait for a new command before assuming the client has quit and ending the session. Default: 60. Set to 300 for 5 minutes, etc.")
+  }
+};
+var getState = () => {
+  const sharedState = getBrowser.__state;
+  if (!sharedState) {
+    throw new Error("Browser state not initialized");
   }
+  return sharedState;
 };
-var scrollDownTool = async ({ pixels = 500 }) => {
+var startAppTool = async (args) => {
   try {
-    const browser = getBrowser();
-    await browser.execute((scrollPixels) => {
-      window.scrollBy(0, scrollPixels);
-    }, pixels);
+    const {
+      platform,
+      appPath,
+      deviceName,
+      platformVersion,
+      automationName,
+      appiumHost,
+      appiumPort,
+      appiumPath,
+      autoGrantPermissions = true,
+      autoAcceptAlerts,
+      autoDismissAlerts,
+      appWaitActivity,
+      udid,
+      noReset,
+      fullReset,
+      newCommandTimeout
+    } = 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,
+      newCommandTimeout
+    }) : buildAndroidCapabilities(appPath, {
+      deviceName,
+      platformVersion,
+      automationName: automationName || "UiAutomator2",
+      autoGrantPermissions,
+      autoAcceptAlerts,
+      autoDismissAlerts,
+      appWaitActivity,
+      noReset,
+      fullReset,
+      newCommandTimeout
+    });
+    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: `Scrolled down ${pixels} pixels` }]
+      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 scrolling down: ${e}` }]
+      content: [{ type: "text", text: `Error starting app session: ${e}` }]
     };
   }
 };
 
-// src/tools/scroll-up.tool.ts
-import { z as z9 } from "zod";
-var scrollUpToolDefinition = {
-  name: "scroll_up",
-  description: "scrolls the page up by specified pixels",
+// src/tools/scroll.tool.ts
+import { z as z6 } from "zod";
+var scrollToolDefinition = {
+  name: "scroll",
+  description: "scrolls the page by specified pixels (browser only). For mobile, use the swipe tool.",
   inputSchema: {
-    pixels: z9.number().optional().default(500)
+    direction: z6.enum(["up", "down"]).describe("Scroll direction"),
+    pixels: z6.number().optional().default(500).describe("Number of pixels to scroll")
   }
 };
-var scrollUpTool = async ({ pixels = 500 }) => {
+var scrollTool = async ({ direction, pixels = 500 }) => {
   try {
     const browser = getBrowser();
-    await browser.execute((scrollPixels) => {
-      window.scrollBy(0, -scrollPixels);
-    }, pixels);
+    const state2 = getState();
+    const metadata = state2.sessionMetadata.get(state2.currentSession);
+    const sessionType = metadata?.type;
+    if (sessionType !== "browser") {
+      throw new Error("scroll only works in browser sessions. For mobile, use the swipe tool.");
+    }
+    const scrollAmount = direction === "down" ? pixels : -pixels;
+    await browser.execute((amount) => {
+      window.scrollBy(0, amount);
+    }, scrollAmount);
     return {
-      content: [{ type: "text", text: `Scrolled up ${pixels} pixels` }]
+      content: [{ type: "text", text: `Scrolled ${direction} ${pixels} pixels` }]
     };
   } catch (e) {
     return {
-      content: [{ type: "text", text: `Error scrolling up: ${e}` }]
+      content: [{ type: "text", text: `Error scrolling: ${e}` }]
     };
   }
 };
 
-// src/scripts/get-interactable-elements.ts
+// src/scripts/get-interactable-browser-elements.ts
 var elementsScript = (elementType = "interactable") => (function() {
   const interactableSelectors = [
     "a[href]",
@@ -494,7 +607,7 @@ var elementsScript = (elementType = "interactable") => (function() {
   }
   return getElements();
 })();
-var get_interactable_elements_default = elementsScript;
+var get_interactable_browser_elements_default = elementsScript;
 
 // src/locators/source-parsing.ts
 import { DOMParser } from "@xmldom/xmldom";
@@ -1097,7 +1210,7 @@ function generateAllElementLocators(sourceXML, options) {
   return ctx.results;
 }
 
-// src/utils/mobile-elements.ts
+// src/scripts/get-visible-mobile-elements.ts
 var LOCATOR_PRIORITY = [
   "accessibility-id",
   // Most stable, cross-platform
@@ -1185,7 +1298,7 @@ async function getMobileVisibleElements(browser, platform, options = {}) {
 
 // src/tools/get-visible-elements.tool.ts
 import { encode } from "@toon-format/toon";
-import { z as z10 } from "zod";
+import { z as z7 } from "zod";
 
 // src/utils/strip-undefined.ts
 function stripUndefined(obj) {
@@ -1202,20 +1315,20 @@ var getVisibleElementsToolDefinition = {
   name: "get_visible_elements",
   description: 'get a list of visible (in viewport & displayed) interactable elements on the page (buttons, links, inputs). Use elementType="visual" for images/SVGs. Must prefer this to take_screenshot for interactions',
   inputSchema: {
-    inViewportOnly: z10.boolean().optional().describe(
+    inViewportOnly: z7.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(
+    includeContainers: z7.boolean().optional().describe(
       "Include layout containers (ViewGroup, FrameLayout, ScrollView, etc). Default: false. Set to true to see all elements including layouts."
     ),
-    includeBounds: z10.boolean().optional().describe(
+    includeBounds: z7.boolean().optional().describe(
       "Include element bounds/coordinates (x, y, width, height). Default: false. Set to true for coordinate-based interactions or layout debugging."
     ),
-    elementType: z10.enum(["interactable", "visual", "all"]).optional().describe(
+    elementType: z7.enum(["interactable", "visual", "all"]).optional().describe(
       'Type of elements to return: "interactable" (default) for buttons/links/inputs, "visual" for images/SVGs, "all" for both.'
     ),
-    limit: z10.number().optional().describe("Maximum number of elements to return. Default: 0 (unlimited)."),
-    offset: z10.number().optional().describe("Number of elements to skip (for pagination). Default: 0.")
+    limit: z7.number().optional().describe("Maximum number of elements to return. Default: 0 (unlimited)."),
+    offset: z7.number().optional().describe("Number of elements to skip (for pagination). Default: 0.")
   }
 };
 var getVisibleElementsTool = async (args) => {
@@ -1234,7 +1347,7 @@ var getVisibleElementsTool = async (args) => {
       const platform = browser.isAndroid ? "android" : "ios";
       elements = await getMobileVisibleElements(browser, platform, { includeContainers, includeBounds });
     } else {
-      const raw = await browser.execute(get_interactable_elements_default, elementType);
+      const raw = await browser.execute(get_interactable_browser_elements_default, elementType);
       elements = stripUndefinedFromArray(raw);
     }
     if (inViewportOnly) {
@@ -1264,29 +1377,56 @@ var getVisibleElementsTool = async (args) => {
 };
 
 // src/tools/take-screenshot.tool.ts
-import { z as z11 } from "zod";
+import { z as z8 } from "zod";
+import sharp from "sharp";
+var MAX_DIMENSION = 2e3;
+var MAX_FILE_SIZE_BYTES = 1024 * 1024;
 var takeScreenshotToolDefinition = {
   name: "take_screenshot",
   description: "captures a screenshot of the current page",
   inputSchema: {
-    outputPath: z11.string().optional().describe("Optional path where to save the screenshot. If not provided, returns base64 data.")
+    outputPath: z8.string().optional().describe("Optional path where to save the screenshot. If not provided, returns base64 data.")
   }
 };
+async function processScreenshot(screenshotBase64) {
+  const inputBuffer = Buffer.from(screenshotBase64, "base64");
+  let image = sharp(inputBuffer);
+  const metadata = await image.metadata();
+  const width = metadata.width ?? 0;
+  const height = metadata.height ?? 0;
+  if (width > MAX_DIMENSION || height > MAX_DIMENSION) {
+    const resizeOptions = width > height ? { width: MAX_DIMENSION } : { height: MAX_DIMENSION };
+    image = image.resize(resizeOptions);
+  }
+  let outputBuffer = await image.png({ compressionLevel: 9 }).toBuffer();
+  if (outputBuffer.length > MAX_FILE_SIZE_BYTES) {
+    let quality = 90;
+    while (quality >= 10 && outputBuffer.length > MAX_FILE_SIZE_BYTES) {
+      outputBuffer = await image.jpeg({ quality, mozjpeg: true }).toBuffer();
+      quality -= 10;
+    }
+    return { data: outputBuffer, mimeType: "image/jpeg" };
+  }
+  return { data: outputBuffer, mimeType: "image/png" };
+}
 var takeScreenshotTool = async ({ outputPath }) => {
   try {
     const browser = getBrowser();
     const screenshot = await browser.takeScreenshot();
+    const { data, mimeType } = await processScreenshot(screenshot);
     if (outputPath) {
       const fs = await import("fs");
-      await fs.promises.writeFile(outputPath, screenshot, "base64");
+      await fs.promises.writeFile(outputPath, data);
+      const sizeKB2 = (data.length / 1024).toFixed(1);
       return {
-        content: [{ type: "text", text: `Screenshot saved to ${outputPath}` }]
+        content: [{ type: "text", text: `Screenshot saved to ${outputPath} (${sizeKB2}KB, ${mimeType})` }]
       };
     }
+    const sizeKB = (data.length / 1024).toFixed(1);
     return {
       content: [
-        { type: "text", text: "Screenshot captured as base64:" },
-        { type: "image", data: screenshot.toString(), mimeType: "image/png" }
+        { type: "text", text: `Screenshot captured (${sizeKB}KB, ${mimeType}):` },
+        { type: "image", data: data.toString("base64"), mimeType }
       ]
     };
   } catch (e) {
@@ -1297,12 +1437,12 @@ var takeScreenshotTool = async ({ outputPath }) => {
 };
 
 // src/tools/cookies.tool.ts
-import { z as z12 } from "zod";
+import { z as z9 } from "zod";
 var getCookiesToolDefinition = {
   name: "get_cookies",
   description: "gets all cookies or a specific cookie by name",
   inputSchema: {
-    name: z12.string().optional().describe("Optional cookie name to retrieve a specific cookie. If not provided, returns all cookies")
+    name: z9.string().optional().describe("Optional cookie name to retrieve a specific cookie. If not provided, returns all cookies")
   }
 };
 var getCookiesTool = async ({ name }) => {
@@ -1338,14 +1478,14 @@ var setCookieToolDefinition = {
   name: "set_cookie",
   description: "sets a cookie with specified name, value, and optional attributes",
   inputSchema: {
-    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")
+    name: z9.string().describe("Cookie name"),
+    value: z9.string().describe("Cookie value"),
+    domain: z9.string().optional().describe("Cookie domain (defaults to current domain)"),
+    path: z9.string().optional().describe('Cookie path (defaults to "/")'),
+    expiry: z9.number().optional().describe("Expiry date as Unix timestamp in seconds"),
+    httpOnly: z9.boolean().optional().describe("HttpOnly flag"),
+    secure: z9.boolean().optional().describe("Secure flag"),
+    sameSite: z9.enum(["strict", "lax", "none"]).optional().describe("SameSite attribute")
   }
 };
 var setCookieTool = async ({
@@ -1353,23 +1493,14 @@ var setCookieTool = async ({
   value,
   domain,
   path = "/",
-  expires,
+  expiry,
   httpOnly,
   secure,
   sameSite
 }) => {
   try {
     const browser = getBrowser();
-    const cookie = {
-      name,
-      value,
-      path,
-      domain,
-      expiry: expires,
-      httpOnly,
-      secure,
-      sameSite
-    };
+    const cookie = { name, value, path, domain, expiry, httpOnly, secure, sameSite };
     await browser.setCookies(cookie);
     return {
       content: [{ type: "text", text: `Cookie "${name}" set successfully` }]
@@ -1384,7 +1515,7 @@ var deleteCookiesToolDefinition = {
   name: "delete_cookies",
   description: "deletes all cookies or a specific cookie by name",
   inputSchema: {
-    name: z12.string().optional().describe("Optional cookie name to delete a specific cookie. If not provided, deletes all cookies")
+    name: z9.string().optional().describe("Optional cookie name to delete a specific cookie. If not provided, deletes all cookies")
   }
 };
 var deleteCookiesTool = async ({ name }) => {
@@ -1409,15 +1540,15 @@ var deleteCookiesTool = async ({ name }) => {
 
 // src/tools/get-accessibility-tree.tool.ts
 import { encode as encode2 } from "@toon-format/toon";
-import { z as z13 } from "zod";
+import { z as z10 } from "zod";
 var getAccessibilityToolDefinition = {
   name: "get_accessibility",
   description: "gets accessibility tree snapshot with semantic information about page elements (roles, names, states). Browser-only - use when get_visible_elements does not return expected elements.",
   inputSchema: {
-    limit: z13.number().optional().describe("Maximum number of nodes to return. Default: 100. Use 0 for unlimited."),
-    offset: z13.number().optional().describe("Number of nodes to skip (for pagination). Default: 0."),
-    roles: z13.array(z13.string()).optional().describe('Filter to specific roles (e.g., ["button", "link", "textbox"]). Default: all roles.'),
-    namedOnly: z13.boolean().optional().describe("Only return nodes with a name/label. Default: true. Filters out anonymous containers.")
+    limit: z10.number().optional().describe("Maximum number of nodes to return. Default: 100. Use 0 for unlimited."),
+    offset: z10.number().optional().describe("Number of nodes to skip (for pagination). Default: 0."),
+    roles: z10.array(z10.string()).optional().describe('Filter to specific roles (e.g., ["button", "link", "textbox"]). Default: all roles.'),
+    namedOnly: z10.boolean().optional().describe("Only return nodes with a name/label. Default: true. Filters out anonymous containers.")
   }
 };
 function flattenAccessibilityTree(node, result = []) {
@@ -1518,215 +1649,15 @@ var getAccessibilityTreeTool = async (args) => {
   }
 };
 
-// src/tools/app-session.tool.ts
-import { remote as remote2 } from "webdriverio";
-import { z as z14 } 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 startAppToolDefinition = {
-  name: "start_app_session",
-  description: "starts a mobile app session (iOS/Android) via Appium",
-  inputSchema: {
-    platform: z14.enum(["iOS", "Android"]).describe("Mobile platform"),
-    appPath: z14.string().optional().describe("Path to the app file (.app/.apk/.ipa). Required unless noReset=true (connecting to already-running app)"),
-    deviceName: z14.string().describe("Device/emulator/simulator name"),
-    platformVersion: z14.string().optional().describe('OS version (e.g., "17.0", "14")'),
-    automationName: z14.enum(["XCUITest", "UiAutomator2", "Espresso"]).optional().describe("Automation driver name"),
-    appiumHost: z14.string().optional().describe("Appium server hostname (overrides APPIUM_URL env var)"),
-    appiumPort: z14.number().optional().describe("Appium server port (overrides APPIUM_URL_PORT env var)"),
-    appiumPath: z14.string().optional().describe("Appium server path (overrides APPIUM_PATH env var)"),
-    autoGrantPermissions: z14.boolean().optional().describe("Auto-grant app permissions (default: true)"),
-    autoAcceptAlerts: z14.boolean().optional().describe("Auto-accept alerts (default: true)"),
-    autoDismissAlerts: z14.boolean().optional().describe('Auto-dismiss alerts (default: false, will override "autoAcceptAlerts" to undefined if set)'),
-    appWaitActivity: z14.string().optional().describe("Activity to wait for on launch (Android only)"),
-    udid: z14.string().optional().describe('Unique Device Identifier for iOS real device testing (e.g., "00008030-001234567890002E")'),
-    noReset: z14.boolean().optional().describe("Do not reset app state before session (preserves app data). Default: false"),
-    fullReset: z14.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 z15 } from "zod";
-var tapElementToolDefinition = {
-  name: "tap_element",
-  description: "taps an element by selector or coordinates (mobile)",
-  inputSchema: {
-    selector: z15.string().optional().describe("Element selector (CSS, XPath, accessibility ID, or UiAutomator)"),
-    x: z15.number().optional().describe("X coordinate for tap (if no selector provided)"),
-    y: z15.number().optional().describe("Y coordinate for tap (if no selector provided)")
+// src/tools/gestures.tool.ts
+import { z as z11 } from "zod";
+var tapElementToolDefinition = {
+  name: "tap_element",
+  description: "taps an element by selector or screen coordinates (mobile)",
+  inputSchema: {
+    selector: z11.string().optional().describe("Element selector (CSS, XPath, accessibility ID, or UiAutomator)"),
+    x: z11.number().optional().describe("X coordinate for screen tap (if no selector provided)"),
+    y: z11.number().optional().describe("Y coordinate for screen tap (if no selector provided)")
   }
 };
 var tapElementTool = async (args) => {
@@ -1740,11 +1671,7 @@ var tapElementTool = async (args) => {
         content: [{ type: "text", text: `Tapped element: ${selector}` }]
       };
     } else if (x !== void 0 && y !== void 0) {
-      await browser.touchAction({
-        action: "tap",
-        x,
-        y
-      });
+      await browser.tap({ x, y });
       return {
         content: [{ type: "text", text: `Tapped at coordinates: (${x}, ${y})` }]
       };
@@ -1754,7 +1681,7 @@ var tapElementTool = async (args) => {
     };
   } catch (e) {
     return {
-      content: [{ type: "text", text: `Error tapping element: ${e}` }]
+      content: [{ type: "text", text: `Error tapping: ${e}` }]
     };
   }
 };
@@ -1762,52 +1689,29 @@ var swipeToolDefinition = {
   name: "swipe",
   description: "performs a swipe gesture in specified direction (mobile)",
   inputSchema: {
-    direction: z15.enum(["up", "down", "left", "right"]).describe("Swipe direction"),
-    duration: z15.number().min(100).max(5e3).optional().describe("Swipe duration in milliseconds (default: 500)"),
-    startX: z15.number().optional().describe("Start X coordinate (optional, uses screen center)"),
-    startY: z15.number().optional().describe("Start Y coordinate (optional, uses screen center)"),
-    distance: z15.number().optional().describe("Swipe distance in pixels (optional, uses percentage of screen)")
+    direction: z11.enum(["up", "down", "left", "right"]).describe("Swipe direction"),
+    duration: z11.number().min(100).max(5e3).optional().describe("Swipe duration in milliseconds (default: 500)"),
+    percent: z11.number().min(0).max(1).optional().describe("Percentage of screen to swipe (0-1, default: 0.5 for up/down, 0.95 for left/right)")
   }
 };
+var contentToFingerDirection = {
+  up: "down",
+  down: "up",
+  left: "right",
+  right: "left"
+};
 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: {} }
-    ]);
+    const { direction, duration, percent } = args;
+    const isVertical = direction === "up" || direction === "down";
+    const defaultPercent = isVertical ? 0.5 : 0.95;
+    const effectivePercent = percent ?? defaultPercent;
+    const effectiveDuration = duration ?? 500;
+    const fingerDirection = contentToFingerDirection[direction];
+    await browser.swipe({ direction: fingerDirection, duration: effectiveDuration, percent: effectivePercent });
     return {
-      content: [
-        {
-          type: "text",
-          text: `Swiped ${direction} from (${Math.round(centerX)}, ${Math.round(centerY)}) to (${Math.round(endX)}, ${Math.round(endY)}) over ${duration}ms`
-        }
-      ]
+      content: [{ type: "text", text: `Swiped ${direction}` }]
     };
   } catch (e) {
     return {
@@ -1815,126 +1719,51 @@ var swipeTool = async (args) => {
     };
   }
 };
-var longPressToolDefinition = {
-  name: "long_press",
-  description: "performs a long press on element or coordinates (mobile)",
-  inputSchema: {
-    selector: z15.string().optional().describe("Element selector (CSS, XPath, accessibility ID, or UiAutomator)"),
-    x: z15.number().optional().describe("X coordinate for long press (if no selector provided)"),
-    y: z15.number().optional().describe("Y coordinate for long press (if no selector provided)"),
-    duration: z15.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 dragAndDropToolDefinition = {
   name: "drag_and_drop",
-  description: "drags from one location to another (mobile)",
+  description: "drags an element to another element or coordinates (mobile)",
   inputSchema: {
-    fromSelector: z15.string().optional().describe("Source element selector"),
-    fromX: z15.number().optional().describe("Source X coordinate"),
-    fromY: z15.number().optional().describe("Source Y coordinate"),
-    toSelector: z15.string().optional().describe("Target element selector"),
-    toX: z15.number().optional().describe("Target X coordinate"),
-    toY: z15.number().optional().describe("Target Y coordinate"),
-    duration: z15.number().min(100).max(5e3).optional().describe("Drag duration in milliseconds (default: 500)")
+    sourceSelector: z11.string().describe("Source element selector to drag"),
+    targetSelector: z11.string().optional().describe("Target element selector to drop onto"),
+    x: z11.number().optional().describe("Target X offset (if no targetSelector)"),
+    y: z11.number().optional().describe("Target Y offset (if no targetSelector)"),
+    duration: z11.number().min(100).max(5e3).optional().describe("Drag duration in milliseconds")
   }
 };
 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 {
+    const { sourceSelector, targetSelector, x, y, duration } = args;
+    const sourceElement = await browser.$(sourceSelector);
+    if (targetSelector) {
+      const targetElement = await browser.$(targetSelector);
+      await sourceElement.dragAndDrop(targetElement, { duration });
       return {
-        content: [{ type: "text", text: "Error: Must provide either fromSelector or fromX,fromY coordinates" }]
+        content: [{ type: "text", text: `Dragged ${sourceSelector} to ${targetSelector}` }]
       };
-    }
-    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 {
+    } else if (x !== void 0 && y !== void 0) {
+      await sourceElement.dragAndDrop({ x, y }, { duration });
       return {
-        content: [{ type: "text", text: "Error: Must provide either toSelector or toX,toY coordinates" }]
+        content: [{ type: "text", text: `Dragged ${sourceSelector} by (${x}, ${y})` }]
       };
     }
-    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`
-        }
-      ]
+      content: [{ type: "text", text: "Error: Must provide either targetSelector or x,y coordinates" }]
     };
   } catch (e) {
     return {
-      content: [{ type: "text", text: `Error dragging and dropping: ${e}` }]
+      content: [{ type: "text", text: `Error dragging: ${e}` }]
     };
   }
 };
 
 // src/tools/app-actions.tool.ts
-import { z as z16 } from "zod";
+import { z as z12 } from "zod";
 var getAppStateToolDefinition = {
   name: "get_app_state",
   description: "gets the state of an app (not installed, not running, background, foreground)",
   inputSchema: {
-    bundleId: z16.string().describe("App bundle ID (e.g., com.example.app)")
+    bundleId: z12.string().describe("App bundle ID (e.g., com.example.app)")
   }
 };
 var getAppStateTool = async (args) => {
@@ -1964,53 +1793,9 @@ var getAppStateTool = async (args) => {
     };
   }
 };
-var activateAppToolDefinition = {
-  name: "activate_app",
-  description: "activates/brings an app to foreground",
-  inputSchema: {
-    bundleId: z16.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 terminateAppToolDefinition = {
-  name: "terminate_app",
-  description: "terminates a running app",
-  inputSchema: {
-    bundleId: z16.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 z17 } from "zod";
+import { z as z13 } from "zod";
 var getContextsToolDefinition = {
   name: "get_contexts",
   description: "lists available contexts (NATIVE_APP, WEBVIEW)",
@@ -2025,7 +1810,7 @@ var switchContextToolDefinition = {
   name: "switch_context",
   description: "switches between native and webview contexts",
   inputSchema: {
-    context: z17.string().describe(
+    context: z13.string().describe(
       'Context name to switch to (e.g., "NATIVE_APP", "WEBVIEW_com.example.app", or use index from get_contexts)'
     )
   }
@@ -2095,52 +1880,12 @@ var switchContextTool = async (args) => {
 };
 
 // src/tools/device.tool.ts
-import { z as z18 } from "zod";
-var getDeviceInfoToolDefinition = {
-  name: "get_device_info",
-  description: "gets device information (platform, version, screen size)",
-  inputSchema: {}
-};
-var getOrientationToolDefinition = {
-  name: "get_orientation",
-  description: "gets current device orientation",
-  inputSchema: {}
-};
-var lockDeviceToolDefinition = {
-  name: "lock_device",
-  description: "locks the device screen",
-  inputSchema: {}
-};
-var unlockDeviceToolDefinition = {
-  name: "unlock_device",
-  description: "unlocks the device screen",
-  inputSchema: {}
-};
-var isDeviceLockedToolDefinition = {
-  name: "is_device_locked",
-  description: "checks if device is locked",
-  inputSchema: {}
-};
-var shakeDeviceToolDefinition = {
-  name: "shake_device",
-  description: "shakes the device (iOS only)",
-  inputSchema: {}
-};
+import { z as z14 } from "zod";
 var hideKeyboardToolDefinition = {
   name: "hide_keyboard",
   description: "hides the on-screen keyboard",
   inputSchema: {}
 };
-var isKeyboardShownToolDefinition = {
-  name: "is_keyboard_shown",
-  description: "checks if keyboard is visible",
-  inputSchema: {}
-};
-var openNotificationsToolDefinition = {
-  name: "open_notifications",
-  description: "opens the notifications panel (Android only)",
-  inputSchema: {}
-};
 var getGeolocationToolDefinition = {
   name: "get_geolocation",
   description: "gets current device geolocation",
@@ -2150,57 +1895,16 @@ var rotateDeviceToolDefinition = {
   name: "rotate_device",
   description: "rotates device to portrait or landscape orientation",
   inputSchema: {
-    orientation: z18.enum(["PORTRAIT", "LANDSCAPE"]).describe("Device orientation")
-  }
-};
-var sendKeysToolDefinition = {
-  name: "send_keys",
-  description: "sends keys to the app (Android only)",
-  inputSchema: {
-    keys: z18.array(z18.string()).describe('Array of keys to send (e.g., ["h", "e", "l", "l", "o"])')
-  }
-};
-var pressKeyCodeToolDefinition = {
-  name: "press_key_code",
-  description: "presses an Android key code (Android only)",
-  inputSchema: {
-    keyCode: z18.number().describe("Android key code (e.g., 4 for BACK, 3 for HOME)")
+    orientation: z14.enum(["PORTRAIT", "LANDSCAPE"]).describe("Device orientation")
   }
 };
 var setGeolocationToolDefinition = {
   name: "set_geolocation",
   description: "sets device geolocation (latitude, longitude, altitude)",
   inputSchema: {
-    latitude: z18.number().min(-90).max(90).describe("Latitude coordinate"),
-    longitude: z18.number().min(-180).max(180).describe("Longitude coordinate"),
-    altitude: z18.number().optional().describe("Altitude in meters (optional)")
-  }
-};
-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}` }]
-    };
+    latitude: z14.number().min(-90).max(90).describe("Latitude coordinate"),
+    longitude: z14.number().min(-180).max(180).describe("Longitude coordinate"),
+    altitude: z14.number().optional().describe("Altitude in meters (optional)")
   }
 };
 var rotateDeviceTool = async (args) => {
@@ -2217,99 +1921,6 @@ var rotateDeviceTool = async (args) => {
     };
   }
 };
-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 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 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();
@@ -2323,32 +1934,6 @@ var hideKeyboardTool = async () => {
     };
   }
 };
-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();
@@ -2393,6 +1978,69 @@ var setGeolocationTool = async (args) => {
   }
 };
 
+// src/tools/execute-script.tool.ts
+import { z as z15 } from "zod";
+var executeScriptToolDefinition = {
+  name: "execute_script",
+  description: `Executes JavaScript in browser or mobile commands via Appium.
+
+**Browser:** Runs JavaScript in page context. Use 'return' to get values back.
+  - Example: execute_script({ script: "return document.title" })
+  - Example: execute_script({ script: "return window.scrollY" })
+  - Example: execute_script({ script: "arguments[0].click()", args: ["#myButton"] })
+
+**Mobile (Appium):** Executes mobile-specific commands using 'mobile: <command>' syntax.
+  - Press key (Android): execute_script({ script: "mobile: pressKey", args: [{ keycode: 4 }] }) // BACK=4, HOME=3
+  - Activate app: execute_script({ script: "mobile: activateApp", args: [{ appId: "com.example" }] })
+  - Terminate app: execute_script({ script: "mobile: terminateApp", args: [{ appId: "com.example" }] })
+  - Deep link: execute_script({ script: "mobile: deepLink", args: [{ url: "myapp://screen", package: "com.example" }] })
+  - Shell command (Android): execute_script({ script: "mobile: shell", args: [{ command: "dumpsys", args: ["battery"] }] })`,
+  inputSchema: {
+    script: z15.string().describe('JavaScript code (browser) or mobile command string like "mobile: pressKey" (Appium)'),
+    args: z15.array(z15.any()).optional().describe("Arguments to pass to the script. For browser: element selectors or values. For mobile commands: command-specific parameters as objects.")
+  }
+};
+var executeScriptTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { script, args: scriptArgs = [] } = args;
+    const resolvedArgs = await Promise.all(
+      scriptArgs.map(async (arg) => {
+        if (typeof arg === "string" && !script.startsWith("mobile:")) {
+          try {
+            const element = await browser.$(arg);
+            if (await element.isExisting()) {
+              return element;
+            }
+          } catch {
+          }
+        }
+        return arg;
+      })
+    );
+    const result = await browser.execute(script, ...resolvedArgs);
+    let resultText;
+    if (result === void 0 || result === null) {
+      resultText = "Script executed successfully (no return value)";
+    } else if (typeof result === "object") {
+      try {
+        resultText = `Result: ${JSON.stringify(result, null, 2)}`;
+      } catch {
+        resultText = `Result: ${String(result)}`;
+      }
+    } else {
+      resultText = `Result: ${result}`;
+    }
+    return {
+      content: [{ type: "text", text: resultText }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error executing script: ${e}` }]
+    };
+  }
+};
+
 // package.json
 var package_default = {
   name: "@wdio/mcp",
@@ -2401,7 +2049,7 @@ var package_default = {
     type: "git",
     url: "git://github.com/webdriverio/mcp.git"
   },
-  version: "1.5.1",
+  version: "1.6.1",
   description: "MCP server with WebdriverIO for browser and mobile app automation (iOS/Android via Appium)",
   main: "./lib/server.js",
   module: "./lib/server.js",
@@ -2433,6 +2081,7 @@ var package_default = {
     "@wdio/protocols": "^9.16.2",
     "@xmldom/xmldom": "^0.8.11",
     "puppeteer-core": "^24.35.0",
+    sharp: "^0.34.5",
     webdriverio: "9.23",
     zod: "^4.3.5"
   },
@@ -2480,42 +2129,25 @@ registerTool(closeSessionToolDefinition, closeSessionTool);
 registerTool(navigateToolDefinition, navigateTool);
 registerTool(getVisibleElementsToolDefinition, getVisibleElementsTool);
 registerTool(getAccessibilityToolDefinition, getAccessibilityTreeTool);
-registerTool(scrollDownToolDefinition, scrollDownTool);
-registerTool(scrollUpToolDefinition, scrollUpTool);
-registerTool(findElementToolDefinition, findElementTool);
+registerTool(scrollToolDefinition, scrollTool);
 registerTool(clickToolDefinition, clickTool);
-registerTool(clickViaTextToolDefinition, clickToolViaText);
 registerTool(setValueToolDefinition, setValueTool);
-registerTool(getElementTextToolDefinition, getElementTextTool);
-registerTool(isDisplayedToolDefinition, isDisplayedTool);
 registerTool(takeScreenshotToolDefinition, takeScreenshotTool);
 registerTool(getCookiesToolDefinition, getCookiesTool);
 registerTool(setCookieToolDefinition, setCookieTool);
 registerTool(deleteCookiesToolDefinition, deleteCookiesTool);
 registerTool(tapElementToolDefinition, tapElementTool);
 registerTool(swipeToolDefinition, swipeTool);
-registerTool(longPressToolDefinition, longPressTool);
 registerTool(dragAndDropToolDefinition, dragAndDropTool);
 registerTool(getAppStateToolDefinition, getAppStateTool);
-registerTool(activateAppToolDefinition, activateAppTool);
-registerTool(terminateAppToolDefinition, terminateAppTool);
 registerTool(getContextsToolDefinition, getContextsTool);
 registerTool(getCurrentContextToolDefinition, getCurrentContextTool);
 registerTool(switchContextToolDefinition, switchContextTool);
-registerTool(getDeviceInfoToolDefinition, getDeviceInfoTool);
 registerTool(rotateDeviceToolDefinition, rotateDeviceTool);
-registerTool(getOrientationToolDefinition, getOrientationTool);
-registerTool(lockDeviceToolDefinition, lockDeviceTool);
-registerTool(unlockDeviceToolDefinition, unlockDeviceTool);
-registerTool(isDeviceLockedToolDefinition, isDeviceLockedTool);
-registerTool(shakeDeviceToolDefinition, shakeDeviceTool);
-registerTool(sendKeysToolDefinition, sendKeysTool);
-registerTool(pressKeyCodeToolDefinition, pressKeyCodeTool);
 registerTool(hideKeyboardToolDefinition, hideKeyboardTool);
-registerTool(isKeyboardShownToolDefinition, isKeyboardShownTool);
-registerTool(openNotificationsToolDefinition, openNotificationsTool);
 registerTool(getGeolocationToolDefinition, getGeolocationTool);
 registerTool(setGeolocationToolDefinition, setGeolocationTool);
+registerTool(executeScriptToolDefinition, executeScriptTool);
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);