@wdio/mcp 2.4.0 → 2.4.1

package/lib/server.js

@@ -11,7 +11,7 @@ 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",
+  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),
@@ -31,7 +31,8 @@ var closeSessionToolDefinition = {
 var state = {
   browsers: /* @__PURE__ */ new Map(),
   currentSession: null,
-  sessionMetadata: /* @__PURE__ */ new Map()
+  sessionMetadata: /* @__PURE__ */ new Map(),
+  sessionHistory: /* @__PURE__ */ new Map()
 };
 var getBrowser = () => {
   const browser = state.browsers.get(state.currentSession);
@@ -132,12 +133,40 @@ var startBrowserTool = async ({
   });
   const { sessionId } = wdioBrowser;
   state.browsers.set(sessionId, wdioBrowser);
-  state.currentSession = sessionId;
   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: [{
+      index: 1,
+      tool: "start_browser",
+      params: { browser, headless, windowWidth, windowHeight, ...navigationUrl && { navigationUrl }, ...Object.keys(userCapabilities).length > 0 && { capabilities: userCapabilities } },
+      status: "ok",
+      durationMs: 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }]
+  });
+  state.currentSession = sessionId;
   let sizeNote = "";
   try {
     await wdioBrowser.setWindowSize(windowWidth, windowHeight);
@@ -164,6 +193,10 @@ var closeSessionTool = async (args = {}) => {
     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();
@@ -464,12 +497,58 @@ var startAppTool = async (args) => {
     const shouldAutoDetach = noReset === true || !appPath;
     const state2 = getState();
     state2.browsers.set(sessionId, browser);
-    state2.currentSession = sessionId;
     state2.sessionMetadata.set(sessionId, {
       type: platform.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();
+      }
+    }
+    state2.sessionHistory.set(sessionId, {
+      sessionId,
+      type: platform.toLowerCase(),
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities: mergedCapabilities,
+      steps: [{
+        index: 1,
+        tool: "start_app_session",
+        params: {
+          platform,
+          deviceName,
+          ...platformVersion !== void 0 && { platformVersion },
+          ...automationName !== void 0 && { automationName },
+          ...appPath !== void 0 && { appPath },
+          ...udid !== void 0 && { udid },
+          ...noReset !== void 0 && { noReset },
+          ...fullReset !== void 0 && { fullReset },
+          ...autoGrantPermissions !== void 0 && { autoGrantPermissions },
+          ...autoAcceptAlerts !== void 0 && { autoAcceptAlerts },
+          ...autoDismissAlerts !== void 0 && { autoDismissAlerts },
+          ...appWaitActivity !== void 0 && { appWaitActivity },
+          ...newCommandTimeout !== void 0 && { newCommandTimeout },
+          ...appiumHost !== void 0 && { appiumHost },
+          ...appiumPort !== void 0 && { appiumPort },
+          ...appiumPath !== void 0 && { appiumPath },
+          ...Object.keys(userCapabilities).length > 0 && { capabilities: userCapabilities }
+        },
+        status: "ok",
+        durationMs: 0,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }]
+    });
+    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.)" : "";
@@ -1905,7 +1984,7 @@ var accessibilityTreeScript = () => (function() {
     if (ariaLevel) return parseInt(ariaLevel, 10);
     return void 0;
   }
-  function getState2(el) {
+  function getState3(el) {
     const inputEl = el;
     const isCheckable = ["input", "menuitemcheckbox", "menuitemradio"].includes(el.tagName.toLowerCase()) || ["checkbox", "radio", "switch"].includes(el.getAttribute("role") || "");
     return {
@@ -1933,7 +2012,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) ?? "", ...getState2(el) };
+    const node = { role, name, selector, level: getLevel(el) ?? "", ...getState3(el) };
     result.push(node);
     for (const child of Array.from(el.children)) {
       walk(child, depth + 1);
@@ -2758,7 +2837,7 @@ var package_default = {
     type: "git",
     url: "git://github.com/webdriverio/mcp.git"
   },
-  version: "2.3.1",
+  version: "2.4.0",
   description: "MCP server with WebdriverIO for browser and mobile app automation (iOS/Android via Appium)",
   main: "./lib/server.js",
   module: "./lib/server.js",
@@ -2826,6 +2905,206 @@ var package_default = {
   packageManager: "pnpm@10.12.4"
 };
 
+// src/server.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// 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.content.some(
+      (c) => c.type === "text" && typeof c.text === "string" && c.text.startsWith("Error")
+    );
+    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) {
+  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_browser": {
+      const browserName = p.browser === "edge" ? "msedge" : String(p.browser ?? "chrome");
+      const headless = p.headless !== false;
+      const width = p.windowWidth ?? 1920;
+      const height = p.windowHeight ?? 1080;
+      const args = [`--window-size=${width},${height}`];
+      if (headless && browserName !== "safari") {
+        args.push("--headless=new", "--disable-gpu", "--disable-dev-shm-usage");
+      }
+      const caps = { browserName };
+      if (browserName === "chrome") caps["goog:chromeOptions"] = { args };
+      else if (browserName === "msedge") caps["ms:edgeOptions"] = { args };
+      else if (browserName === "firefox" && headless) caps["moz:firefoxOptions"] = { args: ["-headless"] };
+      const extra = p.capabilities;
+      const merged = extra ? { ...caps, ...extra } : caps;
+      const nav = p.navigationUrl ? `
+await browser.url('${escapeStr(p.navigationUrl)}');` : "";
+      return `const browser = await remote({
+  capabilities: ${indentJson(merged)}
+});${nav}`;
+    }
+    case "start_app_session": {
+      const caps = {
+        platformName: p.platform,
+        "appium:deviceName": p.deviceName,
+        ...p.platformVersion !== void 0 && { "appium:platformVersion": p.platformVersion },
+        ...p.automationName !== void 0 && { "appium:automationName": p.automationName },
+        ...p.appPath !== void 0 && { "appium:app": p.appPath },
+        ...p.udid !== void 0 && { "appium:udid": p.udid },
+        ...p.noReset !== void 0 && { "appium:noReset": p.noReset },
+        ...p.fullReset !== void 0 && { "appium:fullReset": p.fullReset },
+        ...p.autoGrantPermissions !== void 0 && { "appium:autoGrantPermissions": p.autoGrantPermissions },
+        ...p.autoAcceptAlerts !== void 0 && { "appium:autoAcceptAlerts": p.autoAcceptAlerts },
+        ...p.autoDismissAlerts !== void 0 && { "appium:autoDismissAlerts": p.autoDismissAlerts },
+        ...p.appWaitActivity !== void 0 && { "appium:appWaitActivity": p.appWaitActivity },
+        ...p.newCommandTimeout !== void 0 && { "appium:newCommandTimeout": p.newCommandTimeout },
+        ...p.capabilities ?? {}
+      };
+      const config = {
+        protocol: "http",
+        hostname: p.appiumHost ?? "localhost",
+        port: p.appiumPort ?? 4723,
+        path: p.appiumPath ?? "/",
+        capabilities: caps
+      };
+      return `const browser = await remote(${indentJson(config)});`;
+    }
+    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} });`;
+    default:
+      return `// [unknown tool] ${step.tool}`;
+  }
+}
+function generateCode(history) {
+  const steps = history.steps.map(generateStep).join("\n");
+  return `import { remote } from 'webdriverio';
+
+${steps}
+
+await browser.deleteSession();`;
+}
+
+// src/recording/resources.ts
+function getCurrentSessionId() {
+  return getBrowser.__state?.currentSession ?? null;
+}
+function buildSessionsIndex() {
+  const histories = getSessionHistory();
+  if (histories.size === 0) return "No sessions recorded.";
+  const currentId = getCurrentSessionId();
+  const lines = [`Sessions (${histories.size} total):
+`];
+  for (const [id, h] of histories) {
+    const ended = h.endedAt ?? "-";
+    const current = id === currentId ? "  [current]" : "";
+    lines.push(`- ${id}  ${h.type}  started: ${h.startedAt}  ended: ${ended}  ${h.steps.length} steps${current}`);
+  }
+  return lines.join("\n");
+}
+function buildCurrentSessionSteps() {
+  const currentId = getCurrentSessionId();
+  if (!currentId) return "No active session.";
+  return buildSessionStepsById(currentId);
+}
+function buildSessionStepsById(sessionId) {
+  const history = getSessionHistory().get(sessionId);
+  if (!history) return `Session not found: ${sessionId}`;
+  return formatSessionSteps(history);
+}
+function formatSessionSteps(history) {
+  const header = `Session: ${history.sessionId} (${history.type}) \u2014 ${history.steps.length} steps
+`;
+  const stepLines = history.steps.map((step) => {
+    if (step.tool === "__session_transition__") {
+      return `--- session transitioned to ${step.params.newSessionId ?? "unknown"} at ${step.timestamp} ---`;
+    }
+    const statusLabel = step.status === "ok" ? "[ok]   " : "[error]";
+    const params = Object.entries(step.params).map(([k, v]) => `${k}="${v}"`).join(" ");
+    const errorSuffix = step.error ? ` \u2014 ${step.error}` : "";
+    return `${step.index}. ${statusLabel}  ${step.tool.padEnd(24)} ${params}${errorSuffix}  ${step.durationMs}ms`;
+  });
+  const stepsText = stepLines.length > 0 ? stepLines.join("\n") : "(no steps yet)";
+  const jsCode = generateCode(history);
+  return `${header}
+Steps:
+${stepsText}
+
+--- Generated WebdriverIO JS ---
+${jsCode}`;
+}
+
 // src/server.ts
 console.log = (...args) => console.error("[LOG]", ...args);
 console.info = (...args) => console.error("[INFO]", ...args);
@@ -2840,7 +3119,8 @@ var server = new McpServer({
 }, {
   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: {}
+    tools: {},
+    resources: {}
   }
 });
 var registerTool = (definition, callback) => server.registerTool(definition.name, {
@@ -2852,19 +3132,19 @@ registerTool(startAppToolDefinition, startAppTool);
 registerTool(closeSessionToolDefinition, closeSessionTool);
 registerTool(attachBrowserToolDefinition, attachBrowserTool);
 registerTool(emulateDeviceToolDefinition, emulateDeviceTool);
-registerTool(navigateToolDefinition, navigateTool);
+registerTool(navigateToolDefinition, withRecording("navigate", navigateTool));
 registerTool(getVisibleElementsToolDefinition, getVisibleElementsTool);
 registerTool(getAccessibilityToolDefinition, getAccessibilityTreeTool);
-registerTool(scrollToolDefinition, scrollTool);
-registerTool(clickToolDefinition, clickTool);
-registerTool(setValueToolDefinition, setValueTool);
+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, tapElementTool);
-registerTool(swipeToolDefinition, swipeTool);
-registerTool(dragAndDropToolDefinition, dragAndDropTool);
+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);
@@ -2874,6 +3154,34 @@ registerTool(hideKeyboardToolDefinition, hideKeyboardTool);
 registerTool(getGeolocationToolDefinition, getGeolocationTool);
 registerTool(setGeolocationToolDefinition, setGeolocationTool);
 registerTool(executeScriptToolDefinition, executeScriptTool);
+server.registerResource(
+  "sessions",
+  "wdio://sessions",
+  { description: "Index of all browser and app sessions with step counts" },
+  async () => ({
+    contents: [{ uri: "wdio://sessions", mimeType: "text/plain", text: buildSessionsIndex() }]
+  })
+);
+server.registerResource(
+  "session-current-steps",
+  "wdio://session/current/steps",
+  { description: "Steps for the currently active session with generated WebdriverIO JS" },
+  async () => ({
+    contents: [{ uri: "wdio://session/current/steps", mimeType: "text/plain", text: buildCurrentSessionSteps() }]
+  })
+);
+server.registerResource(
+  "session-steps",
+  new ResourceTemplate("wdio://session/{sessionId}/steps", { list: void 0 }),
+  { description: "Steps for a specific session by ID with generated WebdriverIO JS" },
+  async (uri, { sessionId }) => ({
+    contents: [{
+      uri: uri.href,
+      mimeType: "text/plain",
+      text: buildSessionStepsById(sessionId)
+    }]
+  })
+);
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);