@wdio/mcp 2.3.1 → 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,13 +193,18 @@ var closeSessionTool = async (args = {}) => {
     const browser = getBrowser();
     const sessionId = state.currentSession;
     const metadata = state.sessionMetadata.get(sessionId);
-    if (!args.detach) {
+    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 = args.detach ? "detached from" : "closed";
+    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}` }]
@@ -375,7 +409,7 @@ var startAppToolDefinition = {
     udid: z5.string().optional().describe('Unique Device Identifier for iOS real device testing (e.g., "00008030-001234567890002E")'),
     noReset: z5.boolean().optional().describe("Do not reset app state before session (preserves app data). Default: false"),
     fullReset: z5.boolean().optional().describe("Uninstall app before/after session. Default: true. Set to false with noReset=true to preserve app state completely"),
-    newCommandTimeout: z5.number().min(0).optional().describe("How long (in seconds) Appium will wait for a new command before assuming the client has quit and ending the session. Default: 60. Set to 300 for 5 minutes, etc."),
+    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)")
   }
 };
@@ -404,7 +438,7 @@ var startAppTool = async (args) => {
       udid,
       noReset,
       fullReset,
-      newCommandTimeout,
+      newCommandTimeout = 300,
       capabilities: userCapabilities = {}
     } = args;
     if (!appPath && noReset !== true) {
@@ -463,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.)" : "";
@@ -1904,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 {
@@ -1932,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);
@@ -2569,6 +2649,186 @@ var executeScriptTool = async (args) => {
   }
 };
 
+// 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.
+
+Start Chrome first (quit any running Chrome instance before launching):
+
+  macOS \u2014 with real profile (preserves extensions, cookies, logins):
+    pkill -x "Google Chrome" && sleep 1
+    /Applications/Google Chrome.app/Contents/MacOS/Google Chrome --remote-debugging-port=9222 --user-data-dir="$HOME/Library/Application Support/Google/Chrome" --profile-directory=Default &
+
+  macOS \u2014 with fresh profile (lightweight, no extensions):
+    pkill -x "Google Chrome" && sleep 1
+    /Applications/Google Chrome.app/Contents/MacOS/Google Chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-debug &
+
+  Linux \u2014 with real profile:
+    google-chrome --remote-debugging-port=9222 --user-data-dir="$HOME/.config/google-chrome" --profile-directory=Default &
+
+  Linux \u2014 with fresh profile:
+    google-chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-debug &
+
+Verify Chrome is ready: curl http://localhost:9222/json/version
+
+Then call attach_browser() to hand control to the AI. All other tools (navigate, click, get_visible_elements, etc.) will work on the attached session. Use close_session() to detach without closing Chrome.`,
+  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)"),
+    userDataDir: z16.string().default("/tmp/chrome-debug").describe('Chrome user data directory \u2014 must match the --user-data-dir used when launching Chrome. Use your real profile path (e.g. "$HOME/Library/Application Support/Google/Chrome") to preserve extensions and logins, or /tmp/chrome-debug for a fresh profile (default: /tmp/chrome-debug)'),
+    navigationUrl: z16.string().optional().describe("URL to navigate to immediately after attaching")
+  }
+};
+async function getActiveTabUrl(host, port) {
+  try {
+    const res = await fetch(`http://${host}:${port}/json`);
+    const tabs = await res.json();
+    const page = tabs.find((t) => t.type === "page" && t.url && !t.url.startsWith("devtools://"));
+    return page?.url ?? null;
+  } catch {
+    return null;
+  }
+}
+var attachBrowserTool = async ({
+  port = 9222,
+  host = "localhost",
+  userDataDir = "/tmp/chrome-debug",
+  navigationUrl
+}) => {
+  try {
+    const state2 = getBrowser.__state;
+    const activeUrl = navigationUrl ?? await getActiveTabUrl(host, port);
+    const browser = await remote3({
+      capabilities: {
+        browserName: "chrome",
+        "goog:chromeOptions": {
+          debuggerAddress: `${host}:${port}`,
+          args: [`--user-data-dir=${userDataDir}`]
+        }
+      }
+    });
+    const { sessionId } = browser;
+    state2.browsers.set(sessionId, browser);
+    state2.currentSession = sessionId;
+    state2.sessionMetadata.set(sessionId, {
+      type: "browser",
+      capabilities: browser.capabilities,
+      isAttached: true
+    });
+    if (activeUrl) {
+      await browser.url(activeUrl);
+    }
+    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})`
+      }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error attaching to browser: ${e}` }]
+    };
+  }
+};
+
+// src/tools/emulate-device.tool.ts
+import { z as z17 } 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: z17.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 {
+        content: [{ type: "text", text: "Error: emulate_device is only supported for web browser sessions, not iOS/Android." }]
+      };
+    }
+    if (!browser.isBidi) {
+      return {
+        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 { 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 { content: [{ type: "text", text: `Error: ${e}` }] };
+    }
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error: ${e}` }]
+    };
+  }
+};
+
 // package.json
 var package_default = {
   name: "@wdio/mcp",
@@ -2577,7 +2837,7 @@ var package_default = {
     type: "git",
     url: "git://github.com/webdriverio/mcp.git"
   },
-  version: "2.3.0",
+  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",
@@ -2645,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);
@@ -2659,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, {
@@ -2669,19 +3130,21 @@ var registerTool = (definition, callback) => server.registerTool(definition.name
 registerTool(startBrowserToolDefinition, startBrowserTool);
 registerTool(startAppToolDefinition, startAppTool);
 registerTool(closeSessionToolDefinition, closeSessionTool);
-registerTool(navigateToolDefinition, navigateTool);
+registerTool(attachBrowserToolDefinition, attachBrowserTool);
+registerTool(emulateDeviceToolDefinition, emulateDeviceTool);
+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);
@@ -2691,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);