@wdio/mcp 2.5.3 → 3.1.0

package/lib/server.js

@@ -1,4 +1,41 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/session/state.ts
+var state_exports = {};
+__export(state_exports, {
+  getBrowser: () => getBrowser,
+  getState: () => getState
+});
+function getBrowser() {
+  const browser = state.browsers.get(state.currentSession);
+  if (!browser) {
+    throw new Error("No active browser session");
+  }
+  return browser;
+}
+function getState() {
+  return state;
+}
+var state;
+var init_state = __esm({
+  "src/session/state.ts"() {
+    state = {
+      browsers: /* @__PURE__ */ new Map(),
+      currentSession: null,
+      sessionMetadata: /* @__PURE__ */ new Map(),
+      sessionHistory: /* @__PURE__ */ new Map()
+    };
+  }
+});
 
 // package.json
 var package_default = {
@@ -9,7 +46,7 @@ var package_default = {
     type: "git",
     url: "git://github.com/webdriverio/mcp.git"
   },
-  version: "2.5.2",
+  version: "3.0.0",
   description: "MCP server with WebdriverIO for browser and mobile app automation (iOS/Android via Appium)",
   main: "./lib/server.js",
   module: "./lib/server.js",
@@ -40,263 +77,57 @@ var package_default = {
     prebundle: "rimraf lib --glob ./*.tgz",
     bundle: "tsup && shx chmod +x lib/server.js",
     postbundle: "npm pack",
-    lint: "eslint src/ --fix && tsc --noEmit",
-    "lint:tests": "eslint tests/ --fix && tsc -p tsconfig.test.json --noEmit",
+    lint: "eslint src/ tests/ --fix && tsc --noEmit",
     start: "node lib/server.js",
     dev: "tsx --watch src/server.ts",
     prepare: "husky",
     test: "vitest run"
   },
   dependencies: {
-    "@modelcontextprotocol/sdk": "1.27",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "@toon-format/toon": "^2.1.0",
-    "@wdio/protocols": "^9.16.2",
-    "@xmldom/xmldom": "^0.8.11",
-    "puppeteer-core": "^24.35.0",
+    "@wdio/protocols": "^9.27.0",
+    "@xmldom/xmldom": "^0.8.12",
+    "puppeteer-core": "^24.40.0",
     sharp: "^0.34.5",
-    webdriverio: "9.24",
+    webdriverio: "^9.27.0",
     xpath: "^0.0.34",
-    zod: "^4.3.5"
+    zod: "^4.3.6"
   },
   devDependencies: {
-    "@release-it/conventional-changelog": "^10.0.4",
-    "@types/node": "^20.11.0",
+    "@release-it/conventional-changelog": "^10.0.6",
+    "@types/node": "^20.19.37",
     "@wdio/eslint": "^0.1.3",
-    "@wdio/types": "^9.20.0",
-    eslint: "^9.39.2",
-    "happy-dom": "^20.7.0",
+    "@wdio/types": "^9.27.0",
+    eslint: "^9.39.4",
+    "happy-dom": "^20.8.9",
     husky: "^9.1.7",
-    "release-it": "^19.2.3",
-    rimraf: "^6.1.2",
+    "release-it": "^19.2.4",
+    rimraf: "^6.1.3",
     shx: "^0.4.0",
     tsup: "^8.5.1",
     tsx: "^4.21.0",
-    typescript: "5.9",
-    vitest: "^4.0.18"
+    typescript: "~5.9.3",
+    vitest: "^4.1.2"
   },
   packageManager: "pnpm@10.32.1"
 };
 
 // src/server.ts
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// src/tools/browser.tool.ts
-import { remote } from "webdriverio";
-import { z } from "zod";
-var supportedBrowsers = ["chrome", "firefox", "edge", "safari"];
-var browserSchema = z.enum(supportedBrowsers).default("chrome");
-var startBrowserToolDefinition = {
-  name: "start_browser",
-  description: "starts a browser session (Chrome, Firefox, Edge, Safari) and sets it to the current state. Prefer headless: true unless the user explicitly asks to see the browser.",
-  inputSchema: {
-    browser: browserSchema.describe("Browser to launch: chrome, firefox, edge, safari (default: chrome)"),
-    headless: z.boolean().optional().default(true),
-    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"),
-    capabilities: z.record(z.string(), z.unknown()).optional().describe("Additional W3C capabilities to merge with defaults (e.g. goog:chromeOptions args/extensions/prefs)")
-  }
-};
-var closeSessionToolDefinition = {
-  name: "close_session",
-  description: "closes or detaches from the current browser or app session",
-  inputSchema: {
-    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(),
-  sessionHistory: /* @__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 ({
-  browser = "chrome",
-  headless = true,
-  windowWidth = 1920,
-  windowHeight = 1080,
-  navigationUrl,
-  capabilities: userCapabilities = {}
-}) => {
-  const browserDisplayNames = {
-    chrome: "Chrome",
-    firefox: "Firefox",
-    edge: "Edge",
-    safari: "Safari"
-  };
-  const selectedBrowser = browser;
-  const headlessSupported = selectedBrowser !== "safari";
-  const effectiveHeadless = headless && headlessSupported;
-  const chromiumArgs = [
-    `--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 (effectiveHeadless) {
-    chromiumArgs.push("--headless=new");
-    chromiumArgs.push("--disable-gpu");
-    chromiumArgs.push("--disable-dev-shm-usage");
-  }
-  const firefoxArgs = [];
-  if (effectiveHeadless && selectedBrowser === "firefox") {
-    firefoxArgs.push("-headless");
-  }
-  const capabilities = {
-    acceptInsecureCerts: true
-  };
-  switch (selectedBrowser) {
-    case "chrome":
-      capabilities.browserName = "chrome";
-      capabilities["goog:chromeOptions"] = { args: chromiumArgs };
-      break;
-    case "edge":
-      capabilities.browserName = "msedge";
-      capabilities["ms:edgeOptions"] = { args: chromiumArgs };
-      break;
-    case "firefox":
-      capabilities.browserName = "firefox";
-      if (firefoxArgs.length > 0) {
-        capabilities["moz:firefoxOptions"] = { args: firefoxArgs };
-      }
-      break;
-    case "safari":
-      capabilities.browserName = "safari";
-      break;
-  }
-  const mergeCapabilityOptions = (defaultOptions, customOptions) => {
-    if (!defaultOptions || typeof defaultOptions !== "object" || !customOptions || typeof customOptions !== "object") {
-      return customOptions ?? defaultOptions;
-    }
-    const defaultRecord = defaultOptions;
-    const customRecord = customOptions;
-    const merged = { ...defaultRecord, ...customRecord };
-    if (Array.isArray(defaultRecord.args) || Array.isArray(customRecord.args)) {
-      merged.args = [
-        ...Array.isArray(defaultRecord.args) ? defaultRecord.args : [],
-        ...Array.isArray(customRecord.args) ? customRecord.args : []
-      ];
-    }
-    return merged;
-  };
-  const mergedCapabilities = {
-    ...capabilities,
-    ...userCapabilities,
-    "goog:chromeOptions": mergeCapabilityOptions(capabilities["goog:chromeOptions"], userCapabilities["goog:chromeOptions"]),
-    "ms:edgeOptions": mergeCapabilityOptions(capabilities["ms:edgeOptions"], userCapabilities["ms:edgeOptions"]),
-    "moz:firefoxOptions": mergeCapabilityOptions(capabilities["moz:firefoxOptions"], userCapabilities["moz:firefoxOptions"])
-  };
-  for (const [key, value] of Object.entries(mergedCapabilities)) {
-    if (value === void 0) {
-      delete mergedCapabilities[key];
-    }
-  }
-  const wdioBrowser = await remote({
-    capabilities: mergedCapabilities
-  });
-  const { sessionId } = wdioBrowser;
-  state.browsers.set(sessionId, wdioBrowser);
-  state.sessionMetadata.set(sessionId, {
-    type: "browser",
-    capabilities: wdioBrowser.capabilities,
-    isAttached: false
-  });
-  if (state.currentSession && state.currentSession !== sessionId) {
-    const outgoing = state.sessionHistory.get(state.currentSession);
-    if (outgoing) {
-      outgoing.steps.push({
-        index: outgoing.steps.length + 1,
-        tool: "__session_transition__",
-        params: { newSessionId: sessionId },
-        status: "ok",
-        durationMs: 0,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      outgoing.endedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-  }
-  state.sessionHistory.set(sessionId, {
-    sessionId,
-    type: "browser",
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    capabilities: wdioBrowser.capabilities,
-    steps: []
-  });
-  state.currentSession = sessionId;
-  let sizeNote = "";
-  try {
-    await wdioBrowser.setWindowSize(windowWidth, windowHeight);
-  } catch (e) {
-    sizeNote = `
-Note: Unable to set window size (${windowWidth}x${windowHeight}). ${e}`;
-  }
-  if (navigationUrl) {
-    await wdioBrowser.url(navigationUrl);
-  }
-  const modeText = effectiveHeadless ? "headless" : "headed";
-  const browserText = browserDisplayNames[selectedBrowser];
-  const urlText = navigationUrl ? ` and navigated to ${navigationUrl}` : "";
-  const headlessNote = headless && !headlessSupported ? "\nNote: Safari does not support headless mode. Started in headed mode." : "";
-  return {
-    content: [{
-      type: "text",
-      text: `${browserText} browser started in ${modeText} mode with sessionId: ${sessionId} (${windowWidth}x${windowHeight})${urlText}${headlessNote}${sizeNote}`
-    }]
-  };
-};
-var closeSessionTool = async (args = {}) => {
-  try {
-    const browser = getBrowser();
-    const sessionId = state.currentSession;
-    const metadata = state.sessionMetadata.get(sessionId);
-    const history = state.sessionHistory.get(sessionId);
-    if (history) {
-      history.endedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    const effectiveDetach = args.detach || !!metadata?.isAttached;
-    if (!effectiveDetach) {
-      await browser.deleteSession();
-    }
-    state.browsers.delete(sessionId);
-    state.sessionMetadata.delete(sessionId);
-    state.currentSession = null;
-    const action = effectiveDetach ? "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 {
-      isError: true,
-      content: [{ type: "text", text: `Error closing session: ${e}` }]
-    };
-  }
-};
-
 // src/tools/navigate.tool.ts
-import { z as z2 } from "zod";
+init_state();
+import { z } from "zod";
 var navigateToolDefinition = {
   name: "navigate",
   description: "navigates to a URL",
   inputSchema: {
-    url: z2.string().min(1).describe("The URL to navigate to")
+    url: z.string().min(1).describe("The URL to navigate to")
   }
 };
-var navigateTool = async ({ url }) => {
+var navigateAction = async (url) => {
   try {
     const browser = getBrowser();
     await browser.url(url);
@@ -310,16 +141,32 @@ var navigateTool = async ({ url }) => {
     };
   }
 };
+var navigateTool = async ({ url }) => navigateAction(url);
 
 // src/tools/click.tool.ts
+init_state();
 import { z as z3 } from "zod";
+
+// src/utils/zod-helpers.ts
+import { z as z2 } from "zod";
+var coerceBoolean = z2.preprocess((val) => {
+  if (typeof val === "boolean") return val;
+  if (typeof val === "string") {
+    if (val === "false" || val === "0") return false;
+    if (val === "true" || val === "1") return true;
+    return Boolean(val);
+  }
+  return val;
+}, z2.boolean());
+
+// src/tools/click.tool.ts
 var defaultTimeout = 3e3;
 var clickToolDefinition = {
   name: "click_element",
   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),
+    scrollToView: coerceBoolean.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")
   }
 };
@@ -344,6 +191,7 @@ var clickAction = async (selector, timeout, scrollToView = true) => {
 var clickTool = async ({ selector, scrollToView, timeout = defaultTimeout }) => clickAction(selector, timeout, scrollToView);
 
 // src/tools/set-value.tool.ts
+init_state();
 import { z as z4 } from "zod";
 var defaultTimeout2 = 3e3;
 var setValueToolDefinition = {
@@ -352,11 +200,11 @@ var setValueToolDefinition = {
   inputSchema: {
     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),
+    scrollToView: coerceBoolean.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 }) => {
+var setValueAction = async (selector, value, scrollToView = true, timeout = defaultTimeout2) => {
   try {
     const browser = getBrowser();
     await browser.waitUntil(browser.$(selector).isExisting, { timeout });
@@ -375,287 +223,419 @@ var setValueTool = async ({ selector, value, scrollToView = true, timeout = defa
     };
   }
 };
+var setValueTool = async ({ selector, value, scrollToView = true, timeout = defaultTimeout2 }) => setValueAction(selector, value, scrollToView, timeout);
 
-// src/tools/app-session.tool.ts
-import { remote as remote2 } from "webdriverio";
+// src/tools/scroll.tool.ts
+init_state();
 import { z as z5 } 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;
+var scrollToolDefinition = {
+  name: "scroll",
+  description: "scrolls the page by specified pixels (browser only). For mobile, use the swipe tool.",
+  inputSchema: {
+    direction: z5.enum(["up", "down"]).describe("Scroll direction"),
+    pixels: z5.number().optional().default(500).describe("Number of pixels to scroll")
   }
-  if (options.noReset !== void 0) {
-    capabilities["appium:noReset"] = options.noReset;
+};
+var scrollAction = async (direction, pixels = 500) => {
+  try {
+    const browser = getBrowser();
+    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 ${direction} ${pixels} pixels` }]
+    };
+  } catch (e) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: `Error scrolling: ${e}` }]
+    };
   }
-  if (options.fullReset !== void 0) {
-    capabilities["appium:fullReset"] = options.fullReset;
+};
+var scrollTool = async ({ direction, pixels = 500 }) => scrollAction(direction, pixels);
+
+// src/tools/cookies.tool.ts
+import { z as z6 } from "zod";
+var setCookieToolDefinition = {
+  name: "set_cookie",
+  description: "sets a cookie with specified name, value, and optional attributes",
+  inputSchema: {
+    name: z6.string().describe("Cookie name"),
+    value: z6.string().describe("Cookie value"),
+    domain: z6.string().optional().describe("Cookie domain (defaults to current domain)"),
+    path: z6.string().optional().describe('Cookie path (defaults to "/")'),
+    expiry: z6.number().optional().describe("Expiry date as Unix timestamp in seconds"),
+    httpOnly: coerceBoolean.optional().describe("HttpOnly flag"),
+    secure: coerceBoolean.optional().describe("Secure flag"),
+    sameSite: z6.enum(["strict", "lax", "none"]).optional().describe("SameSite attribute")
   }
-  if (options.newCommandTimeout !== void 0) {
-    capabilities["appium:newCommandTimeout"] = options.newCommandTimeout;
+};
+var setCookieTool = async ({
+  name,
+  value,
+  domain,
+  path = "/",
+  expiry,
+  httpOnly,
+  secure,
+  sameSite
+}) => {
+  try {
+    const cookie = { name, value, path, domain, expiry, httpOnly, secure, sameSite };
+    const { getBrowser: getBrowser2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+    const browser = getBrowser2();
+    await browser.setCookies(cookie);
+    return {
+      content: [{ type: "text", text: `Cookie "${name}" set successfully` }]
+    };
+  } catch (e) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: `Error setting cookie: ${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;
+};
+var deleteCookiesToolDefinition = {
+  name: "delete_cookies",
+  description: "deletes all cookies or a specific cookie by name",
+  inputSchema: {
+    name: z6.string().optional().describe("Optional cookie name to delete a specific cookie. If not provided, deletes all cookies")
   }
-  for (const [key, value] of Object.entries(options)) {
-    if (!["deviceName", "platformVersion", "automationName", "autoGrantPermissions", "autoAcceptAlerts", "autoDismissAlerts", "udid", "noReset", "fullReset", "newCommandTimeout"].includes(
-      key
-    )) {
-      capabilities[`appium:${key}`] = value;
+};
+var deleteCookiesTool = async ({ name }) => {
+  try {
+    const { getBrowser: getBrowser2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+    const browser = getBrowser2();
+    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 {
+      isError: true,
+      content: [{ type: "text", text: `Error deleting cookies: ${e}` }]
+    };
   }
-  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;
+};
+
+// src/tools/gestures.tool.ts
+init_state();
+import { z as z7 } from "zod";
+var tapElementToolDefinition = {
+  name: "tap_element",
+  description: "taps an element by selector or screen coordinates (mobile)",
+  inputSchema: {
+    selector: z7.string().optional().describe("Element selector (CSS, XPath, accessibility ID, or UiAutomator)"),
+    x: z7.number().optional().describe("X coordinate for screen tap (if no selector provided)"),
+    y: z7.number().optional().describe("Y coordinate for screen tap (if no selector provided)")
   }
-  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;
+};
+var tapAction = 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.tap({ x, y });
+      return {
+        content: [{ type: "text", text: `Tapped at coordinates: (${x}, ${y})` }]
+      };
+    }
+    return {
+      isError: true,
+      content: [{ type: "text", text: "Error: Must provide either selector or x,y coordinates" }]
+    };
+  } catch (e) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: `Error tapping: ${e}` }]
+    };
   }
-  if (options.appWaitActivity) {
-    capabilities["appium:appWaitActivity"] = options.appWaitActivity;
+};
+var tapElementTool = async (args) => tapAction(args);
+var swipeToolDefinition = {
+  name: "swipe",
+  description: "performs a swipe gesture in specified direction (mobile)",
+  inputSchema: {
+    direction: z7.enum(["up", "down", "left", "right"]).describe("Swipe direction"),
+    duration: z7.number().min(100).max(5e3).optional().describe("Swipe duration in milliseconds (default: 500)"),
+    percent: z7.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)")
   }
-  for (const [key, value] of Object.entries(options)) {
-    if (!["deviceName", "platformVersion", "automationName", "autoGrantPermissions", "autoAcceptAlerts", "autoDismissAlerts", "appWaitActivity", "noReset", "fullReset", "newCommandTimeout"].includes(
-      key
-    )) {
-      capabilities[`appium:${key}`] = value;
-    }
+};
+var contentToFingerDirection = {
+  up: "down",
+  down: "up",
+  left: "right",
+  right: "left"
+};
+var swipeAction = async (args) => {
+  try {
+    const browser = getBrowser();
+    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}` }]
+    };
+  } catch (e) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: `Error swiping: ${e}` }]
+    };
   }
-  return capabilities;
-}
-
-// src/tools/app-session.tool.ts
-var startAppToolDefinition = {
-  name: "start_app_session",
-  description: "starts a mobile app session (iOS/Android) via Appium",
+};
+var swipeTool = async (args) => swipeAction(args);
+var dragAndDropToolDefinition = {
+  name: "drag_and_drop",
+  description: "drags an element to another element or coordinates (mobile)",
   inputSchema: {
-    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().default(300).describe("How long (in seconds) Appium will wait for a new command before assuming the client has quit and ending the session. Default: 300."),
-    capabilities: z5.record(z5.string(), z5.unknown()).optional().describe("Additional Appium/WebDriver capabilities to merge with defaults (e.g. appium:udid, appium:chromedriverExecutable, appium:autoWebview)")
-  }
-};
-var getState = () => {
-  const sharedState = getBrowser.__state;
-  if (!sharedState) {
-    throw new Error("Browser state not initialized");
-  }
-  return sharedState;
-};
-var startAppTool = async (args) => {
+    sourceSelector: z7.string().describe("Source element selector to drag"),
+    targetSelector: z7.string().optional().describe("Target element selector to drop onto"),
+    x: z7.number().optional().describe("Target X offset (if no targetSelector)"),
+    y: z7.number().optional().describe("Target Y offset (if no targetSelector)"),
+    duration: z7.number().min(100).max(5e3).optional().describe("Drag duration in milliseconds")
+  }
+};
+var dragAndDropAction = async (args) => {
   try {
-    const {
-      platform: platform2,
-      appPath,
-      deviceName,
-      platformVersion,
-      automationName,
-      appiumHost,
-      appiumPort,
-      appiumPath,
-      autoGrantPermissions = true,
-      autoAcceptAlerts,
-      autoDismissAlerts,
-      appWaitActivity,
-      udid,
-      noReset,
-      fullReset,
-      newCommandTimeout = 300,
-      capabilities: userCapabilities = {}
-    } = args;
-    if (!appPath && noReset !== true) {
+    const browser = getBrowser();
+    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: Either "appPath" must be provided to install an app, or "noReset: true" must be set to connect to an already-running app.'
-        }]
+        content: [{ type: "text", text: `Dragged ${sourceSelector} to ${targetSelector}` }]
+      };
+    } else if (x !== void 0 && y !== void 0) {
+      await sourceElement.dragAndDrop({ x, y }, { duration });
+      return {
+        content: [{ type: "text", text: `Dragged ${sourceSelector} by (${x}, ${y})` }]
       };
     }
-    const serverConfig = getAppiumServerConfig({
-      hostname: appiumHost,
-      port: appiumPort,
-      path: appiumPath
-    });
-    const capabilities = platform2 === "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 mergedCapabilities = {
-      ...capabilities,
-      ...userCapabilities
+    return {
+      isError: true,
+      content: [{ type: "text", text: "Error: Must provide either targetSelector or x,y coordinates" }]
     };
-    for (const [key, value] of Object.entries(mergedCapabilities)) {
-      if (value === void 0) {
-        delete mergedCapabilities[key];
-      }
-    }
-    const browser = await remote2({
-      protocol: "http",
-      hostname: serverConfig.hostname,
-      port: serverConfig.port,
-      path: serverConfig.path,
-      capabilities: mergedCapabilities
-    });
-    const { sessionId } = browser;
-    const shouldAutoDetach = noReset === true || !appPath;
-    const state2 = getState();
-    state2.browsers.set(sessionId, browser);
-    state2.sessionMetadata.set(sessionId, {
-      type: platform2.toLowerCase(),
-      capabilities: mergedCapabilities,
-      isAttached: shouldAutoDetach
-    });
-    if (state2.currentSession && state2.currentSession !== sessionId) {
-      const outgoing = state2.sessionHistory.get(state2.currentSession);
-      if (outgoing) {
-        outgoing.steps.push({
-          index: outgoing.steps.length + 1,
-          tool: "__session_transition__",
-          params: { newSessionId: sessionId },
-          status: "ok",
-          durationMs: 0,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        outgoing.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+  } catch (e) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: `Error dragging: ${e}` }]
+    };
+  }
+};
+var dragAndDropTool = async (args) => dragAndDropAction(args);
+
+// src/tools/context.tool.ts
+init_state();
+import { z as z8 } from "zod";
+var switchContextToolDefinition = {
+  name: "switch_context",
+  description: "switches between native and webview contexts",
+  inputSchema: {
+    context: z8.string().describe(
+      'Context name to switch to (e.g., "NATIVE_APP", "WEBVIEW_com.example.app", or use index from wdio://session/current/contexts resource)'
+    )
+  }
+};
+var switchContextTool = async (args) => {
+  try {
+    const browser = getBrowser();
+    const { context } = args;
+    if (/^\d+$/.test(context)) {
+      const contexts = await browser.getContexts();
+      const index = Number.parseInt(context, 10) - 1;
+      if (index >= 0 && index < contexts.length) {
+        const targetContext = contexts[index];
+        await browser.switchContext(targetContext);
+        return { content: [{ type: "text", text: `Switched to context: ${targetContext}` }] };
       }
+      throw new Error(`Error: Invalid context index ${context}. Available contexts: ${contexts.length}`);
     }
-    state2.sessionHistory.set(sessionId, {
-      sessionId,
-      type: platform2.toLowerCase(),
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      capabilities: mergedCapabilities,
-      appiumConfig: { hostname: serverConfig.hostname, port: serverConfig.port, path: serverConfig.path },
-      steps: []
-    });
-    state2.currentSession = sessionId;
-    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.)" : "";
+    await browser.switchContext(context);
     return {
-      content: [
-        {
-          type: "text",
-          text: `${platform2} app session started with sessionId: ${sessionId}
-Device: ${deviceName}${appInfo}
-Appium Server: ${serverConfig.hostname}:${serverConfig.port}${serverConfig.path}${detachNote}`
-        }
-      ]
+      content: [{ type: "text", text: `Switched to context: ${context}` }]
     };
   } catch (e) {
     return {
       isError: true,
-      content: [{ type: "text", text: `Error starting app session: ${e}` }]
+      content: [{ type: "text", text: `Error switching context: ${e}` }]
     };
   }
 };
 
-// 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.",
+// src/tools/device.tool.ts
+init_state();
+import { z as z9 } from "zod";
+var hideKeyboardToolDefinition = {
+  name: "hide_keyboard",
+  description: "hides the on-screen keyboard",
+  inputSchema: {}
+};
+var rotateDeviceToolDefinition = {
+  name: "rotate_device",
+  description: "rotates device to portrait or landscape orientation",
+  inputSchema: {
+    orientation: z9.enum(["PORTRAIT", "LANDSCAPE"]).describe("Device orientation")
+  }
+};
+var setGeolocationToolDefinition = {
+  name: "set_geolocation",
+  description: "sets device geolocation (latitude, longitude, altitude)",
   inputSchema: {
-    direction: z6.enum(["up", "down"]).describe("Scroll direction"),
-    pixels: z6.number().optional().default(500).describe("Number of pixels to scroll")
+    latitude: z9.number().min(-90).max(90).describe("Latitude coordinate"),
+    longitude: z9.number().min(-180).max(180).describe("Longitude coordinate"),
+    altitude: z9.number().optional().describe("Altitude in meters (optional)")
   }
 };
-var scrollTool = async ({ direction, pixels = 500 }) => {
+var rotateDeviceTool = async (args) => {
   try {
     const browser = getBrowser();
-    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);
+    const { orientation } = args;
+    await browser.setOrientation(orientation);
     return {
-      content: [{ type: "text", text: `Scrolled ${direction} ${pixels} pixels` }]
+      content: [{ type: "text", text: `Device rotated to: ${orientation}` }]
     };
   } catch (e) {
     return {
       isError: true,
-      content: [{ type: "text", text: `Error scrolling: ${e}` }]
+      content: [{ type: "text", text: `Error rotating device: ${e}` }]
+    };
+  }
+};
+var hideKeyboardTool = async () => {
+  try {
+    const browser = getBrowser();
+    await browser.hideKeyboard();
+    return {
+      content: [{ type: "text", text: "Keyboard hidden" }]
+    };
+  } catch (e) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: `Error hiding keyboard: ${e}` }]
+    };
+  }
+};
+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 {
+      isError: true,
+      content: [{ type: "text", text: `Error setting geolocation: ${e}` }]
     };
   }
 };
 
-// src/scripts/get-interactable-browser-elements.ts
-var elementsScript = (includeBounds) => (function() {
+// src/tools/execute-script.tool.ts
+init_state();
+import { z as z10 } from "zod";
+var executeScriptToolDefinition = {
+  name: "execute_script",
+  description: `Executes JavaScript in browser or mobile commands via Appium.
+
+**Option B for browser interaction** \u2014 prefer get_visible_elements or click_element/set_value with a selector instead. Use execute_script only when no dedicated tool covers the action (e.g. reading computed values, triggering custom events, scrolling to a position).
+
+**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: z10.string().describe('JavaScript code (browser) or mobile command string like "mobile: pressKey" (Appium)'),
+    args: z10.array(z10.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 {
+      isError: true,
+      content: [{ type: "text", text: `Error executing script: ${e}` }]
+    };
+  }
+};
+
+// src/tools/get-elements.tool.ts
+init_state();
+import { z as z11 } from "zod";
+
+// src/scripts/get-interactable-browser-elements.ts
+var elementsScript = (includeBounds) => (function() {
   const interactableSelectors = [
     "a[href]",
     "button",
@@ -1768,121 +1748,714 @@ async function getMobileVisibleElements(browser, platform2, options = {}) {
   return elements.map((el) => toMobileElementInfo(el, includeBounds));
 }
 
-// src/tools/get-visible-elements.tool.ts
+// src/scripts/get-elements.ts
+async function getElements(browser, params) {
+  const {
+    inViewportOnly = true,
+    includeContainers = false,
+    includeBounds = false,
+    limit = 0,
+    offset = 0
+  } = params;
+  let elements;
+  if (browser.isAndroid || browser.isIOS) {
+    const platform2 = browser.isAndroid ? "android" : "ios";
+    elements = await getMobileVisibleElements(browser, platform2, { includeContainers, includeBounds });
+  } else {
+    elements = await getInteractableBrowserElements(browser, { includeBounds });
+  }
+  if (inViewportOnly) {
+    elements = elements.filter((el) => el.isInViewport !== false);
+  }
+  const total = elements.length;
+  if (offset > 0) {
+    elements = elements.slice(offset);
+  }
+  if (limit > 0) {
+    elements = elements.slice(0, limit);
+  }
+  return {
+    total,
+    showing: elements.length,
+    hasMore: offset + elements.length < total,
+    elements
+  };
+}
+
+// src/tools/get-elements.tool.ts
 import { encode } from "@toon-format/toon";
-import { z as z7 } from "zod";
-var getVisibleElementsToolDefinition = {
-  name: "get_visible_elements",
-  description: "Get interactable elements on the page (buttons, links, inputs). Use get_accessibility for page structure and non-interactable elements.",
+var getElementsToolDefinition = {
+  name: "get_elements",
+  description: "Get interactable elements on the current page. Use when wdio://session/current/elements does not return the desired elements.",
   inputSchema: {
-    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: z7.boolean().optional().describe("Mobile only: include layout containers. Default: false."),
-    includeBounds: z7.boolean().optional().describe("Include element bounds/coordinates (x, y, width, height). Default: false."),
-    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.")
+    inViewportOnly: coerceBoolean.optional().default(false).describe("Only return elements visible in the current viewport (default: false)."),
+    includeContainers: coerceBoolean.optional().default(false).describe("Include container elements like divs and sections (default: false)"),
+    includeBounds: coerceBoolean.optional().default(false).describe("Include element bounding box coordinates (default: false)"),
+    limit: z11.number().optional().default(0).describe("Maximum number of elements to return (0 = no limit)"),
+    offset: z11.number().optional().default(0).describe("Number of elements to skip (for pagination)")
   }
 };
-var getVisibleElementsTool = async (args) => {
+var getElementsTool = async ({
+  inViewportOnly = false,
+  includeContainers = false,
+  includeBounds = false,
+  limit = 0,
+  offset = 0
+}) => {
   try {
     const browser = getBrowser();
-    const {
-      inViewportOnly = true,
-      includeContainers = false,
-      includeBounds = false,
-      limit = 0,
-      offset = 0
-    } = args || {};
-    let elements;
-    if (browser.isAndroid || browser.isIOS) {
-      const platform2 = browser.isAndroid ? "android" : "ios";
-      elements = await getMobileVisibleElements(browser, platform2, { includeContainers, includeBounds });
-    } else {
-      elements = await getInteractableBrowserElements(browser, { includeBounds });
-    }
-    if (inViewportOnly) {
-      elements = elements.filter((el) => el.isInViewport !== false);
-    }
-    const total = elements.length;
-    if (offset > 0) {
-      elements = elements.slice(offset);
+    const result = await getElements(browser, { inViewportOnly, includeContainers, includeBounds, limit, offset });
+    const text = encode(result).replace(/,""/g, ",").replace(/"",/g, ",");
+    return { content: [{ type: "text", text }] };
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: `Error getting elements: ${e}` }] };
+  }
+};
+
+// src/tools/launch-chrome.tool.ts
+import { spawn } from "child_process";
+import { copyFileSync, cpSync, existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { homedir, platform, tmpdir } from "os";
+import { join } from "path";
+import { z as z12 } from "zod";
+var USER_DATA_DIR = join(tmpdir(), "chrome-debug");
+var launchChromeToolDefinition = {
+  name: "launch_chrome",
+  description: `Prepares and launches Chrome with remote debugging enabled so attach_browser() can connect.
+
+Two modes:
+
+  newInstance (default): Opens a Chrome window alongside your existing one using a separate
+    profile dir. Your current Chrome session is untouched.
+
+  freshSession: Launches Chrome with an empty profile (no cookies, no logins).
+
+Use copyProfileFiles: true to carry over your cookies and logins into the debug session.
+Note: changes made during the session won't sync back to your main profile.
+
+After this tool succeeds, call attach_browser() to connect.`,
+  inputSchema: {
+    port: z12.number().default(9222).describe("Remote debugging port (default: 9222)"),
+    mode: z12.enum(["newInstance", "freshSession"]).default("newInstance").describe(
+      "newInstance: open alongside existing Chrome | freshSession: clean profile"
+    ),
+    copyProfileFiles: coerceBoolean.default(false).describe(
+      "Copy your Default Chrome profile (cookies, logins) into the debug session."
+    )
+  }
+};
+function isMac() {
+  return platform() === "darwin";
+}
+function chromeExec() {
+  if (isMac()) return "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+  if (platform() === "win32") {
+    const candidates = [
+      join("C:", "Program Files", "Google", "Chrome", "Application", "chrome.exe"),
+      join("C:", "Program Files (x86)", "Google", "Chrome", "Application", "chrome.exe")
+    ];
+    return candidates.find((p) => existsSync(p)) ?? candidates[0];
+  }
+  return "google-chrome";
+}
+function defaultProfileDir() {
+  const home = homedir();
+  if (isMac()) return join(home, "Library", "Application Support", "Google", "Chrome");
+  if (platform() === "win32") return join(home, "AppData", "Local", "Google", "Chrome", "User Data");
+  return join(home, ".config", "google-chrome");
+}
+function copyProfile() {
+  const srcDir = defaultProfileDir();
+  rmSync(USER_DATA_DIR, { recursive: true, force: true });
+  mkdirSync(USER_DATA_DIR, { recursive: true });
+  copyFileSync(join(srcDir, "Local State"), join(USER_DATA_DIR, "Local State"));
+  cpSync(join(srcDir, "Default"), join(USER_DATA_DIR, "Default"), { recursive: true });
+  for (const f of ["SingletonLock", "SingletonCookie", "SingletonSocket"]) {
+    rmSync(join(USER_DATA_DIR, f), { force: true });
+  }
+  for (const f of ["Current Session", "Current Tabs", "Last Session", "Last Tabs"]) {
+    rmSync(join(USER_DATA_DIR, "Default", f), { force: true });
+  }
+  writeFileSync(join(USER_DATA_DIR, "First Run"), "");
+}
+function launchChrome(port) {
+  spawn(chromeExec(), [
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${USER_DATA_DIR}`,
+    "--profile-directory=Default",
+    "--no-first-run",
+    "--disable-session-crashed-bubble"
+  ], { detached: true, stdio: "ignore" }).unref();
+}
+async function waitForCDP(port, timeoutMs = 15e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`http://localhost:${port}/json/version`);
+      if (res.ok) return;
+    } catch {
     }
-    if (limit > 0) {
-      elements = elements.slice(0, limit);
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  throw new Error(`Chrome did not expose CDP on port ${port} within ${timeoutMs}ms`);
+}
+var launchChromeTool = async ({
+  port = 9222,
+  mode = "newInstance",
+  copyProfileFiles = false
+}) => {
+  const warnings = [];
+  const notes = [];
+  try {
+    if (copyProfileFiles) {
+      warnings.push("\u26A0\uFE0F  Cookies and logins were copied at this moment. Changes during this session won't sync back to your main profile.");
+      copyProfile();
+    } else {
+      notes.push(mode === "newInstance" ? "No profile copied \u2014 this instance starts with no cookies or logins." : "Fresh profile \u2014 no existing cookies or logins.");
+      rmSync(USER_DATA_DIR, { recursive: true, force: true });
+      mkdirSync(USER_DATA_DIR, { recursive: true });
     }
-    const result = {
-      total,
-      showing: elements.length,
-      hasMore: offset + elements.length < total,
-      elements
-    };
-    const toon = encode(result).replace(/,""/g, ",").replace(/"",/g, ",");
-    return {
-      content: [{ type: "text", text: toon }]
-    };
+    launchChrome(port);
+    await waitForCDP(port);
+    const lines = [
+      `Chrome launched on port ${port} (mode: ${mode}).`,
+      ...warnings,
+      ...notes
+    ];
+    return { content: [{ type: "text", text: lines.join("\n") }] };
   } catch (e) {
     return {
       isError: true,
-      content: [{ type: "text", text: `Error getting visible elements: ${e}` }]
+      content: [{ type: "text", text: `Error launching Chrome: ${e}` }]
     };
   }
 };
 
-// src/scripts/get-browser-accessibility-tree.ts
-var accessibilityTreeScript = () => (function() {
-  const INPUT_TYPE_ROLES = {
-    text: "textbox",
-    search: "searchbox",
-    email: "textbox",
-    url: "textbox",
-    tel: "textbox",
-    password: "textbox",
-    number: "spinbutton",
-    checkbox: "checkbox",
-    radio: "radio",
-    range: "slider",
-    submit: "button",
-    reset: "button",
-    image: "button",
-    file: "button",
-    color: "button"
-  };
-  const LANDMARK_ROLES = /* @__PURE__ */ new Set([
-    "navigation",
-    "main",
-    "banner",
-    "contentinfo",
-    "complementary",
-    "form",
-    "dialog",
-    "region"
-  ]);
-  const CONTAINER_ROLES = /* @__PURE__ */ new Set([
-    "navigation",
-    "banner",
-    "contentinfo",
-    "complementary",
-    "main",
-    "form",
-    "region",
-    "group",
-    "list",
-    "listitem",
-    "table",
-    "row",
-    "rowgroup",
-    "generic"
-  ]);
-  function getRole(el) {
-    const explicit = el.getAttribute("role");
-    if (explicit) return explicit.split(" ")[0];
-    const tag = el.tagName.toLowerCase();
-    switch (tag) {
-      case "button":
-        return "button";
-      case "a":
-        return el.hasAttribute("href") ? "link" : null;
-      case "input": {
-        const type = (el.getAttribute("type") || "text").toLowerCase();
+// src/tools/emulate-device.tool.ts
+init_state();
+import { z as z13 } from "zod";
+var restoreFunctions = /* @__PURE__ */ new Map();
+var emulateDeviceToolDefinition = {
+  name: "emulate_device",
+  description: `Emulate a mobile or tablet device in the current browser session (sets viewport, DPR, user-agent, touch events).
+
+Requires a BiDi-enabled session: start_browser({ capabilities: { webSocketUrl: true } })
+
+Usage:
+  emulate_device()                    \u2014 list available device presets
+  emulate_device({ device: "iPhone 15" })  \u2014 activate emulation
+  emulate_device({ device: "reset" }) \u2014 restore desktop defaults`,
+  inputSchema: {
+    device: z13.string().optional().describe(
+      'Device preset name (e.g. "iPhone 15", "Pixel 7"). Omit to list available presets. Pass "reset" to restore desktop defaults.'
+    )
+  }
+};
+var emulateDeviceTool = async ({
+  device
+}) => {
+  try {
+    const browser = getBrowser();
+    const state2 = getState();
+    const sessionId = state2.currentSession;
+    const metadata = state2.sessionMetadata.get(sessionId);
+    if (metadata?.type === "ios" || metadata?.type === "android") {
+      return {
+        isError: true,
+        content: [{
+          type: "text",
+          text: "Error: emulate_device is only supported for web browser sessions, not iOS/Android."
+        }]
+      };
+    }
+    if (!browser.isBidi) {
+      return {
+        isError: true,
+        content: [{
+          type: "text",
+          text: "Error: emulate_device requires a BiDi-enabled session.\nRestart the browser with: start_browser({ capabilities: { webSocketUrl: true } })"
+        }]
+      };
+    }
+    if (!device) {
+      try {
+        await browser.emulate("device", "\0");
+      } catch (e) {
+        const msg = String(e);
+        const match = msg.match(/please use one of the following: (.+)$/);
+        if (match) {
+          const names = match[1].split(", ").sort();
+          return {
+            content: [{ type: "text", text: `Available devices (${names.length}):
+${names.join("\n")}` }]
+          };
+        }
+        return { isError: true, content: [{ type: "text", text: `Error listing devices: ${e}` }] };
+      }
+      return { content: [{ type: "text", text: "Could not retrieve device list." }] };
+    }
+    if (device === "reset") {
+      const restoreFn = restoreFunctions.get(sessionId);
+      if (!restoreFn) {
+        return { content: [{ type: "text", text: "No active device emulation to reset." }] };
+      }
+      await restoreFn();
+      restoreFunctions.delete(sessionId);
+      return { content: [{ type: "text", text: "Device emulation reset to desktop defaults." }] };
+    }
+    try {
+      const restoreFn = await browser.emulate("device", device);
+      restoreFunctions.set(sessionId, restoreFn);
+      return {
+        content: [{ type: "text", text: `Emulating "${device}".` }]
+      };
+    } catch (e) {
+      const msg = String(e);
+      if (msg.includes("Unknown device name")) {
+        return {
+          content: [{
+            type: "text",
+            text: `Error: Unknown device "${device}". Call emulate_device() with no arguments to list valid names.`
+          }]
+        };
+      }
+      return { isError: true, content: [{ type: "text", text: `Error: ${e}` }] };
+    }
+  } catch (e) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: `Error: ${e}` }]
+    };
+  }
+};
+
+// src/recording/step-recorder.ts
+init_state();
+function appendStep(toolName, params, status, durationMs, error) {
+  const state2 = getState();
+  const sessionId = state2.currentSession;
+  if (!sessionId) return;
+  const history = state2.sessionHistory.get(sessionId);
+  if (!history) return;
+  const step = {
+    index: history.steps.length + 1,
+    tool: toolName,
+    params,
+    status,
+    durationMs,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...error !== void 0 && { error }
+  };
+  history.steps.push(step);
+}
+function getSessionHistory() {
+  return getState().sessionHistory;
+}
+function extractErrorText(result) {
+  const textContent = result.content.find((c) => c.type === "text");
+  return textContent ? textContent.text : "Unknown error";
+}
+function withRecording(toolName, callback) {
+  return async (params, extra) => {
+    const start = Date.now();
+    const result = await callback(params, extra);
+    const isError = result.isError === true;
+    appendStep(
+      toolName,
+      params,
+      isError ? "error" : "ok",
+      Date.now() - start,
+      isError ? extractErrorText(result) : void 0
+    );
+    return result;
+  };
+}
+
+// src/resources/browserstack-local.resource.ts
+function getLocalBinaryInfo() {
+  const platform2 = process.platform;
+  const arch = process.arch;
+  if (platform2 === "darwin") {
+    return {
+      downloadUrl: "https://local-downloads.browserstack.com/BrowserStackLocal-darwin-x64.zip",
+      platform: "macOS",
+      arch: arch === "arm64" ? "Apple Silicon (via Rosetta 2)" : "Intel x64",
+      binaryName: "BrowserStackLocal",
+      note: arch === "arm64" ? "macOS binary is Intel-only. Rosetta 2 must be installed (it is on most Apple Silicon Macs by default)." : void 0
+    };
+  }
+  if (platform2 === "win32") {
+    return {
+      downloadUrl: "https://local-downloads.browserstack.com/BrowserStackLocal-win32.zip",
+      platform: "Windows",
+      arch: "x86/x64",
+      binaryName: "BrowserStackLocal.exe"
+    };
+  }
+  if (arch === "arm64") {
+    return {
+      downloadUrl: "https://local-downloads.browserstack.com/BrowserStackLocal-linux-arm64.zip",
+      platform: "Linux",
+      arch: "ARM64",
+      binaryName: "BrowserStackLocal"
+    };
+  }
+  if (arch === "ia32") {
+    return {
+      downloadUrl: "https://local-downloads.browserstack.com/BrowserStackLocal-linux-ia32.zip",
+      platform: "Linux",
+      arch: "x86 32-bit",
+      binaryName: "BrowserStackLocal"
+    };
+  }
+  return {
+    downloadUrl: "https://local-downloads.browserstack.com/BrowserStackLocal-linux-x64.zip",
+    platform: "Linux",
+    arch: "x64",
+    binaryName: "BrowserStackLocal"
+  };
+}
+var browserstackLocalBinaryResource = {
+  name: "browserstack-local-binary",
+  uri: "wdio://browserstack/local-binary",
+  description: "BrowserStack Local binary download URL and daemon setup instructions for the current platform. MUST be read and followed before using browserstackLocal: true in start_session.",
+  handler: async () => {
+    const info = getLocalBinaryInfo();
+    const accessKey = process.env.BROWSERSTACK_ACCESS_KEY ?? "<BROWSERSTACK_ACCESS_KEY>";
+    const content = {
+      requirement: "MUST start the BrowserStack Local daemon BEFORE calling start_session with browserstackLocal: true. Without it, all navigation to local/internal URLs will fail with ERR_TUNNEL_CONNECTION_FAILED.",
+      platform: info.platform,
+      arch: info.arch,
+      downloadUrl: info.downloadUrl,
+      ...info.note ? { note: info.note } : {},
+      setup: [
+        `1. Download: curl -O ${info.downloadUrl}`,
+        `2. Unzip: unzip ${info.downloadUrl.split("/").pop()}`,
+        `3. Make executable (macOS/Linux): chmod +x ${info.binaryName}`,
+        `4. Start daemon: ./${info.binaryName} --key ${accessKey} --force-local --daemon start`
+      ],
+      commands: {
+        start: `./${info.binaryName} --key ${accessKey} --force-local --daemon start`,
+        stop: `./${info.binaryName} --key ${accessKey} --daemon stop`,
+        status: `./${info.binaryName} --daemon list`
+      },
+      afterDaemonIsRunning: "Call start_session with browserstackLocal: true to route BrowserStack traffic through the tunnel."
+    };
+    return {
+      contents: [{
+        uri: "wdio://browserstack/local-binary",
+        mimeType: "application/json",
+        text: JSON.stringify(content, null, 2)
+      }]
+    };
+  }
+};
+
+// src/resources/sessions.resource.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp";
+
+// src/recording/code-generator.ts
+function escapeStr(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function formatParams(params) {
+  return Object.entries(params).map(([k, v]) => `${k}="${v}"`).join(" ");
+}
+function indentJson(value) {
+  return JSON.stringify(value, null, 2).split("\n").map((line, i) => i > 0 ? `  ${line}` : line).join("\n");
+}
+function generateStep(step, history) {
+  if (step.tool === "__session_transition__") {
+    const newId = step.params.newSessionId ?? "unknown";
+    return `// --- new session: ${newId} started at ${step.timestamp} ---`;
+  }
+  if (step.status === "error") {
+    return `// [error] ${step.tool}: ${formatParams(step.params)} \u2014 ${step.error ?? "unknown error"}`;
+  }
+  const p = step.params;
+  switch (step.tool) {
+    case "start_session": {
+      const platform2 = p.platform;
+      if (platform2 === "browser") {
+        const nav = p.navigationUrl ? `
+await browser.url('${escapeStr(p.navigationUrl)}');` : "";
+        return `const browser = await remote({
+  capabilities: ${indentJson(history.capabilities)}
+});${nav}`;
+      }
+      const config = {
+        protocol: "http",
+        hostname: history.appiumConfig?.hostname ?? "localhost",
+        port: history.appiumConfig?.port ?? 4723,
+        path: history.appiumConfig?.path ?? "/",
+        capabilities: history.capabilities
+      };
+      return `const browser = await remote(${indentJson(config)});`;
+    }
+    case "close_session":
+      return "// Session closed";
+    case "navigate":
+      return `await browser.url('${escapeStr(p.url)}');`;
+    case "click_element":
+      return `await browser.$('${escapeStr(p.selector)}').click();`;
+    case "set_value":
+      return `await browser.$('${escapeStr(p.selector)}').setValue('${escapeStr(p.value)}');`;
+    case "scroll": {
+      const scrollAmount = p.direction === "down" ? p.pixels : -p.pixels;
+      return `await browser.execute(() => window.scrollBy(0, ${scrollAmount}));`;
+    }
+    case "tap_element":
+      if (p.selector !== void 0) {
+        return `await browser.$('${escapeStr(p.selector)}').click();`;
+      }
+      return `await browser.tap({ x: ${p.x}, y: ${p.y} });`;
+    case "swipe":
+      return `await browser.execute('mobile: swipe', { direction: '${escapeStr(p.direction)}' });`;
+    case "drag_and_drop":
+      if (p.targetSelector !== void 0) {
+        return `await browser.$('${escapeStr(p.sourceSelector)}').dragAndDrop(browser.$('${escapeStr(p.targetSelector)}'));`;
+      }
+      return `await browser.$('${escapeStr(p.sourceSelector)}').dragAndDrop({ x: ${p.x}, y: ${p.y} });`;
+    case "execute_script": {
+      const scriptCode = `'${escapeStr(p.script)}'`;
+      const scriptArgs = p.args?.length ? `, ${indentJson(p.args)}` : "";
+      return `await browser.execute(${scriptCode}${scriptArgs});`;
+    }
+    default:
+      return `// [unknown tool] ${step.tool}`;
+  }
+}
+function generateCode(history) {
+  const steps = history.steps.map((step) => generateStep(step, history)).join("\n").split("\n").map((line) => `  ${line}`).join("\n");
+  return `import { remote } from 'webdriverio';
+
+try {
+${steps}
+} finally {
+  await browser.deleteSession();
+}`;
+}
+
+// src/resources/sessions.resource.ts
+init_state();
+function getCurrentSessionId() {
+  return getState().currentSession;
+}
+function buildSessionsIndex() {
+  const histories = getSessionHistory();
+  const currentId = getCurrentSessionId();
+  const sessions = Array.from(histories.values()).map((h) => ({
+    sessionId: h.sessionId,
+    type: h.type,
+    startedAt: h.startedAt,
+    ...h.endedAt ? { endedAt: h.endedAt } : {},
+    stepCount: h.steps.length,
+    isCurrent: h.sessionId === currentId
+  }));
+  return JSON.stringify({ sessions });
+}
+function buildCurrentSessionSteps() {
+  const currentId = getCurrentSessionId();
+  if (!currentId) return null;
+  return buildSessionStepsById(currentId);
+}
+function buildSessionStepsById(sessionId) {
+  const history = getSessionHistory().get(sessionId);
+  if (!history) return null;
+  return buildSessionPayload(history);
+}
+function buildSessionPayload(history) {
+  const stepsJson = JSON.stringify({
+    sessionId: history.sessionId,
+    type: history.type,
+    startedAt: history.startedAt,
+    ...history.endedAt ? { endedAt: history.endedAt } : {},
+    stepCount: history.steps.length,
+    steps: history.steps
+  });
+  return { stepsJson, generatedJs: generateCode(history) };
+}
+var sessionsIndexResource = {
+  name: "sessions",
+  uri: "wdio://sessions",
+  description: "JSON index of all browser and app sessions with metadata and step counts",
+  handler: async () => ({
+    contents: [{ uri: "wdio://sessions", mimeType: "application/json", text: buildSessionsIndex() }]
+  })
+};
+var sessionCurrentStepsResource = {
+  name: "session-current-steps",
+  uri: "wdio://session/current/steps",
+  description: "JSON step log for the currently active session",
+  handler: async () => {
+    const payload = buildCurrentSessionSteps();
+    return {
+      contents: [{
+        uri: "wdio://session/current/steps",
+        mimeType: "application/json",
+        text: payload?.stepsJson ?? '{"error":"No active session"}'
+      }]
+    };
+  }
+};
+var sessionCurrentCodeResource = {
+  name: "session-current-code",
+  uri: "wdio://session/current/code",
+  description: "Generated WebdriverIO JS code for the currently active session",
+  handler: async () => {
+    const payload = buildCurrentSessionSteps();
+    return {
+      contents: [{
+        uri: "wdio://session/current/code",
+        mimeType: "text/plain",
+        text: payload?.generatedJs ?? "// No active session"
+      }]
+    };
+  }
+};
+var sessionStepsResource = {
+  name: "session-steps",
+  template: new ResourceTemplate("wdio://session/{sessionId}/steps", { list: void 0 }),
+  description: "JSON step log for a specific session by ID",
+  handler: async (uri, { sessionId }) => {
+    const payload = buildSessionStepsById(sessionId);
+    return {
+      contents: [{
+        uri: uri.href,
+        mimeType: "application/json",
+        text: payload?.stepsJson ?? `{"error":"Session not found: ${sessionId}"}`
+      }]
+    };
+  }
+};
+var sessionCodeResource = {
+  name: "session-code",
+  template: new ResourceTemplate("wdio://session/{sessionId}/code", { list: void 0 }),
+  description: "Generated WebdriverIO JS code for a specific session by ID",
+  handler: async (uri, { sessionId }) => {
+    const payload = buildSessionStepsById(sessionId);
+    return {
+      contents: [{
+        uri: uri.href,
+        mimeType: "text/plain",
+        text: payload?.generatedJs ?? `// Session not found: ${sessionId}`
+      }]
+    };
+  }
+};
+
+// src/resources/capabilities.resource.ts
+init_state();
+var capabilitiesResource = {
+  name: "session-current-capabilities",
+  uri: "wdio://session/current/capabilities",
+  description: "Raw capabilities returned by the WebDriver/Appium server for the current session. Use for debugging \u2014 shows the actual values the driver accepted, including defaults applied by BrowserStack or Appium.",
+  handler: async () => {
+    try {
+      const browser = getBrowser();
+      return {
+        contents: [{
+          uri: "wdio://session/current/capabilities",
+          mimeType: "application/json",
+          text: JSON.stringify(browser.capabilities, null, 2)
+        }]
+      };
+    } catch (e) {
+      return {
+        contents: [{
+          uri: "wdio://session/current/capabilities",
+          mimeType: "application/json",
+          text: JSON.stringify({ error: String(e) })
+        }]
+      };
+    }
+  }
+};
+
+// src/resources/elements.resource.ts
+init_state();
+import { encode as encode2 } from "@toon-format/toon";
+var elementsResource = {
+  name: "session-current-elements",
+  uri: "wdio://session/current/elements",
+  description: "Interactable elements on the current page. Prefer this over screenshot \u2014 returns ready-to-use selectors, faster, and far fewer tokens. Only use screenshot for visual verification or debugging.",
+  handler: async () => {
+    try {
+      const browser = getBrowser();
+      const result = await getElements(browser, {});
+      const text = encode2(result).replace(/,""/g, ",").replace(/"",/g, ",");
+      return { contents: [{ uri: "wdio://session/current/elements", mimeType: "text/plain", text }] };
+    } catch (e) {
+      return {
+        contents: [{
+          uri: "wdio://session/current/elements",
+          mimeType: "text/plain",
+          text: `Error getting visible elements: ${e}`
+        }]
+      };
+    }
+  }
+};
+
+// src/resources/accessibility.resource.ts
+init_state();
+
+// src/scripts/get-browser-accessibility-tree.ts
+var accessibilityTreeScript = () => (function() {
+  const INPUT_TYPE_ROLES = {
+    text: "textbox",
+    search: "searchbox",
+    email: "textbox",
+    url: "textbox",
+    tel: "textbox",
+    password: "textbox",
+    number: "spinbutton",
+    checkbox: "checkbox",
+    radio: "radio",
+    range: "slider",
+    submit: "button",
+    reset: "button",
+    image: "button",
+    file: "button",
+    color: "button"
+  };
+  const LANDMARK_ROLES = /* @__PURE__ */ new Set([
+    "navigation",
+    "main",
+    "banner",
+    "contentinfo",
+    "complementary",
+    "form",
+    "dialog",
+    "region"
+  ]);
+  const CONTAINER_ROLES = /* @__PURE__ */ new Set([
+    "navigation",
+    "banner",
+    "contentinfo",
+    "complementary",
+    "main",
+    "form",
+    "region",
+    "group",
+    "list",
+    "listitem",
+    "table",
+    "row",
+    "rowgroup",
+    "generic"
+  ]);
+  function getRole(el) {
+    const explicit = el.getAttribute("role");
+    if (explicit) return explicit.split(" ")[0];
+    const tag = el.tagName.toLowerCase();
+    switch (tag) {
+      case "button":
+        return "button";
+      case "a":
+        return el.hasAttribute("href") ? "link" : null;
+      case "input": {
+        const type = (el.getAttribute("type") || "text").toLowerCase();
         if (type === "hidden") return null;
         return INPUT_TYPE_ROLES[type] || "textbox";
       }
@@ -2037,7 +2610,7 @@ var accessibilityTreeScript = () => (function() {
     if (ariaLevel) return parseInt(ariaLevel, 10);
     return void 0;
   }
-  function getState3(el) {
+  function getState2(el) {
     const inputEl = el;
     const isCheckable = ["input", "menuitemcheckbox", "menuitemradio"].includes(el.tagName.toLowerCase()) || ["checkbox", "radio", "switch"].includes(el.getAttribute("role") || "");
     return {
@@ -2065,7 +2638,7 @@ var accessibilityTreeScript = () => (function() {
     const isLandmark = LANDMARK_ROLES.has(role);
     const hasIdentity = !!(name || isLandmark);
     const selector = hasIdentity ? getSelector(el) : "";
-    const node = { role, name, selector, level: getLevel(el) ?? "", ...getState3(el) };
+    const node = { role, name, selector, level: getLevel(el) ?? "", ...getState2(el) };
     result.push(node);
     for (const child of Array.from(el.children)) {
       walk(child, depth + 1);
@@ -2080,35 +2653,21 @@ async function getBrowserAccessibilityTree(browser) {
   return browser.execute(accessibilityTreeScript);
 }
 
-// src/tools/get-accessibility-tree.tool.ts
-import { encode as encode2 } from "@toon-format/toon";
-import { z as z8 } from "zod";
-var getAccessibilityToolDefinition = {
-  name: "get_accessibility",
-  description: "Gets the accessibility tree: page structure with headings, landmarks, and semantic roles. Browser-only. Use to understand page layout and context around interactable elements.",
-  inputSchema: {
-    limit: z8.number().optional().describe("Maximum number of nodes to return. Default: 100. Use 0 for unlimited."),
-    offset: z8.number().optional().describe("Number of nodes to skip (for pagination). Default: 0."),
-    roles: z8.array(z8.string()).optional().describe('Filter to specific roles (e.g., ["heading", "navigation", "region"]). Default: all roles.')
-  }
-};
-var getAccessibilityTreeTool = async (args) => {
+// src/resources/accessibility.resource.ts
+import { encode as encode3 } from "@toon-format/toon";
+async function readAccessibilityTree(params) {
   try {
     const browser = getBrowser();
     if (browser.isAndroid || browser.isIOS) {
       return {
-        content: [{
-          type: "text",
-          text: "Error: get_accessibility is browser-only. For mobile apps, use get_visible_elements instead."
-        }]
+        mimeType: "text/plain",
+        text: "Error: accessibility is browser-only. For mobile apps, use elements resource instead."
       };
     }
-    const { limit = 100, offset = 0, roles } = args || {};
+    const { limit = 0, offset = 0, roles } = params;
     let nodes = await getBrowserAccessibilityTree(browser);
     if (nodes.length === 0) {
-      return {
-        content: [{ type: "text", text: "No accessibility tree available" }]
-      };
+      return { mimeType: "text/plain", text: "No accessibility tree available" };
     }
     nodes = nodes.filter((n) => n.name && n.name.trim() !== "");
     if (roles && roles.length > 0) {
@@ -2135,30 +2694,27 @@ var getAccessibilityTreeTool = async (args) => {
       hasMore: offset + trimmed.length < total,
       nodes: trimmed
     };
-    const toon = encode2(result).replace(/,""/g, ",").replace(/"",/g, ",");
-    return {
-      content: [{ type: "text", text: toon }]
-    };
+    const toon = encode3(result).replace(/,""/g, ",").replace(/"",/g, ",");
+    return { mimeType: "text/plain", text: toon };
   } catch (e) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: `Error getting accessibility tree: ${e}` }]
-    };
+    return { mimeType: "text/plain", text: `Error getting accessibility tree: ${e}` };
+  }
+}
+var accessibilityResource = {
+  name: "session-current-accessibility",
+  uri: "wdio://session/current/accessibility",
+  description: "Accessibility tree for the current page. Returns all elements by default.",
+  handler: async () => {
+    const result = await readAccessibilityTree({});
+    return { contents: [{ uri: "wdio://session/current/accessibility", mimeType: result.mimeType, text: result.text }] };
   }
 };
 
-// src/tools/take-screenshot.tool.ts
-import { z as z9 } from "zod";
+// src/resources/screenshot.resource.ts
+init_state();
 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: z9.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);
@@ -2180,552 +2736,620 @@ async function processScreenshot(screenshotBase64) {
   }
   return { data: outputBuffer, mimeType: "image/png" };
 }
-var takeScreenshotTool = async ({ outputPath }) => {
+async function readScreenshot() {
   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, data);
-      const sizeKB2 = (data.length / 1024).toFixed(1);
-      return {
-        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 (${sizeKB}KB, ${mimeType}):` },
-        { type: "image", data: data.toString("base64"), mimeType }
-      ]
-    };
+    return { mimeType, blob: data.toString("base64") };
   } catch (e) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: `Error taking screenshot: ${e.message}` }]
-    };
+    return { mimeType: "text/plain", blob: Buffer.from(`Error: ${e}`).toString("base64") };
   }
-};
-
-// src/tools/cookies.tool.ts
-import { z as z10 } from "zod";
-var getCookiesToolDefinition = {
-  name: "get_cookies",
-  description: "gets all cookies or a specific cookie by name",
-  inputSchema: {
-    name: z10.string().optional().describe("Optional cookie name to retrieve a specific cookie. If not provided, returns all cookies")
+}
+var screenshotResource = {
+  name: "session-current-screenshot",
+  uri: "wdio://session/current/screenshot",
+  description: "Screenshot of the current page",
+  handler: async () => {
+    const result = await readScreenshot();
+    return { contents: [{ uri: "wdio://session/current/screenshot", mimeType: result.mimeType, blob: result.blob }] };
   }
 };
-var getCookiesTool = async ({ name }) => {
+
+// src/resources/cookies.resource.ts
+init_state();
+async function readCookies(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 { mimeType: "application/json", text: JSON.stringify(null) };
       }
-      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 {
-      isError: true,
-      content: [{ type: "text", text: `Error getting cookies: ${e}` }]
-    };
-  }
-};
-var setCookieToolDefinition = {
-  name: "set_cookie",
-  description: "sets a cookie with specified name, value, and optional attributes",
-  inputSchema: {
-    name: z10.string().describe("Cookie name"),
-    value: z10.string().describe("Cookie value"),
-    domain: z10.string().optional().describe("Cookie domain (defaults to current domain)"),
-    path: z10.string().optional().describe('Cookie path (defaults to "/")'),
-    expiry: z10.number().optional().describe("Expiry date as Unix timestamp in seconds"),
-    httpOnly: z10.boolean().optional().describe("HttpOnly flag"),
-    secure: z10.boolean().optional().describe("Secure flag"),
-    sameSite: z10.enum(["strict", "lax", "none"]).optional().describe("SameSite attribute")
-  }
-};
-var setCookieTool = async ({
-  name,
-  value,
-  domain,
-  path = "/",
-  expiry,
-  httpOnly,
-  secure,
-  sameSite
-}) => {
-  try {
-    const browser = getBrowser();
-    const cookie = { name, value, path, domain, expiry, httpOnly, secure, sameSite };
-    await browser.setCookies(cookie);
-    return {
-      content: [{ type: "text", text: `Cookie "${name}" set successfully` }]
-    };
-  } catch (e) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: `Error setting cookie: ${e}` }]
-    };
-  }
-};
-var deleteCookiesToolDefinition = {
-  name: "delete_cookies",
-  description: "deletes all cookies or a specific cookie by name",
-  inputSchema: {
-    name: z10.string().optional().describe("Optional cookie name to delete a specific cookie. If not provided, deletes all cookies")
+      return { mimeType: "application/json", text: JSON.stringify(cookie[0]) };
+    }
+    const cookies = await browser.getCookies();
+    return { mimeType: "application/json", text: JSON.stringify(cookies) };
+  } catch (e) {
+    return { mimeType: "application/json", text: JSON.stringify({ error: String(e) }) };
+  }
+}
+var cookiesResource = {
+  name: "session-current-cookies",
+  uri: "wdio://session/current/cookies",
+  description: "Cookies for the current session",
+  handler: async () => {
+    const result = await readCookies();
+    return { contents: [{ uri: "wdio://session/current/cookies", mimeType: result.mimeType, text: result.text }] };
   }
 };
-var deleteCookiesTool = async ({ name }) => {
+
+// src/resources/app-state.resource.ts
+init_state();
+import { ResourceTemplate as ResourceTemplate2 } from "@modelcontextprotocol/sdk/server/mcp";
+async function readAppState(bundleId) {
   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" }]
+    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"
     };
-  } catch (e) {
     return {
-      isError: true,
-      content: [{ type: "text", text: `Error deleting cookies: ${e}` }]
+      mimeType: "text/plain",
+      text: `App state for ${bundleId}: ${stateMap[state2] || "unknown: " + state2}`
     };
+  } catch (e) {
+    return { mimeType: "text/plain", text: `Error getting app state: ${e}` };
+  }
+}
+var appStateResource = {
+  name: "session-current-app-state",
+  template: new ResourceTemplate2("wdio://session/current/app-state/{bundleId}", { list: void 0 }),
+  description: "App state for a given bundle ID",
+  handler: async (uri, variables) => {
+    const result = await readAppState(variables.bundleId);
+    return { contents: [{ uri: uri.href, mimeType: result.mimeType, text: result.text }] };
   }
 };
 
-// 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)")
+// src/resources/contexts.resource.ts
+init_state();
+async function readContexts() {
+  try {
+    const browser = getBrowser();
+    const contexts = await browser.getContexts();
+    return { mimeType: "application/json", text: JSON.stringify(contexts) };
+  } catch (e) {
+    return { mimeType: "text/plain", text: `Error: ${e}` };
   }
-};
-var tapElementTool = async (args) => {
+}
+async function readCurrentContext() {
   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.tap({ x, y });
-      return {
-        content: [{ type: "text", text: `Tapped at coordinates: (${x}, ${y})` }]
-      };
-    }
-    return {
-      isError: true,
-      content: [{ type: "text", text: "Error: Must provide either selector or x,y coordinates" }]
-    };
+    const currentContext = await browser.getContext();
+    return { mimeType: "application/json", text: JSON.stringify(currentContext) };
   } catch (e) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: `Error tapping: ${e}` }]
-    };
+    return { mimeType: "text/plain", text: `Error: ${e}` };
   }
-};
-var swipeToolDefinition = {
-  name: "swipe",
-  description: "performs a swipe gesture in specified direction (mobile)",
-  inputSchema: {
-    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 contextsResource = {
+  name: "session-current-contexts",
+  uri: "wdio://session/current/contexts",
+  description: "Available contexts (NATIVE_APP, WEBVIEW)",
+  handler: async () => {
+    const result = await readContexts();
+    return { contents: [{ uri: "wdio://session/current/contexts", mimeType: result.mimeType, text: result.text }] };
   }
 };
-var contentToFingerDirection = {
-  up: "down",
-  down: "up",
-  left: "right",
-  right: "left"
+var contextResource = {
+  name: "session-current-context",
+  uri: "wdio://session/current/context",
+  description: "Currently active context",
+  handler: async () => {
+    const result = await readCurrentContext();
+    return { contents: [{ uri: "wdio://session/current/context", mimeType: result.mimeType, text: result.text }] };
+  }
 };
-var swipeTool = async (args) => {
+
+// src/resources/geolocation.resource.ts
+init_state();
+async function readGeolocation() {
   try {
     const browser = getBrowser();
-    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}` }]
-    };
+    const location = await browser.getGeoLocation();
+    return { mimeType: "application/json", text: JSON.stringify(location) };
   } catch (e) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: `Error swiping: ${e}` }]
-    };
+    return { mimeType: "text/plain", text: `Error: ${e}` };
   }
-};
-var dragAndDropToolDefinition = {
-  name: "drag_and_drop",
-  description: "drags an element to another element or coordinates (mobile)",
-  inputSchema: {
-    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 geolocationResource = {
+  name: "session-current-geolocation",
+  uri: "wdio://session/current/geolocation",
+  description: "Current device geolocation",
+  handler: async () => {
+    const result = await readGeolocation();
+    return { contents: [{ uri: "wdio://session/current/geolocation", mimeType: result.mimeType, text: result.text }] };
   }
 };
-var dragAndDropTool = async (args) => {
+
+// src/resources/tabs.resource.ts
+init_state();
+async function readTabs() {
   try {
     const browser = getBrowser();
-    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: `Dragged ${sourceSelector} to ${targetSelector}` }]
-      };
-    } else if (x !== void 0 && y !== void 0) {
-      await sourceElement.dragAndDrop({ x, y }, { duration });
-      return {
-        content: [{ type: "text", text: `Dragged ${sourceSelector} by (${x}, ${y})` }]
-      };
+    const handles = await browser.getWindowHandles();
+    const currentHandle = await browser.getWindowHandle();
+    const tabs = [];
+    for (const handle of handles) {
+      await browser.switchToWindow(handle);
+      tabs.push({
+        handle,
+        title: await browser.getTitle(),
+        url: await browser.getUrl(),
+        isActive: handle === currentHandle
+      });
     }
-    return {
-      isError: true,
-      content: [{ type: "text", text: "Error: Must provide either targetSelector or x,y coordinates" }]
-    };
+    await browser.switchToWindow(currentHandle);
+    return { mimeType: "application/json", text: JSON.stringify(tabs) };
   } catch (e) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: `Error dragging: ${e}` }]
-    };
+    return { mimeType: "text/plain", text: `Error: ${e}` };
+  }
+}
+var tabsResource = {
+  name: "session-current-tabs",
+  uri: "wdio://session/current/tabs",
+  description: "Browser tabs in the current session",
+  handler: async () => {
+    const result = await readTabs();
+    return { contents: [{ uri: "wdio://session/current/tabs", mimeType: result.mimeType, text: result.text }] };
   }
 };
 
-// src/tools/app-actions.tool.ts
-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: z12.string().describe("App bundle ID (e.g., com.example.app)")
+// src/tools/session.tool.ts
+init_state();
+import { remote } from "webdriverio";
+import { z as z14 } from "zod";
+
+// src/session/lifecycle.ts
+init_state();
+function handleSessionTransition(newSessionId) {
+  const state2 = getState();
+  if (state2.currentSession && state2.currentSession !== newSessionId) {
+    const outgoing = state2.sessionHistory.get(state2.currentSession);
+    if (outgoing) {
+      outgoing.steps.push({
+        index: outgoing.steps.length + 1,
+        tool: "__session_transition__",
+        params: { newSessionId },
+        status: "ok",
+        durationMs: 0,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      outgoing.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
   }
-};
-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"
+}
+function registerSession(sessionId, browser, metadata, historyEntry) {
+  const state2 = getState();
+  const oldSessionId = state2.currentSession;
+  if (oldSessionId && oldSessionId !== sessionId) {
+    handleSessionTransition(sessionId);
+  }
+  state2.browsers.set(sessionId, browser);
+  state2.sessionMetadata.set(sessionId, metadata);
+  state2.sessionHistory.set(sessionId, historyEntry);
+  state2.currentSession = sessionId;
+  if (oldSessionId && oldSessionId !== sessionId) {
+    const oldBrowser = state2.browsers.get(oldSessionId);
+    if (oldBrowser) {
+      oldBrowser.deleteSession().catch(() => {
+      });
+      state2.browsers.delete(oldSessionId);
+      state2.sessionMetadata.delete(oldSessionId);
+    }
+  }
+}
+async function closeSession(sessionId, detach, isAttached, force) {
+  const state2 = getState();
+  const browser = state2.browsers.get(sessionId);
+  if (!browser) return;
+  const history = state2.sessionHistory.get(sessionId);
+  if (history) {
+    history.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  if (force || !detach && !isAttached) {
+    await browser.deleteSession();
+  }
+  state2.browsers.delete(sessionId);
+  state2.sessionMetadata.delete(sessionId);
+  if (state2.currentSession === sessionId) {
+    state2.currentSession = null;
+  }
+}
+
+// src/providers/local-browser.provider.ts
+var LocalBrowserProvider = class {
+  name = "local-browser";
+  getConnectionConfig(_options) {
+    return {};
+  }
+  buildCapabilities(options) {
+    const selectedBrowser = options.browser ?? "chrome";
+    const headless = options.headless ?? true;
+    const windowWidth = options.windowWidth ?? 1920;
+    const windowHeight = options.windowHeight ?? 1080;
+    const userCapabilities = options.capabilities ?? {};
+    const headlessSupported = selectedBrowser !== "safari";
+    const effectiveHeadless = headless && headlessSupported;
+    const chromiumArgs = [
+      `--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 (effectiveHeadless) {
+      chromiumArgs.push("--headless=new");
+      chromiumArgs.push("--disable-gpu");
+      chromiumArgs.push("--disable-dev-shm-usage");
+    }
+    const firefoxArgs = [];
+    if (effectiveHeadless && selectedBrowser === "firefox") {
+      firefoxArgs.push("-headless");
+    }
+    const capabilities = {
+      acceptInsecureCerts: true
     };
-    return {
-      content: [
-        {
-          type: "text",
-          text: `App state for ${bundleId}: ${stateMap[state2] || "unknown: " + state2}`
+    switch (selectedBrowser) {
+      case "chrome":
+        capabilities.browserName = "chrome";
+        capabilities["goog:chromeOptions"] = { args: chromiumArgs };
+        break;
+      case "edge":
+        capabilities.browserName = "msedge";
+        capabilities["ms:edgeOptions"] = { args: chromiumArgs };
+        break;
+      case "firefox":
+        capabilities.browserName = "firefox";
+        if (firefoxArgs.length > 0) {
+          capabilities["moz:firefoxOptions"] = { args: firefoxArgs };
         }
-      ]
-    };
-  } catch (e) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: `Error getting app state: ${e}` }]
+        break;
+      case "safari":
+        capabilities.browserName = "safari";
+        break;
+    }
+    const mergedCapabilities = {
+      ...capabilities,
+      ...userCapabilities,
+      "goog:chromeOptions": this.mergeCapabilityOptions(capabilities["goog:chromeOptions"], userCapabilities["goog:chromeOptions"]),
+      "ms:edgeOptions": this.mergeCapabilityOptions(capabilities["ms:edgeOptions"], userCapabilities["ms:edgeOptions"]),
+      "moz:firefoxOptions": this.mergeCapabilityOptions(capabilities["moz:firefoxOptions"], userCapabilities["moz:firefoxOptions"])
     };
+    for (const [key, value] of Object.entries(mergedCapabilities)) {
+      if (value === void 0) {
+        delete mergedCapabilities[key];
+      }
+    }
+    return mergedCapabilities;
+  }
+  getSessionType(_options) {
+    return "browser";
+  }
+  shouldAutoDetach(_options) {
+    return false;
+  }
+  mergeCapabilityOptions(defaultOptions, customOptions) {
+    if (!defaultOptions || typeof defaultOptions !== "object" || !customOptions || typeof customOptions !== "object") {
+      return customOptions ?? defaultOptions;
+    }
+    const defaultRecord = defaultOptions;
+    const customRecord = customOptions;
+    const merged = { ...defaultRecord, ...customRecord };
+    if (Array.isArray(defaultRecord.args) || Array.isArray(customRecord.args)) {
+      merged.args = [
+        ...Array.isArray(defaultRecord.args) ? defaultRecord.args : [],
+        ...Array.isArray(customRecord.args) ? customRecord.args : []
+      ];
+    }
+    return merged;
+  }
+};
+var localBrowserProvider = new LocalBrowserProvider();
+
+// 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;
+  }
+  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;
+  }
+  for (const [key, value] of Object.entries(options)) {
+    if (!["deviceName", "platformVersion", "automationName", "autoGrantPermissions", "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;
   }
-};
-
-// src/tools/context.tool.ts
-import { z as z13 } from "zod";
-var getContextsToolDefinition = {
-  name: "get_contexts",
-  description: "lists available contexts (NATIVE_APP, WEBVIEW)",
-  inputSchema: {}
-};
-var getCurrentContextToolDefinition = {
-  name: "get_current_context",
-  description: "shows the currently active context",
-  inputSchema: {}
-};
-var switchContextToolDefinition = {
-  name: "switch_context",
-  description: "switches between native and webview contexts",
-  inputSchema: {
-    context: z13.string().describe(
-      'Context name to switch to (e.g., "NATIVE_APP", "WEBVIEW_com.example.app", or use index from get_contexts)'
-    )
+  if (options.noReset !== void 0) {
+    capabilities["appium:noReset"] = options.noReset;
   }
-};
-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 {
-      isError: true,
-      content: [{ type: "text", text: `Error getting contexts: ${e}` }]
-    };
+  if (options.fullReset !== void 0) {
+    capabilities["appium:fullReset"] = options.fullReset;
   }
-};
-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 {
-      isError: true,
-      content: [{ type: "text", text: `Error getting current context: ${e}` }]
-    };
+  if (options.newCommandTimeout !== void 0) {
+    capabilities["appium:newCommandTimeout"] = options.newCommandTimeout;
   }
-};
-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 {
-        throw new Error(`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 {
-      isError: true,
-      content: [{ type: "text", text: `Error switching context: ${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;
   }
-};
-
-// src/tools/device.tool.ts
-import { z as z14 } from "zod";
-var hideKeyboardToolDefinition = {
-  name: "hide_keyboard",
-  description: "hides the on-screen keyboard",
-  inputSchema: {}
-};
-var getGeolocationToolDefinition = {
-  name: "get_geolocation",
-  description: "gets current device geolocation",
-  inputSchema: {}
-};
-var rotateDeviceToolDefinition = {
-  name: "rotate_device",
-  description: "rotates device to portrait or landscape orientation",
-  inputSchema: {
-    orientation: z14.enum(["PORTRAIT", "LANDSCAPE"]).describe("Device orientation")
+  if (options.appWaitActivity) {
+    capabilities["appium:appWaitActivity"] = options.appWaitActivity;
   }
-};
-var setGeolocationToolDefinition = {
-  name: "set_geolocation",
-  description: "sets device geolocation (latitude, longitude, altitude)",
-  inputSchema: {
-    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)")
+  for (const [key, value] of Object.entries(options)) {
+    if (!["deviceName", "platformVersion", "automationName", "autoGrantPermissions", "autoAcceptAlerts", "autoDismissAlerts", "appWaitActivity", "noReset", "fullReset", "newCommandTimeout"].includes(
+      key
+    )) {
+      capabilities[`appium:${key}`] = value;
+    }
   }
-};
-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 {
-      isError: true,
-      content: [{ type: "text", text: `Error rotating device: ${e}` }]
+  return capabilities;
+}
+
+// src/providers/local-appium.provider.ts
+var LocalAppiumProvider = class {
+  name = "local-appium";
+  getConnectionConfig(options) {
+    const appiumConfig = options.appiumConfig;
+    const config = getAppiumServerConfig({
+      hostname: appiumConfig?.host,
+      port: appiumConfig?.port,
+      path: appiumConfig?.path
+    });
+    return { protocol: "http", ...config };
+  }
+  buildCapabilities(options) {
+    const platform2 = options.platform;
+    const appPath = options.appPath;
+    const deviceName = options.deviceName;
+    const platformVersion = options.platformVersion;
+    const autoGrantPermissions = options.autoGrantPermissions;
+    const autoAcceptAlerts = options.autoAcceptAlerts;
+    const autoDismissAlerts = options.autoDismissAlerts;
+    const udid = options.udid;
+    const noReset = options.noReset;
+    const fullReset = options.fullReset;
+    const newCommandTimeout = options.newCommandTimeout;
+    const appWaitActivity = options.appWaitActivity;
+    const userCapabilities = options.capabilities ?? {};
+    const capabilities = platform2 === "iOS" ? buildIOSCapabilities(appPath, {
+      deviceName,
+      platformVersion,
+      automationName: options.automationName || "XCUITest",
+      autoGrantPermissions,
+      autoAcceptAlerts,
+      autoDismissAlerts,
+      udid,
+      noReset,
+      fullReset,
+      newCommandTimeout
+    }) : buildAndroidCapabilities(appPath, {
+      deviceName,
+      platformVersion,
+      automationName: options.automationName || "UiAutomator2",
+      autoGrantPermissions,
+      autoAcceptAlerts,
+      autoDismissAlerts,
+      appWaitActivity,
+      noReset,
+      fullReset,
+      newCommandTimeout
+    });
+    const mergedCapabilities = {
+      ...capabilities,
+      ...userCapabilities
     };
+    for (const [key, value] of Object.entries(mergedCapabilities)) {
+      if (value === void 0) {
+        delete mergedCapabilities[key];
+      }
+    }
+    return mergedCapabilities;
   }
-};
-var hideKeyboardTool = async () => {
-  try {
-    const browser = getBrowser();
-    await browser.hideKeyboard();
-    return {
-      content: [{ type: "text", text: "Keyboard hidden" }]
-    };
-  } catch (e) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: `Error hiding keyboard: ${e}` }]
-    };
+  getSessionType(options) {
+    const platform2 = options.platform;
+    return platform2.toLowerCase();
   }
-};
-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 {
-      isError: true,
-      content: [{ type: "text", text: `Error getting geolocation: ${e}` }]
-    };
+  shouldAutoDetach(options) {
+    return options.noReset === true || !options.appPath;
   }
 };
-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) {
+var localAppiumProvider = new LocalAppiumProvider();
+
+// src/providers/cloud/browserstack.provider.ts
+var BrowserStackProvider = class {
+  name = "browserstack";
+  getConnectionConfig(_options) {
     return {
-      isError: true,
-      content: [{ type: "text", text: `Error setting geolocation: ${e}` }]
+      protocol: "https",
+      hostname: "hub.browserstack.com",
+      port: 443,
+      path: "/wd/hub",
+      user: process.env.BROWSERSTACK_USERNAME,
+      key: process.env.BROWSERSTACK_ACCESS_KEY
     };
   }
-};
-
-// 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.
-
-**Option B for browser interaction** \u2014 prefer get_visible_elements or click_element/set_value with a selector instead. Use execute_script only when no dedicated tool covers the action (e.g. reading computed values, triggering custom events, scrolling to a position).
-
-**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}`;
+  buildCapabilities(options) {
+    const platform2 = options.platform;
+    const userCapabilities = options.capabilities ?? {};
+    const browserstackLocal = options.browserstackLocal;
+    if (platform2 === "browser") {
+      const bstackOptions2 = {
+        browserVersion: options.browserVersion ?? "latest"
+      };
+      if (options.os) bstackOptions2.os = options.os;
+      if (options.osVersion) bstackOptions2.osVersion = options.osVersion;
+      if (browserstackLocal) bstackOptions2.local = true;
+      const reporting2 = options.reporting;
+      if (reporting2?.project) bstackOptions2.projectName = reporting2.project;
+      if (reporting2?.build) bstackOptions2.buildName = reporting2.build;
+      if (reporting2?.session) bstackOptions2.sessionName = reporting2.session;
+      return {
+        browserName: options.browser ?? "chrome",
+        "bstack:options": bstackOptions2,
+        ...userCapabilities
+      };
     }
-    return {
-      content: [{ type: "text", text: resultText }]
+    const bstackOptions = {
+      platformName: platform2,
+      deviceName: options.deviceName,
+      platformVersion: options.platformVersion,
+      deviceType: "phone",
+      appiumVersion: "3.1.0"
     };
-  } catch (e) {
+    if (browserstackLocal) bstackOptions.local = true;
+    const reporting = options.reporting;
+    if (reporting?.project) bstackOptions.projectName = reporting.project;
+    if (reporting?.build) bstackOptions.buildName = reporting.build;
+    if (reporting?.session) bstackOptions.sessionName = reporting.session;
+    const autoAcceptAlerts = options.autoAcceptAlerts;
+    const autoDismissAlerts = options.autoDismissAlerts;
     return {
-      isError: true,
-      content: [{ type: "text", text: `Error executing script: ${e}` }]
+      platformName: platform2,
+      "appium:app": options.app,
+      "appium:autoGrantPermissions": options.autoGrantPermissions ?? true,
+      "appium:autoAcceptAlerts": autoDismissAlerts ? void 0 : autoAcceptAlerts ?? true,
+      "appium:autoDismissAlerts": autoDismissAlerts,
+      "appium:newCommandTimeout": options.newCommandTimeout ?? 300,
+      "bstack:options": bstackOptions,
+      ...userCapabilities
     };
   }
+  getSessionType(options) {
+    const platform2 = options.platform;
+    if (platform2 === "browser") return "browser";
+    return platform2;
+  }
+  shouldAutoDetach(_options) {
+    return false;
+  }
 };
+var browserStackProvider = new BrowserStackProvider();
 
-// src/tools/attach-browser.tool.ts
-import { remote as remote3 } from "webdriverio";
-import { z as z16 } from "zod";
-var attachBrowserToolDefinition = {
-  name: "attach_browser",
-  description: `Attach to a Chrome instance already running with --remote-debugging-port.
+// src/providers/registry.ts
+function getProvider(providerName, platform2) {
+  if (providerName === "browserstack") return browserStackProvider;
+  return platform2 === "browser" ? localBrowserProvider : localAppiumProvider;
+}
 
-Use launch_chrome() first to prepare and launch Chrome with remote debugging enabled.`,
+// src/tools/session.tool.ts
+var platformEnum = z14.enum(["browser", "ios", "android"]);
+var browserEnum = z14.enum(["chrome", "firefox", "edge", "safari"]);
+var automationEnum = z14.enum(["XCUITest", "UiAutomator2"]);
+var startSessionToolDefinition = {
+  name: "start_session",
+  description: "Starts a browser or mobile app session. For local browser, use browser platform. For mobile apps, use ios or android platform. Use attach mode to connect to an existing Chrome instance.",
+  inputSchema: {
+    provider: z14.enum(["local", "browserstack"]).optional().default("local").describe("Session provider (default: local)"),
+    platform: platformEnum.describe("Session platform type"),
+    browser: browserEnum.optional().describe("Browser to launch (required for browser platform)"),
+    browserVersion: z14.string().optional().describe("Browser version (BrowserStack only, default: latest)"),
+    os: z14.string().optional().describe('Operating system (BrowserStack browser only, e.g. "Windows", "OS X")'),
+    osVersion: z14.string().optional().describe('OS version (BrowserStack browser only, e.g. "11", "Sequoia")'),
+    app: z14.string().optional().describe("BrowserStack app URL (bs://...) or custom_id for mobile sessions"),
+    reporting: z14.object({
+      project: z14.string().optional(),
+      build: z14.string().optional(),
+      session: z14.string().optional()
+    }).optional().describe("BrowserStack reporting labels (project, build, session)"),
+    headless: coerceBoolean.optional().default(true).describe("Run browser in headless mode (default: true)"),
+    windowWidth: z14.number().min(400).max(3840).optional().default(1920).describe("Browser window width"),
+    windowHeight: z14.number().min(400).max(2160).optional().default(1080).describe("Browser window height"),
+    deviceName: z14.string().optional().describe("Mobile device/emulator/simulator name (required for ios/android)"),
+    platformVersion: z14.string().optional().describe('OS version (e.g., "17.0", "14")'),
+    appPath: z14.string().optional().describe("Path to app file (.app/.apk/.ipa)"),
+    automationName: automationEnum.optional().describe("Automation driver"),
+    autoGrantPermissions: coerceBoolean.optional().describe("Auto-grant app permissions (default: true)"),
+    autoAcceptAlerts: coerceBoolean.optional().describe("Auto-accept alerts (default: true)"),
+    autoDismissAlerts: coerceBoolean.optional().describe("Auto-dismiss alerts (default: false)"),
+    appWaitActivity: z14.string().optional().describe("Activity to wait for on Android launch"),
+    udid: z14.string().optional().describe("Unique Device Identifier for iOS real device"),
+    noReset: coerceBoolean.optional().describe("Preserve app data between sessions"),
+    fullReset: coerceBoolean.optional().describe("Uninstall app before/after session"),
+    newCommandTimeout: z14.number().min(0).optional().default(300).describe("Appium command timeout in seconds"),
+    attach: coerceBoolean.optional().default(false).describe("Attach to existing Chrome instead of launching"),
+    attachConfig: z14.object({
+      port: z14.number().optional().default(9222),
+      host: z14.string().optional().default("localhost")
+    }).optional().describe("Chrome remote debugging connection (attach mode only, defaults: port 9222, host localhost)"),
+    appiumConfig: z14.object({
+      host: z14.string().optional(),
+      port: z14.number().optional(),
+      path: z14.string().optional()
+    }).optional().describe("Appium server connection (local provider only)"),
+    browserstackLocal: coerceBoolean.optional().default(false).describe("Enable BrowserStack Local tunnel for testing against local/internal URLs (BrowserStack only, default: false). IMPORTANT: The BrowserStack Local binary daemon MUST already be running before calling start_session, otherwise all navigation to local/internal URLs will fail with ERR_TUNNEL_CONNECTION_FAILED. Read the wdio://browserstack/local-binary resource for the platform-specific download URL and the exact daemon start command. Do not set this to true without first confirming the daemon is running."),
+    navigationUrl: z14.string().optional().describe("URL to navigate to after starting"),
+    capabilities: z14.record(z14.string(), z14.unknown()).optional().describe("Additional capabilities to merge")
+  }
+};
+var closeSessionToolDefinition = {
+  name: "close_session",
+  description: "Closes or detaches from the current browser or app session",
   inputSchema: {
-    port: z16.number().default(9222).describe("Chrome remote debugging port (default: 9222)"),
-    host: z16.string().default("localhost").describe("Host where Chrome is running (default: localhost)"),
-    navigationUrl: z16.string().optional().describe("URL to navigate to immediately after attaching")
+    detach: coerceBoolean.optional().describe("If true, disconnect without terminating (preserves app state). Default: false")
   }
 };
 async function closeStaleMappers(host, port) {
@@ -2763,7 +3387,7 @@ async function restoreAndSwitchToActiveTab(browser, activeTabUrl, allTabUrls) {
     }
   }
 }
-async function waitForCDP(host, port, timeoutMs = 1e4) {
+async function waitForCDP2(host, port, timeoutMs = 1e4) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     try {
@@ -2775,444 +3399,314 @@ async function waitForCDP(host, port, timeoutMs = 1e4) {
   }
   throw new Error(`Chrome did not expose CDP on ${host}:${port} within ${timeoutMs}ms`);
 }
-var attachBrowserTool = async ({
-  port = 9222,
-  host = "localhost",
-  navigationUrl
-}) => {
+async function startBrowserSession(args) {
+  const {
+    browser = "chrome",
+    headless = true,
+    windowWidth = 1920,
+    windowHeight = 1080,
+    navigationUrl,
+    capabilities: userCapabilities = {}
+  } = args;
+  const browserDisplayNames = {
+    chrome: "Chrome",
+    firefox: "Firefox",
+    edge: "Edge",
+    safari: "Safari"
+  };
+  const headlessSupported = browser !== "safari";
+  const effectiveHeadless = headless && headlessSupported;
+  const provider = getProvider(args.provider ?? "local", "browser");
+  const connectionConfig = provider.getConnectionConfig(args);
+  const mergedCapabilities = provider.buildCapabilities({
+    ...args,
+    browser,
+    headless,
+    windowWidth,
+    windowHeight,
+    capabilities: userCapabilities
+  });
+  const wdioBrowser = await remote({ ...connectionConfig, capabilities: mergedCapabilities });
+  const { sessionId } = wdioBrowser;
+  const sessionMetadata = {
+    type: "browser",
+    capabilities: mergedCapabilities,
+    isAttached: false
+  };
+  registerSession(sessionId, wdioBrowser, sessionMetadata, {
+    sessionId,
+    type: "browser",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    capabilities: mergedCapabilities,
+    steps: []
+  });
+  let sizeNote = "";
   try {
-    const state2 = getBrowser.__state;
-    await waitForCDP(host, port);
-    const { activeTabUrl, allTabUrls } = await closeStaleMappers(host, port);
-    const browser = await remote3({
-      connectionRetryTimeout: 3e4,
-      connectionRetryCount: 3,
-      capabilities: {
-        browserName: "chrome",
-        unhandledPromptBehavior: "dismiss",
-        webSocketUrl: false,
-        "goog:chromeOptions": {
-          debuggerAddress: `${host}:${port}`
-        }
-      }
-    });
-    const { sessionId } = browser;
-    state2.browsers.set(sessionId, browser);
-    state2.currentSession = sessionId;
-    state2.sessionMetadata.set(sessionId, {
-      type: "browser",
-      capabilities: browser.capabilities,
-      isAttached: true
-    });
-    state2.sessionHistory.set(sessionId, {
-      sessionId,
-      type: "browser",
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      capabilities: {
-        browserName: "chrome",
-        "goog:chromeOptions": {
-          debuggerAddress: `${host}:${port}`
-        }
-      },
-      steps: []
-    });
-    if (navigationUrl) {
-      await browser.url(navigationUrl);
-    } else if (activeTabUrl) {
-      await restoreAndSwitchToActiveTab(browser, activeTabUrl, allTabUrls);
-    }
-    const title = await browser.getTitle();
-    const url = await browser.getUrl();
-    return {
-      content: [{
-        type: "text",
-        text: `Attached to Chrome on ${host}:${port}
-Session ID: ${sessionId}
-Current page: "${title}" (${url})`
-      }]
-    };
+    await wdioBrowser.setWindowSize(windowWidth, windowHeight);
   } catch (e) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: `Error attaching to browser: ${e}` }]
-    };
-  }
-};
-
-// src/tools/launch-chrome.tool.ts
-import { spawn } from "child_process";
-import { copyFileSync, cpSync, existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
-import { homedir, platform, tmpdir } from "os";
-import { join } from "path";
-import { z as z17 } from "zod";
-var USER_DATA_DIR = join(tmpdir(), "chrome-debug");
-var launchChromeToolDefinition = {
-  name: "launch_chrome",
-  description: `Prepares and launches Chrome with remote debugging enabled so attach_browser() can connect.
-
-Two modes:
-
-  newInstance (default): Opens a Chrome window alongside your existing one using a separate
-    profile dir. Your current Chrome session is untouched.
-
-  freshSession: Launches Chrome with an empty profile (no cookies, no logins).
-
-Use copyProfileFiles: true to carry over your cookies and logins into the debug session.
-Note: changes made during the session won't sync back to your main profile.
-
-After this tool succeeds, call attach_browser() to connect.`,
-  inputSchema: {
-    port: z17.number().default(9222).describe("Remote debugging port (default: 9222)"),
-    mode: z17.enum(["newInstance", "freshSession"]).default("newInstance").describe(
-      "newInstance: open alongside existing Chrome | freshSession: clean profile"
-    ),
-    copyProfileFiles: z17.boolean().default(false).describe(
-      "Copy your Default Chrome profile (cookies, logins) into the debug session."
-    )
-  }
-};
-function isMac() {
-  return platform() === "darwin";
-}
-function chromeExec() {
-  if (isMac()) return "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
-  if (platform() === "win32") {
-    const candidates = [
-      join("C:", "Program Files", "Google", "Chrome", "Application", "chrome.exe"),
-      join("C:", "Program Files (x86)", "Google", "Chrome", "Application", "chrome.exe")
-    ];
-    return candidates.find((p) => existsSync(p)) ?? candidates[0];
-  }
-  return "google-chrome";
-}
-function defaultProfileDir() {
-  const home = homedir();
-  if (isMac()) return join(home, "Library", "Application Support", "Google", "Chrome");
-  if (platform() === "win32") return join(home, "AppData", "Local", "Google", "Chrome", "User Data");
-  return join(home, ".config", "google-chrome");
-}
-function copyProfile() {
-  const srcDir = defaultProfileDir();
-  rmSync(USER_DATA_DIR, { recursive: true, force: true });
-  mkdirSync(USER_DATA_DIR, { recursive: true });
-  copyFileSync(join(srcDir, "Local State"), join(USER_DATA_DIR, "Local State"));
-  cpSync(join(srcDir, "Default"), join(USER_DATA_DIR, "Default"), { recursive: true });
-  for (const f of ["SingletonLock", "SingletonCookie", "SingletonSocket"]) {
-    rmSync(join(USER_DATA_DIR, f), { force: true });
-  }
-  for (const f of ["Current Session", "Current Tabs", "Last Session", "Last Tabs"]) {
-    rmSync(join(USER_DATA_DIR, "Default", f), { force: true });
+    sizeNote = `
+Note: Unable to set window size (${windowWidth}x${windowHeight}). ${e}`;
   }
-  writeFileSync(join(USER_DATA_DIR, "First Run"), "");
-}
-function launchChrome(port) {
-  spawn(chromeExec(), [
-    `--remote-debugging-port=${port}`,
-    `--user-data-dir=${USER_DATA_DIR}`,
-    "--profile-directory=Default",
-    "--no-first-run",
-    "--disable-session-crashed-bubble"
-  ], { detached: true, stdio: "ignore" }).unref();
-}
-async function waitForCDP2(port, timeoutMs = 15e3) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetch(`http://localhost:${port}/json/version`);
-      if (res.ok) return;
-    } catch {
-    }
-    await new Promise((r) => setTimeout(r, 300));
+  if (navigationUrl) {
+    await wdioBrowser.url(navigationUrl);
   }
-  throw new Error(`Chrome did not expose CDP on port ${port} within ${timeoutMs}ms`);
+  const modeText = effectiveHeadless ? "headless" : "headed";
+  const urlText = navigationUrl ? ` and navigated to ${navigationUrl}` : "";
+  const headlessNote = headless && !headlessSupported ? "\nNote: Safari does not support headless mode. Started in headed mode." : "";
+  return {
+    content: [{
+      type: "text",
+      text: `${browserDisplayNames[browser]} browser started in ${modeText} mode with sessionId: ${sessionId} (${windowWidth}x${windowHeight})${urlText}${headlessNote}${sizeNote}`
+    }]
+  };
 }
-var launchChromeTool = async ({
-  port = 9222,
-  mode = "newInstance",
-  copyProfileFiles = false
-}) => {
-  const warnings = [];
-  const notes = [];
-  try {
-    if (copyProfileFiles) {
-      warnings.push("\u26A0\uFE0F  Cookies and logins were copied at this moment. Changes during this session won't sync back to your main profile.");
-      copyProfile();
-    } else {
-      notes.push(mode === "newInstance" ? "No profile copied \u2014 this instance starts with no cookies or logins." : "Fresh profile \u2014 no existing cookies or logins.");
-      rmSync(USER_DATA_DIR, { recursive: true, force: true });
-      mkdirSync(USER_DATA_DIR, { recursive: true });
-    }
-    launchChrome(port);
-    await waitForCDP2(port);
-    const lines = [
-      `Chrome launched on port ${port} (mode: ${mode}).`,
-      ...warnings,
-      ...notes
-    ];
-    return { content: [{ type: "text", text: lines.join("\n") }] };
-  } catch (e) {
+async function startMobileSession(args) {
+  const { platform: platform2, appPath, app, deviceName, noReset } = args;
+  if (!appPath && !app && noReset !== true) {
     return {
-      isError: true,
-      content: [{ type: "text", text: `Error launching Chrome: ${e}` }]
+      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.'
+      }]
     };
   }
-};
-
-// src/tools/emulate-device.tool.ts
-import { z as z18 } from "zod";
-var restoreFunctions = /* @__PURE__ */ new Map();
-var emulateDeviceToolDefinition = {
-  name: "emulate_device",
-  description: `Emulate a mobile or tablet device in the current browser session (sets viewport, DPR, user-agent, touch events).
-
-Requires a BiDi-enabled session: start_browser({ capabilities: { webSocketUrl: true } })
-
-Usage:
-  emulate_device()                    \u2014 list available device presets
-  emulate_device({ device: "iPhone 15" })  \u2014 activate emulation
-  emulate_device({ device: "reset" }) \u2014 restore desktop defaults`,
-  inputSchema: {
-    device: z18.string().optional().describe(
-      'Device preset name (e.g. "iPhone 15", "Pixel 7"). Omit to list available presets. Pass "reset" to restore desktop defaults.'
-    )
-  }
-};
-var emulateDeviceTool = async ({
-  device
-}) => {
-  try {
-    const browser = getBrowser();
-    const state2 = getBrowser.__state;
-    const sessionId = state2.currentSession;
-    const metadata = state2.sessionMetadata.get(sessionId);
-    if (metadata?.type === "ios" || metadata?.type === "android") {
-      return {
-        isError: true,
-        content: [{ type: "text", text: "Error: emulate_device is only supported for web browser sessions, not iOS/Android." }]
-      };
-    }
-    if (!browser.isBidi) {
-      return {
-        isError: true,
-        content: [{
-          type: "text",
-          text: "Error: emulate_device requires a BiDi-enabled session.\nRestart the browser with: start_browser({ capabilities: { webSocketUrl: true } })"
-        }]
-      };
-    }
-    if (!device) {
-      try {
-        await browser.emulate("device", "\0");
-      } catch (e) {
-        const msg = String(e);
-        const match = msg.match(/please use one of the following: (.+)$/);
-        if (match) {
-          const names = match[1].split(", ").sort();
-          return {
-            content: [{ type: "text", text: `Available devices (${names.length}):
-${names.join("\n")}` }]
-          };
-        }
-        return { isError: true, content: [{ type: "text", text: `Error listing devices: ${e}` }] };
-      }
-      return { content: [{ type: "text", text: "Could not retrieve device list." }] };
-    }
-    if (device === "reset") {
-      const restoreFn = restoreFunctions.get(sessionId);
-      if (!restoreFn) {
-        return { content: [{ type: "text", text: "No active device emulation to reset." }] };
-      }
-      await restoreFn();
-      restoreFunctions.delete(sessionId);
-      return { content: [{ type: "text", text: "Device emulation reset to desktop defaults." }] };
-    }
-    try {
-      const restoreFn = await browser.emulate("device", device);
-      restoreFunctions.set(sessionId, restoreFn);
-      return {
-        content: [{ type: "text", text: `Emulating "${device}".` }]
-      };
-    } catch (e) {
-      const msg = String(e);
-      if (msg.includes("Unknown device name")) {
-        return {
-          content: [{
-            type: "text",
-            text: `Error: Unknown device "${device}". Call emulate_device() with no arguments to list valid names.`
-          }]
-        };
+  const provider = getProvider(args.provider ?? "local", args.platform);
+  const serverConfig = provider.getConnectionConfig(args);
+  const mergedCapabilities = provider.buildCapabilities(args);
+  const browser = await remote({ ...serverConfig, capabilities: mergedCapabilities });
+  const { sessionId } = browser;
+  const shouldAutoDetach = provider.shouldAutoDetach(args);
+  const sessionType = provider.getSessionType(args);
+  const metadata = {
+    type: sessionType,
+    capabilities: mergedCapabilities,
+    isAttached: shouldAutoDetach
+  };
+  registerSession(sessionId, browser, metadata, {
+    sessionId,
+    type: sessionType,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    capabilities: mergedCapabilities,
+    appiumConfig: { hostname: serverConfig.hostname, port: serverConfig.port, path: serverConfig.path },
+    steps: []
+  });
+  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: `${platform2} app session started with sessionId: ${sessionId}
+Device: ${deviceName}${appInfo}
+Appium Server: ${serverConfig.hostname}:${serverConfig.port}${serverConfig.path}${detachNote}`
       }
-      return { isError: true, content: [{ type: "text", text: `Error: ${e}` }] };
+    ]
+  };
+}
+async function attachBrowserSession(args) {
+  const { port = 9222, host = "localhost" } = args.attachConfig ?? {};
+  const { navigationUrl } = args;
+  await waitForCDP2(host, port);
+  const { activeTabUrl, allTabUrls } = await closeStaleMappers(host, port);
+  const capabilities = {
+    browserName: "chrome",
+    unhandledPromptBehavior: "dismiss",
+    webSocketUrl: false,
+    "goog:chromeOptions": {
+      debuggerAddress: `${host}:${port}`
+    }
+  };
+  const browser = await remote({
+    connectionRetryTimeout: 3e4,
+    connectionRetryCount: 3,
+    capabilities
+  });
+  const { sessionId } = browser;
+  const sessionMetadata = {
+    type: "browser",
+    capabilities,
+    isAttached: true
+  };
+  registerSession(sessionId, browser, sessionMetadata, {
+    sessionId,
+    type: "browser",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    capabilities,
+    steps: []
+  });
+  if (navigationUrl) {
+    await browser.url(navigationUrl);
+  } else if (activeTabUrl) {
+    await restoreAndSwitchToActiveTab(browser, activeTabUrl, allTabUrls);
+  }
+  const title = await browser.getTitle();
+  const url = await browser.getUrl();
+  return {
+    content: [{
+      type: "text",
+      text: `Attached to Chrome on ${host}:${port}
+Session ID: ${sessionId}
+Current page: "${title}" (${url})`
+    }]
+  };
+}
+var startSessionTool = async (args) => {
+  try {
+    if (args.platform === "browser") {
+      if (args.attach) {
+        return await attachBrowserSession(args);
+      }
+      return await startBrowserSession(args);
     }
+    return await startMobileSession(args);
   } catch (e) {
+    return { isError: true, content: [{ type: "text", text: `Error starting session: ${e}` }] };
+  }
+};
+var closeSessionTool = async (args = {}) => {
+  try {
+    getBrowser();
+    const state2 = getState();
+    const sessionId = state2.currentSession;
+    const metadata = state2.sessionMetadata.get(sessionId);
+    const isAttached = !!metadata?.isAttached;
+    const detach = args.detach ?? false;
+    const force = !detach && isAttached;
+    const effectiveDetach = detach || isAttached;
+    await closeSession(sessionId, detach, isAttached, force);
+    const action = effectiveDetach && !force ? "detached from" : "closed";
+    const note = detach && !isAttached ? "\nNote: Session will remain active on Appium server." : "";
     return {
-      isError: true,
-      content: [{ type: "text", text: `Error: ${e}` }]
+      content: [{ type: "text", text: `Session ${sessionId} ${action}${note}` }]
     };
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: `Error closing session: ${e}` }] };
   }
 };
 
-// src/recording/step-recorder.ts
-function getState2() {
-  return getBrowser.__state;
-}
-function appendStep(toolName, params, status, durationMs, error) {
-  const state2 = getState2();
-  const sessionId = state2.currentSession;
-  if (!sessionId) return;
-  const history = state2.sessionHistory.get(sessionId);
-  if (!history) return;
-  const step = {
-    index: history.steps.length + 1,
-    tool: toolName,
-    params,
-    status,
-    durationMs,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    ...error !== void 0 && { error }
-  };
-  history.steps.push(step);
-}
-function getSessionHistory() {
-  return getState2().sessionHistory;
-}
-function extractErrorText(result) {
-  const textContent = result.content.find((c) => c.type === "text");
-  return textContent ? textContent.text : "Unknown error";
-}
-function withRecording(toolName, callback) {
-  return async (params, extra) => {
-    const start = Date.now();
-    const result = await callback(params, extra);
-    const isError = result.isError === true;
-    appendStep(
-      toolName,
-      params,
-      isError ? "error" : "ok",
-      Date.now() - start,
-      isError ? extractErrorText(result) : void 0
-    );
-    return result;
-  };
-}
-
-// src/recording/code-generator.ts
-function escapeStr(value) {
-  return String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-function formatParams(params) {
-  return Object.entries(params).map(([k, v]) => `${k}="${v}"`).join(" ");
-}
-function indentJson(value) {
-  return JSON.stringify(value, null, 2).split("\n").map((line, i) => i > 0 ? `  ${line}` : line).join("\n");
-}
-function generateStep(step, history) {
-  if (step.tool === "__session_transition__") {
-    const newId = step.params.newSessionId ?? "unknown";
-    return `// --- new session: ${newId} started at ${step.timestamp} ---`;
-  }
-  if (step.status === "error") {
-    return `// [error] ${step.tool}: ${formatParams(step.params)} \u2014 ${step.error ?? "unknown error"}`;
+// src/tools/tabs.tool.ts
+init_state();
+import { z as z15 } from "zod";
+var switchTabToolDefinition = {
+  name: "switch_tab",
+  description: "switches to a browser tab by handle or index",
+  inputSchema: {
+    handle: z15.string().optional().describe("Window handle to switch to"),
+    index: z15.number().int().min(0).optional().describe("0-based tab index to switch to")
   }
-  const p = step.params;
-  switch (step.tool) {
-    case "start_browser": {
-      const nav = p.navigationUrl ? `
-await browser.url('${escapeStr(p.navigationUrl)}');` : "";
-      return `const browser = await remote({
-  capabilities: ${indentJson(history.capabilities)}
-});${nav}`;
-    }
-    case "start_app_session": {
-      const config = {
-        protocol: "http",
-        hostname: history.appiumConfig?.hostname ?? "localhost",
-        port: history.appiumConfig?.port ?? 4723,
-        path: history.appiumConfig?.path ?? "/",
-        capabilities: history.capabilities
-      };
-      return `const browser = await remote(${indentJson(config)});`;
-    }
-    case "attach_browser": {
-      const nav = p.navigationUrl ? `
-await browser.url('${escapeStr(p.navigationUrl)}');` : "";
-      return `const browser = await remote({
-  capabilities: ${indentJson(history.capabilities)}
-});${nav}`;
-    }
-    case "navigate":
-      return `await browser.url('${escapeStr(p.url)}');`;
-    case "click_element":
-      return `await browser.$('${escapeStr(p.selector)}').click();`;
-    case "set_value":
-      return `await browser.$('${escapeStr(p.selector)}').setValue('${escapeStr(p.value)}');`;
-    case "scroll": {
-      const scrollAmount = p.direction === "down" ? p.pixels : -p.pixels;
-      return `await browser.execute(() => window.scrollBy(0, ${scrollAmount}));`;
-    }
-    case "tap_element":
-      if (p.selector !== void 0) {
-        return `await browser.$('${escapeStr(p.selector)}').click();`;
-      }
-      return `await browser.tap({ x: ${p.x}, y: ${p.y} });`;
-    case "swipe":
-      return `await browser.execute('mobile: swipe', { direction: '${escapeStr(p.direction)}' });`;
-    case "drag_and_drop":
-      if (p.targetSelector !== void 0) {
-        return `await browser.$('${escapeStr(p.sourceSelector)}').dragAndDrop(browser.$('${escapeStr(p.targetSelector)}'));`;
+};
+var switchTabTool = async ({ handle, index }) => {
+  try {
+    const browser = getBrowser();
+    if (handle) {
+      await browser.switchToWindow(handle);
+      return { content: [{ type: "text", text: `Switched to tab: ${handle}` }] };
+    } else if (index !== void 0) {
+      const handles = await browser.getWindowHandles();
+      if (index >= handles.length) {
+        return { isError: true, content: [{ type: "text", text: `Error: index ${index} out of range (${handles.length} tabs)` }] };
       }
-      return `await browser.$('${escapeStr(p.sourceSelector)}').dragAndDrop({ x: ${p.x}, y: ${p.y} });`;
-    default:
-      return `// [unknown tool] ${step.tool}`;
+      await browser.switchToWindow(handles[index]);
+      return { content: [{ type: "text", text: `Switched to tab ${index}: ${handles[index]}` }] };
+    }
+    return { isError: true, content: [{ type: "text", text: "Error: Must provide either handle or index" }] };
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: `Error switching tab: ${e}` }] };
   }
-}
-function generateCode(history) {
-  const steps = history.steps.map((step) => generateStep(step, history)).join("\n");
-  return `import { remote } from 'webdriverio';
-
-${steps}
+};
 
-await browser.deleteSession();`;
-}
+// src/tools/browserstack.tool.ts
+import { existsSync as existsSync2, createReadStream } from "fs";
+import { z as z16 } from "zod";
+var BS_API = "https://api-cloud.browserstack.com";
+function getAuth() {
+  const user = process.env.BROWSERSTACK_USERNAME;
+  const key = process.env.BROWSERSTACK_ACCESS_KEY;
+  if (!user || !key) return null;
+  return Buffer.from(`${user}:${key}`).toString("base64");
+}
+function formatAppList(apps) {
+  if (apps.length === 0) return "No apps found.";
+  return apps.map((a) => {
+    const id = a.custom_id ? ` [${a.custom_id}]` : "";
+    return `${a.app_name} v${a.app_version}${id} \u2014 ${a.app_url} (${a.uploaded_at})`;
+  }).join("\n");
+}
+var listAppsToolDefinition = {
+  name: "list_apps",
+  description: "List apps uploaded to BrowserStack App Automate. Reads BROWSERSTACK_USERNAME and BROWSERSTACK_ACCESS_KEY from environment.",
+  inputSchema: {
+    sortBy: z16.enum(["app_name", "uploaded_at"]).optional().default("uploaded_at").describe("Sort order for results"),
+    organizationWide: coerceBoolean.optional().default(false).describe("List apps uploaded by all users in the organization (uses recent_group_apps endpoint). Defaults to false (own uploads only)."),
+    limit: z16.number().int().min(1).optional().default(20).describe("Maximum number of apps to return (only applies when organizationWide is true, default 20)")
+  }
+};
+var listAppsTool = async ({ sortBy = "uploaded_at", organizationWide = false, limit = 20 }) => {
+  const auth = getAuth();
+  if (!auth) {
+    return { isError: true, content: [{ type: "text", text: "Missing credentials: set BROWSERSTACK_USERNAME and BROWSERSTACK_ACCESS_KEY environment variables." }] };
+  }
+  try {
+    let url = `${BS_API}/app-automate/${organizationWide ? "recent_group_apps" : "recent_apps"}`;
+    if (organizationWide && limit) url += `?limit=${limit}`;
+    const res = await fetch(url, {
+      headers: { Authorization: `Basic ${auth}` }
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      return { isError: true, content: [{ type: "text", text: `BrowserStack API error ${res.status}: ${body}` }] };
+    }
+    const raw = await res.json();
+    let apps = Array.isArray(raw) ? raw : [];
+    apps = sortBy === "app_name" ? apps.sort((a, b) => a.app_name.localeCompare(b.app_name)) : apps.sort((a, b) => new Date(b.uploaded_at).getTime() - new Date(a.uploaded_at).getTime());
+    return { content: [{ type: "text", text: formatAppList(apps) }] };
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: `Error listing apps: ${e}` }] };
+  }
+};
+var uploadAppToolDefinition = {
+  name: "upload_app",
+  description: "Upload a local .apk or .ipa to BrowserStack App Automate. Returns a bs:// URL for use in start_session.",
+  inputSchema: {
+    path: z16.string().describe("Absolute path to the .apk or .ipa file"),
+    customId: z16.string().optional().describe("Optional custom ID for the app (used to reference it later)")
+  }
+};
+var uploadAppTool = async ({ path, customId }) => {
+  const auth = getAuth();
+  if (!auth) {
+    return { isError: true, content: [{ type: "text", text: "Missing credentials: set BROWSERSTACK_USERNAME and BROWSERSTACK_ACCESS_KEY environment variables." }] };
+  }
+  if (!existsSync2(path)) {
+    return { isError: true, content: [{ type: "text", text: `File not found: ${path}` }] };
+  }
+  try {
+    const form = new FormData();
+    const stream = createReadStream(path);
+    const fileName = path.split("/").pop() ?? "app";
+    form.append("file", new Blob([stream]), fileName);
+    if (customId) form.append("custom_id", customId);
+    const res = await fetch(`${BS_API}/app-automate/upload`, {
+      method: "POST",
+      headers: { Authorization: `Basic ${auth}` },
+      body: form
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      return { isError: true, content: [{ type: "text", text: `Upload failed ${res.status}: ${body}` }] };
+    }
+    const data = await res.json();
+    const customIdNote = data.custom_id ? `
+Custom ID: ${data.custom_id}` : "";
+    return { content: [{ type: "text", text: `Upload successful.
+App URL: ${data.app_url}${customIdNote}
 
-// src/recording/resources.ts
-function getCurrentSessionId() {
-  return getBrowser.__state?.currentSession ?? null;
-}
-function buildSessionsIndex() {
-  const histories = getSessionHistory();
-  const currentId = getCurrentSessionId();
-  const sessions = Array.from(histories.values()).map((h) => ({
-    sessionId: h.sessionId,
-    type: h.type,
-    startedAt: h.startedAt,
-    ...h.endedAt ? { endedAt: h.endedAt } : {},
-    stepCount: h.steps.length,
-    isCurrent: h.sessionId === currentId
-  }));
-  return JSON.stringify({ sessions });
-}
-function buildCurrentSessionSteps() {
-  const currentId = getCurrentSessionId();
-  if (!currentId) return null;
-  return buildSessionStepsById(currentId);
-}
-function buildSessionStepsById(sessionId) {
-  const history = getSessionHistory().get(sessionId);
-  if (!history) return null;
-  return buildSessionPayload(history);
-}
-function buildSessionPayload(history) {
-  const stepsJson = JSON.stringify({
-    sessionId: history.sessionId,
-    type: history.type,
-    startedAt: history.startedAt,
-    ...history.endedAt ? { endedAt: history.endedAt } : {},
-    stepCount: history.steps.length,
-    steps: history.steps
-  });
-  return { stepsJson, generatedJs: generateCode(history) };
-}
+Use this URL as the "app" parameter in start_session with provider: "browserstack".` }] };
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: `Error uploading app: ${e}` }] };
+  }
+};
 
 // src/server.ts
 console.log = (...args) => console.error("[LOG]", ...args);
@@ -3236,102 +3730,61 @@ var registerTool = (definition, callback) => server.registerTool(definition.name
   description: definition.description,
   inputSchema: definition.inputSchema
 }, callback);
-registerTool(startBrowserToolDefinition, withRecording("start_browser", startBrowserTool));
-registerTool(startAppToolDefinition, withRecording("start_app_session", startAppTool));
+var registerResource = (definition) => {
+  if ("uri" in definition) {
+    server.registerResource(
+      definition.name,
+      definition.uri,
+      { description: definition.description },
+      definition.handler
+    );
+  } else {
+    server.registerResource(
+      definition.name,
+      definition.template,
+      { description: definition.description },
+      definition.handler
+    );
+  }
+};
+registerTool(startSessionToolDefinition, withRecording("start_session", startSessionTool));
 registerTool(closeSessionToolDefinition, closeSessionTool);
 registerTool(launchChromeToolDefinition, withRecording("launch_chrome", launchChromeTool));
-registerTool(attachBrowserToolDefinition, withRecording("attach_browser", attachBrowserTool));
 registerTool(emulateDeviceToolDefinition, emulateDeviceTool);
 registerTool(navigateToolDefinition, withRecording("navigate", navigateTool));
-registerTool(getVisibleElementsToolDefinition, getVisibleElementsTool);
-registerTool(getAccessibilityToolDefinition, getAccessibilityTreeTool);
+registerTool(switchTabToolDefinition, switchTabTool);
 registerTool(scrollToolDefinition, withRecording("scroll", scrollTool));
 registerTool(clickToolDefinition, withRecording("click_element", clickTool));
 registerTool(setValueToolDefinition, withRecording("set_value", setValueTool));
-registerTool(takeScreenshotToolDefinition, takeScreenshotTool);
-registerTool(getCookiesToolDefinition, getCookiesTool);
 registerTool(setCookieToolDefinition, setCookieTool);
 registerTool(deleteCookiesToolDefinition, deleteCookiesTool);
 registerTool(tapElementToolDefinition, withRecording("tap_element", tapElementTool));
 registerTool(swipeToolDefinition, withRecording("swipe", swipeTool));
 registerTool(dragAndDropToolDefinition, withRecording("drag_and_drop", dragAndDropTool));
-registerTool(getAppStateToolDefinition, getAppStateTool);
-registerTool(getContextsToolDefinition, getContextsTool);
-registerTool(getCurrentContextToolDefinition, getCurrentContextTool);
 registerTool(switchContextToolDefinition, switchContextTool);
 registerTool(rotateDeviceToolDefinition, rotateDeviceTool);
 registerTool(hideKeyboardToolDefinition, hideKeyboardTool);
-registerTool(getGeolocationToolDefinition, getGeolocationTool);
 registerTool(setGeolocationToolDefinition, setGeolocationTool);
-registerTool(executeScriptToolDefinition, executeScriptTool);
-server.registerResource(
-  "sessions",
-  "wdio://sessions",
-  { description: "JSON index of all browser and app sessions with metadata and step counts" },
-  async () => ({
-    contents: [{ uri: "wdio://sessions", mimeType: "application/json", text: buildSessionsIndex() }]
-  })
-);
-server.registerResource(
-  "session-current-steps",
-  "wdio://session/current/steps",
-  { description: "JSON step log for the currently active session" },
-  async () => {
-    const payload = buildCurrentSessionSteps();
-    return {
-      contents: [{
-        uri: "wdio://session/current/steps",
-        mimeType: "application/json",
-        text: payload?.stepsJson ?? '{"error":"No active session"}'
-      }]
-    };
-  }
-);
-server.registerResource(
-  "session-current-code",
-  "wdio://session/current/code",
-  { description: "Generated WebdriverIO JS code for the currently active session" },
-  async () => {
-    const payload = buildCurrentSessionSteps();
-    return {
-      contents: [{
-        uri: "wdio://session/current/code",
-        mimeType: "text/plain",
-        text: payload?.generatedJs ?? "// No active session"
-      }]
-    };
-  }
-);
-server.registerResource(
-  "session-steps",
-  new ResourceTemplate("wdio://session/{sessionId}/steps", { list: void 0 }),
-  { description: "JSON step log for a specific session by ID" },
-  async (uri, { sessionId }) => {
-    const payload = buildSessionStepsById(sessionId);
-    return {
-      contents: [{
-        uri: uri.href,
-        mimeType: "application/json",
-        text: payload?.stepsJson ?? `{"error":"Session not found: ${sessionId}"}`
-      }]
-    };
-  }
-);
-server.registerResource(
-  "session-code",
-  new ResourceTemplate("wdio://session/{sessionId}/code", { list: void 0 }),
-  { description: "Generated WebdriverIO JS code for a specific session by ID" },
-  async (uri, { sessionId }) => {
-    const payload = buildSessionStepsById(sessionId);
-    return {
-      contents: [{
-        uri: uri.href,
-        mimeType: "text/plain",
-        text: payload?.generatedJs ?? `// Session not found: ${sessionId}`
-      }]
-    };
-  }
-);
+registerTool(executeScriptToolDefinition, withRecording("execute_script", executeScriptTool));
+registerTool(getElementsToolDefinition, getElementsTool);
+registerTool(listAppsToolDefinition, listAppsTool);
+registerTool(uploadAppToolDefinition, uploadAppTool);
+registerResource(sessionsIndexResource);
+registerResource(sessionCurrentStepsResource);
+registerResource(sessionCurrentCodeResource);
+registerResource(sessionStepsResource);
+registerResource(sessionCodeResource);
+registerResource(browserstackLocalBinaryResource);
+registerResource(capabilitiesResource);
+registerResource(elementsResource);
+registerResource(accessibilityResource);
+registerResource(screenshotResource);
+registerResource(cookiesResource);
+registerResource(appStateResource);
+registerResource(contextsResource);
+registerResource(contextResource);
+registerResource(geolocationResource);
+registerResource(tabsResource);
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);