@wdio/mcp 3.2.4 → 3.3.0

package/lib/server.js

@@ -46,7 +46,7 @@ var package_default = {
     type: "git",
     url: "git://github.com/webdriverio/mcp.git"
   },
-  version: "3.2.3",
+  version: "3.2.5",
   description: "MCP server with WebdriverIO for browser and mobile app automation (iOS/Android via Appium)",
   main: "./lib/server.js",
   module: "./lib/server.js",
@@ -79,7 +79,9 @@ var package_default = {
     postbundle: "npm pack",
     lint: "eslint src/ tests/ --fix && tsc --noEmit",
     start: "node lib/server.js",
+    "start:http": "node lib/server.js --http --allowedOrigins http://localhost:8080",
     dev: "tsx --watch src/server.ts",
+    "dev:http": "tsx --watch src/server.ts --http --allowedOrigins http://localhost:8080",
     prepare: "husky",
     test: "vitest run"
   },
@@ -120,15 +122,58 @@ var package_default = {
 };
 
 // src/server.ts
+import http from "http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// src/utils/parse-args.ts
+function parseList(argv, flag) {
+  const idx = argv.indexOf(flag);
+  if (idx === -1) return null;
+  const raw = argv[idx + 1];
+  if (!raw || raw.startsWith("--")) {
+    throw new Error(`${flag} requires a comma-separated list`);
+  }
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function parseArgs(argv) {
+  const http2 = argv.includes("--http");
+  const portIdx = argv.indexOf("--port");
+  let port = 3e3;
+  if (portIdx !== -1) {
+    const raw = argv[portIdx + 1];
+    const parsed = Number(raw);
+    if (!raw || !Number.isInteger(parsed) || parsed <= 0) {
+      throw new Error("--port must be a valid number");
+    }
+    port = parsed;
+  }
+  const allowedHosts = parseList(argv, "--allowedHosts") ?? ["localhost", "127.0.0.1", "::1"];
+  const allowedOrigins = parseList(argv, "--allowedOrigins") ?? [];
+  return { http: http2, port, allowedHosts, allowedOrigins };
+}
+
+// src/utils/http-helpers.ts
+function extractHost(header) {
+  if (header.startsWith("[")) {
+    const end = header.indexOf("]");
+    return end === -1 ? header : header.slice(1, end);
+  }
+  return header.split(":")[0];
+}
+function sendJsonRpcError(res, httpStatus, code, message) {
+  const body = JSON.stringify({ jsonrpc: "2.0", id: null, error: { code, message } });
+  res.writeHead(httpStatus, { "Content-Type": "application/json" });
+  res.end(body);
+}
 
 // src/tools/navigate.tool.ts
 init_state();
 import { z } from "zod";
 var navigateToolDefinition = {
   name: "navigate",
-  description: "navigates to a URL",
+  description: "Loads a URL in the current tab and waits for the page load event. Resets page state (DOM, JS runtime). Use instead of clicking links to go directly to a known URL.",
   inputSchema: {
     url: z.string().min(1).describe("The URL to navigate to")
   }
@@ -169,7 +214,7 @@ var coerceBoolean = z2.preprocess((val) => {
 var defaultTimeout = 3e3;
 var clickToolDefinition = {
   name: "click_element",
-  description: "clicks an element",
+  description: "Waits for an element to exist, scrolls it into view, and calls element.click(). For browser sessions. On iOS, element.click() is sometimes ignored \u2014 use tap_element (which calls element.tap()) instead.",
   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: coerceBoolean.optional().describe("Whether to scroll the element into view before clicking").default(true),
@@ -202,7 +247,7 @@ import { z as z4 } from "zod";
 var defaultTimeout2 = 3e3;
 var setValueToolDefinition = {
   name: "set_value",
-  description: "set value to an element, aka typing",
+  description: "Clears an input or textarea and types the given text. Always replaces existing content. Fails if the element is not found or not interactable within the timeout.",
   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"),
@@ -271,7 +316,7 @@ var scrollTool = async ({ direction, pixels = 500 }) => scrollAction(direction,
 import { z as z6 } from "zod";
 var setCookieToolDefinition = {
   name: "set_cookie",
-  description: "sets a cookie with specified name, value, and optional attributes",
+  description: "Sets a browser cookie for the active session. The browser must already be on the target domain \u2014 cookies cannot be set cross-domain. Use to inject session tokens or feature flags without going through login flows.",
   inputSchema: {
     name: z6.string().describe("Cookie name"),
     value: z6.string().describe("Cookie value"),
@@ -342,7 +387,7 @@ init_state();
 import { z as z7 } from "zod";
 var tapElementToolDefinition = {
   name: "tap_element",
-  description: "taps an element by selector or screen coordinates (mobile)",
+  description: "Calls element.tap() on a matched element or taps at absolute screen coordinates. Use on iOS when element.click() (click_element) is ignored \u2014 tap is the native gesture iOS responds to. Mobile-only.",
   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)"),
@@ -379,7 +424,7 @@ var tapAction = async (args) => {
 var tapElementTool = async (args) => tapAction(args);
 var swipeToolDefinition = {
   name: "swipe",
-  description: "performs a swipe gesture in specified direction (mobile)",
+  description: 'Performs a full-screen swipe gesture on mobile. Direction is content movement (e.g. "up" scrolls a list upward, not the finger direction). Use to scroll past visible bounds; for moving a specific element use drag_and_drop. Mobile-only \u2014 use scroll for browsers.',
   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)"),
@@ -459,7 +504,7 @@ init_state();
 import { z as z8 } from "zod";
 var switchContextToolDefinition = {
   name: "switch_context",
-  description: "switches between native and webview contexts",
+  description: "Switches between native and webview automation contexts in a hybrid mobile app. Required before using CSS/XPath selectors inside an embedded webview \u2014 switch to WEBVIEW_* first, then switch back to NATIVE_APP for native elements. List available contexts using get_contexts tool or wdio://session/current/contexts resource.",
   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)'
@@ -497,19 +542,19 @@ init_state();
 import { z as z9 } from "zod";
 var hideKeyboardToolDefinition = {
   name: "hide_keyboard",
-  description: "hides the on-screen keyboard",
+  description: "Dismisses the software keyboard on mobile. Call after text entry when the keyboard obscures elements you need to interact with next. No-op if already hidden. Mobile-only.",
   inputSchema: {}
 };
 var rotateDeviceToolDefinition = {
   name: "rotate_device",
-  description: "rotates device to portrait or landscape orientation",
+  description: "Rotates a mobile device to portrait or landscape and waits for the OS rotation to complete. Use to test orientation-dependent layouts. Mobile-only; no effect in browser sessions.",
   inputSchema: {
     orientation: z9.enum(["PORTRAIT", "LANDSCAPE"]).describe("Device orientation")
   }
 };
 var setGeolocationToolDefinition = {
   name: "set_geolocation",
-  description: "sets device geolocation (latitude, longitude, altitude)",
+  description: "Overrides the device GPS coordinates for the session. Affects navigator.geolocation on web and location services on mobile. Location permissions must be granted to the app before calling this.",
   inputSchema: {
     latitude: z9.number().min(-90).max(90).describe("Latitude coordinate"),
     longitude: z9.number().min(-180).max(180).describe("Longitude coordinate"),
@@ -2855,7 +2900,7 @@ async function readCookies(name) {
     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) }) };
+    return { mimeType: "text/plain", text: `Error: ${e}` };
   }
 }
 var cookiesResource = {
@@ -2874,6 +2919,12 @@ import { ResourceTemplate as ResourceTemplate2 } from "@modelcontextprotocol/sdk
 async function readAppState(bundleId) {
   try {
     const browser = getBrowser();
+    if (!browser.isMobile) {
+      return {
+        mimeType: "text/plain",
+        text: "Error: get_app_state is mobile-only. Use it on an iOS or Android session."
+      };
+    }
     const appIdentifier = browser.isAndroid ? { appId: bundleId } : { bundleId };
     const state2 = await browser.execute("mobile: queryAppState", appIdentifier);
     const stateMap = {
@@ -3450,7 +3501,7 @@ 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.",
+  description: 'Starts a new browser or mobile automation session. Only one active session at a time \u2014 starting a new one closes the existing one. Use platform "browser" with a browser name, or "ios"/"android" with a deviceName. Use attach mode to connect to an already-running Chrome instance via CDP.',
   inputSchema: {
     provider: z14.enum(["local", "browserstack"]).optional().default("local").describe("Session provider (default: local)"),
     platform: platformEnum.describe("Session platform type"),
@@ -3496,7 +3547,7 @@ var startSessionToolDefinition = {
 };
 var closeSessionToolDefinition = {
   name: "close_session",
-  description: "Closes or detaches from the current browser or app session",
+  description: "Closes or detaches from the current session. Detach disconnects without terminating the process, preserving app state on the Appium server. Sessions started with noReset: true auto-detach by default.",
   inputSchema: {
     detach: coerceBoolean.optional().describe("If true, disconnect without terminating (preserves app state). Default: false")
   }
@@ -3746,7 +3797,7 @@ init_state();
 import { z as z15 } from "zod";
 var switchTabToolDefinition = {
   name: "switch_tab",
-  description: "switches to a browser tab by handle or index",
+  description: "Focuses a browser tab by window handle or 0-based index. All subsequent tool calls operate on the newly active tab. Get handles from get_tabs tool or wdio://session/current/tabs resource. Browser-only \u2014 use switch_context for mobile webviews.",
   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")
@@ -3864,87 +3915,272 @@ Use this URL as the "app" parameter in start_session with provider: "browserstac
   }
 };
 
+// src/tools/screenshot.tool.ts
+var screenshotToolDefinition = {
+  name: "get_screenshot",
+  description: "Takes a screenshot of the current page or screen and returns a base64-encoded image, resized and compressed for model context limits.",
+  inputSchema: {}
+};
+var screenshotTool = async () => {
+  const result = await readScreenshot();
+  if (result.mimeType === "text/plain") {
+    return { isError: true, content: [{ type: "text", text: Buffer.from(result.blob, "base64").toString("utf-8") }] };
+  }
+  return { content: [{ type: "image", data: result.blob, mimeType: result.mimeType }] };
+};
+
+// src/tools/accessibility.tool.ts
+import { z as z17 } from "zod";
+var accessibilityToolDefinition = {
+  name: "get_accessibility_tree",
+  description: "Returns the page accessibility tree with roles, names, and selectors. Browser-only. Supports filtering by ARIA roles and pagination via limit/offset.",
+  inputSchema: {
+    limit: z17.number().optional().default(0).describe("Maximum number of nodes to return (0 = no limit)"),
+    offset: z17.number().optional().default(0).describe("Number of nodes to skip for pagination"),
+    roles: z17.array(z17.string()).optional().describe('Filter by ARIA roles, e.g. ["button", "link", "heading"]')
+  }
+};
+var accessibilityTool = async ({ limit = 0, offset = 0, roles }) => {
+  const result = await readAccessibilityTree({ limit, offset, roles });
+  if (result.text.startsWith("Error")) {
+    return { isError: true, content: [{ type: "text", text: result.text }] };
+  }
+  return { content: [{ type: "text", text: result.text }] };
+};
+
+// src/tools/get-tabs.tool.ts
+var getTabsToolDefinition = {
+  name: "get_tabs",
+  description: "Lists all browser tabs with handle, title, URL, and which is active. Use before switch_tab to find the target handle or index. Browser-only.",
+  inputSchema: {}
+};
+var getTabsTool = async () => {
+  const result = await readTabs();
+  if (result.text.startsWith("Error")) {
+    return { isError: true, content: [{ type: "text", text: result.text }] };
+  }
+  return { content: [{ type: "text", text: result.text }] };
+};
+
+// src/tools/get-contexts.tool.ts
+var getContextsToolDefinition = {
+  name: "get_contexts",
+  description: "Returns available automation contexts and the currently active one. Use before switch_context to discover NATIVE_APP and WEBVIEW_* targets. Mobile-only.",
+  inputSchema: {}
+};
+var getContextsTool = async () => {
+  const [contexts, current] = await Promise.all([readContexts(), readCurrentContext()]);
+  if (contexts.mimeType === "text/plain" && contexts.text.startsWith("Error")) {
+    return { isError: true, content: [{ type: "text", text: contexts.text }] };
+  }
+  if (current.mimeType === "text/plain" && current.text.startsWith("Error")) {
+    return { isError: true, content: [{ type: "text", text: current.text }] };
+  }
+  const combined = {
+    contexts: JSON.parse(contexts.text),
+    currentContext: JSON.parse(current.text)
+  };
+  return { content: [{ type: "text", text: JSON.stringify(combined) }] };
+};
+
+// src/tools/app-state.tool.ts
+import { z as z18 } from "zod";
+var appStateToolDefinition = {
+  name: "get_app_state",
+  description: "Returns the current state of a mobile app: not installed, not running, background, or foreground. Mobile-only.",
+  inputSchema: {
+    bundleId: z18.string().describe('App bundle ID (iOS) or package name (Android), e.g. "com.example.app"')
+  }
+};
+var appStateTool = async ({ bundleId }) => {
+  const result = await readAppState(bundleId);
+  if (result.text.startsWith("Error")) {
+    return { isError: true, content: [{ type: "text", text: result.text }] };
+  }
+  return { content: [{ type: "text", text: result.text }] };
+};
+
+// src/tools/get-cookies.tool.ts
+import { z as z19 } from "zod";
+var getCookiesToolDefinition = {
+  name: "get_cookies",
+  description: "Returns all cookies for the current session, or a single cookie by name. Use to verify auth state, session tokens, or feature flags after login flows.",
+  inputSchema: {
+    name: z19.string().optional().describe("Cookie name to retrieve a specific cookie. If omitted, returns all cookies.")
+  }
+};
+var getCookiesTool = async ({ name }) => {
+  const result = await readCookies(name);
+  if (result.mimeType === "text/plain" && result.text.startsWith("Error")) {
+    return { isError: true, content: [{ type: "text", text: result.text }] };
+  }
+  return { content: [{ type: "text", text: result.text }] };
+};
+
 // src/server.ts
 console.log = (...args) => console.error("[LOG]", ...args);
 console.info = (...args) => console.error("[INFO]", ...args);
 console.warn = (...args) => console.error("[WARN]", ...args);
 console.debug = (...args) => console.error("[DEBUG]", ...args);
-var server = new McpServer({
-  title: "WebdriverIO MCP Server",
-  name: package_default.name,
-  version: package_default.version,
-  description: package_default.description,
-  websiteUrl: "https://github.com/webdriverio/mcp"
-}, {
-  instructions: "MCP server for browser and mobile app automation using WebDriverIO. Supports Chrome, Firefox, Edge, and Safari browser control plus iOS/Android native app testing via Appium.",
-  capabilities: {
-    tools: {},
-    resources: {}
-  }
-});
-var registerTool = (definition, callback) => server.registerTool(definition.name, {
-  description: definition.description,
-  inputSchema: definition.inputSchema
-}, callback);
-var registerResource = (definition) => {
-  if ("uri" in definition) {
-    server.registerResource(
-      definition.name,
-      definition.uri,
-      { description: definition.description },
-      definition.handler
-    );
+function createServer() {
+  const server = new McpServer({
+    title: "WebdriverIO MCP Server",
+    name: package_default.name,
+    version: package_default.version,
+    description: package_default.description,
+    websiteUrl: "https://github.com/webdriverio/mcp"
+  }, {
+    instructions: "MCP server for browser and mobile app automation using WebDriverIO. Supports Chrome, Firefox, Edge, and Safari browser control plus iOS/Android native app testing via Appium.",
+    capabilities: {
+      tools: {},
+      resources: {}
+    }
+  });
+  const registerTool = (definition, callback) => server.registerTool(definition.name, {
+    description: definition.description,
+    inputSchema: definition.inputSchema
+  }, callback);
+  const 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(emulateDeviceToolDefinition, emulateDeviceTool);
+  registerTool(navigateToolDefinition, withRecording("navigate", navigateTool));
+  registerTool(switchTabToolDefinition, switchTabTool);
+  registerTool(scrollToolDefinition, withRecording("scroll", scrollTool));
+  registerTool(clickToolDefinition, withRecording("click_element", clickTool));
+  registerTool(setValueToolDefinition, withRecording("set_value", setValueTool));
+  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(switchContextToolDefinition, switchContextTool);
+  registerTool(rotateDeviceToolDefinition, rotateDeviceTool);
+  registerTool(hideKeyboardToolDefinition, hideKeyboardTool);
+  registerTool(setGeolocationToolDefinition, setGeolocationTool);
+  registerTool(executeScriptToolDefinition, withRecording("execute_script", executeScriptTool));
+  registerTool(getElementsToolDefinition, getElementsTool);
+  registerTool(listAppsToolDefinition, listAppsTool);
+  registerTool(uploadAppToolDefinition, uploadAppTool);
+  registerTool(screenshotToolDefinition, screenshotTool);
+  registerTool(accessibilityToolDefinition, accessibilityTool);
+  registerTool(getTabsToolDefinition, getTabsTool);
+  registerTool(getContextsToolDefinition, getContextsTool);
+  registerTool(appStateToolDefinition, appStateTool);
+  registerTool(getCookiesToolDefinition, getCookiesTool);
+  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);
+  return server;
+}
+async function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+  } catch (e) {
+    console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+  }
+  if (args.http) {
+    http.createServer((req, res) => {
+      const host = extractHost(req.headers.host ?? "");
+      if (!args.allowedHosts.includes(host)) {
+        sendJsonRpcError(res, 403, -32e3, "Host not allowed");
+        return;
+      }
+      const origin = req.headers.origin;
+      if (origin) {
+        const wildcard = args.allowedOrigins.includes("*");
+        const allowed = wildcard || args.allowedOrigins.includes(origin);
+        if (!allowed) {
+          console.error(`[WARN] Blocked origin: ${origin}. Add --allowedOrigins ${origin} (or '*' for all) to allow it.`);
+          sendJsonRpcError(res, 403, -32e3, "Origin not allowed");
+          return;
+        }
+        res.setHeader("Access-Control-Allow-Origin", wildcard ? "*" : origin);
+        if (!wildcard) res.setHeader("Vary", "Origin");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Accept, mcp-session-id, mcp-protocol-version");
+      }
+      if (req.method === "OPTIONS") {
+        res.writeHead(204).end();
+        return;
+      }
+      if (!req.url?.startsWith("/mcp")) {
+        sendJsonRpcError(res, 404, -32601, "Not found");
+        return;
+      }
+      void (async () => {
+        try {
+          const chunks = [];
+          let totalSize = 0;
+          for await (const chunk of req) {
+            totalSize += chunk.length;
+            if (totalSize > 1024 * 1024) {
+              sendJsonRpcError(res, 413, -32600, "Payload too large");
+              return;
+            }
+            chunks.push(chunk);
+          }
+          const raw = Buffer.concat(chunks).toString();
+          let body;
+          try {
+            body = raw ? JSON.parse(raw) : void 0;
+          } catch {
+            sendJsonRpcError(res, 400, -32700, "Parse error");
+            return;
+          }
+          const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+          await createServer().connect(transport);
+          await transport.handleRequest(req, res, body);
+        } catch (e) {
+          const code = e.code;
+          if (code === "ECONNRESET" || code === "ECONNABORTED" || e.message === "aborted") return;
+          console.error("[WARN] Request failed:", e);
+          if (!res.headersSent) sendJsonRpcError(res, 500, -32603, "Internal error");
+        }
+      })();
+    }).listen(args.port, () => {
+      const originsMsg = args.allowedOrigins.length ? args.allowedOrigins.join(", ") : "(none \u2014 browsers blocked)";
+      console.error(`WebdriverIO MCP Server running on Streamable HTTP at http://localhost:${args.port}/mcp`);
+      console.error(`  allowed hosts:   ${args.allowedHosts.join(", ")}`);
+      console.error(`  allowed origins: ${originsMsg}`);
+    });
   } else {
-    server.registerResource(
-      definition.name,
-      definition.template,
-      { description: definition.description },
-      definition.handler
-    );
+    const transport = new StdioServerTransport();
+    await createServer().connect(transport);
+    console.error("WebdriverIO MCP Server running on stdio");
   }
-};
-registerTool(startSessionToolDefinition, withRecording("start_session", startSessionTool));
-registerTool(closeSessionToolDefinition, closeSessionTool);
-registerTool(launchChromeToolDefinition, withRecording("launch_chrome", launchChromeTool));
-registerTool(emulateDeviceToolDefinition, emulateDeviceTool);
-registerTool(navigateToolDefinition, withRecording("navigate", navigateTool));
-registerTool(switchTabToolDefinition, switchTabTool);
-registerTool(scrollToolDefinition, withRecording("scroll", scrollTool));
-registerTool(clickToolDefinition, withRecording("click_element", clickTool));
-registerTool(setValueToolDefinition, withRecording("set_value", setValueTool));
-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(switchContextToolDefinition, switchContextTool);
-registerTool(rotateDeviceToolDefinition, rotateDeviceTool);
-registerTool(hideKeyboardToolDefinition, hideKeyboardTool);
-registerTool(setGeolocationToolDefinition, setGeolocationTool);
-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);
-  console.error("WebdriverIO MCP Server running on stdio");
 }
 main().catch((error) => {
   console.error("Fatal error in main():", error);