@wordbricks/playwright-mcp 0.1.25 → 0.1.26

package/lib/tools/repl.js

@@ -0,0 +1,414 @@
+import debug from "debug";
+import { readFileSync } from "fs";
+import ms from "ms";
+import { join } from "path";
+import { z } from "zod";
+import { transformScript } from "../playwrightTransformer.js";
+import * as javascript from "../utils/codegen.js";
+import { truncate } from "../utils/truncate.js";
+import { defineTabTool } from "./tool.js";
+const EVALUATE_TIMEOUT_MS = ms("30s");
+const debugLog = debug("pw:mcp:repl");
+const replSchema = z.object({
+    script: z
+        .string()
+        .describe("JavaScript code to execute in the browser console."),
+});
+const contextStates = new WeakMap();
+function getPageState(page) {
+    let pageStates = contextStates.get(page.context());
+    if (!pageStates) {
+        pageStates = new WeakMap();
+        contextStates.set(page.context(), pageStates);
+    }
+    let state = pageStates.get(page);
+    if (!state) {
+        state = {
+            librariesInjected: false,
+            consoleListenerSetup: false,
+        };
+        pageStates.set(page, state);
+    }
+    return state;
+}
+// Helpers
+async function setupConsoleCapture(page) {
+    await page.evaluate(() => {
+        // Store original console methods
+        window.__originalConsole = {
+            // eslint-disable-next-line no-console
+            log: console.log,
+            // eslint-disable-next-line no-console
+            error: console.error,
+            // eslint-disable-next-line no-console
+            warn: console.warn,
+            // eslint-disable-next-line no-console
+            info: console.info,
+        };
+        // Create array to store console outputs
+        window.__consoleOutputs = [];
+        // Override console methods to capture output
+        const captureConsole = (method) => {
+            const handler = (...args) => {
+                // Call original method
+                window.__originalConsole?.[method](...args);
+                // Capture output
+                const output = args
+                    .map((arg) => {
+                    if (arg === undefined)
+                        return "undefined";
+                    if (arg === null)
+                        return "null";
+                    if (typeof arg === "object") {
+                        try {
+                            return JSON.stringify(arg);
+                        }
+                        catch {
+                            return String(arg);
+                        }
+                    }
+                    return String(arg);
+                })
+                    .join(" ");
+                window.__consoleOutputs?.push(output);
+            };
+            Object.defineProperty(console, method, {
+                value: handler,
+                configurable: true,
+                writable: true,
+            });
+        };
+        captureConsole("log");
+        captureConsole("error");
+        captureConsole("warn");
+        captureConsole("info");
+    });
+}
+async function injectLibraries(cdpSession) {
+    try {
+        const nodeModulesPath = join(process.cwd(), "node_modules");
+        // Inject utility libraries into the page context
+        const json5Code = readFileSync(join(nodeModulesPath, "json5", "dist", "index.min.js"), "utf8");
+        const jsonpathCode = readFileSync(join(nodeModulesPath, "jsonpath-plus", "dist", "index-browser-umd.min.cjs"), "utf8");
+        const lodashCode = readFileSync(join(nodeModulesPath, "lodash", "lodash.min.js"), "utf8");
+        // Inject libraries using CDP
+        await cdpSession.send("Runtime.evaluate", {
+            expression: `
+        (function(){
+          try {
+            window.mcp = window.mcp || {};
+            window.mcp.helpers = window.mcp.helpers || {};
+
+            var prev_ = window._;
+            var prevJSON5 = window.JSON5;
+            var prevJSONPath = window.JSONPath;
+
+            // Load libs
+            ${json5Code}
+            ${jsonpathCode}
+            ${lodashCode}
+
+            // Capture injected references
+            var injectedJSON5 = window.JSON5;
+            var injectedJSONPathFn = (window.JSONPath && window.JSONPath.JSONPath) ? window.JSONPath.JSONPath : window.JSONPath;
+            var injectedLodash = window._;
+
+            // Restore previous globals to avoid conflicts
+            if (typeof prevJSON5 !== 'undefined') window.JSON5 = prevJSON5;
+            if (typeof prevJSONPath !== 'undefined') window.JSONPath = prevJSONPath;
+            if (injectedLodash && injectedLodash.noConflict) {
+              injectedLodash = injectedLodash.noConflict();
+            } else if (typeof prev_ !== 'undefined') {
+              window._ = prev_;
+            }
+
+            // Expose helpers under a simple namespace
+            window.mcp.JSON5 = injectedJSON5;
+            window.mcp.JSONPath = injectedJSONPathFn;
+            window.mcp._ = injectedLodash;
+
+            // GraphQL helpers
+            if (!window.mcp.GraphQLClient) {
+              class GraphQLClient {
+                constructor(endpoint, options = {}) {
+                  this.endpoint = endpoint;
+                  this.options = options || {};
+                }
+                async request(document, variables, requestHeaders) {
+                  const method = ((this.options.method || 'POST')).toUpperCase();
+                  const headers = Object.assign(
+                    { 'content-type': 'application/json' },
+                    this.options.headers || {},
+                    requestHeaders || {}
+                  );
+                  const bodyObj = {
+                    query: typeof document === 'string' ? document : String(document),
+                    variables: variables || undefined,
+                  };
+                  let url = this.endpoint;
+                  const fetchOptions = { method, headers, credentials: (this.options.credentials || 'same-origin') };
+                  if (method === 'GET') {
+                    const params = new URLSearchParams();
+                    params.set('query', bodyObj.query);
+                    if (variables) params.set('variables', JSON.stringify(variables));
+                    url += (url.includes('?') ? '&' : '?') + params.toString();
+                  } else {
+                    fetchOptions.body = JSON.stringify(bodyObj);
+                  }
+                  const res = await fetch(url, fetchOptions);
+                  let json;
+                  try {
+                    json = await res.json();
+                  } catch (e) {
+                    throw new Error('Invalid JSON response: ' + (e && e.message ? e.message : String(e)));
+                  }
+                  if (!res.ok) {
+                    const errMsg = (json && json.error) ? json.error : (json && json.errors ? (json.errors.map(e => e.message).join('; ')) : res.statusText);
+                    throw new Error('HTTP ' + res.status + ' ' + errMsg);
+                  }
+                  if (json.errors && (!this.options || this.options.errorPolicy !== 'all')) {
+                    const msg = json.errors.map(e => e.message).join('; ');
+                    throw new Error('GraphQL errors: ' + msg);
+                  }
+                  return (this.options && this.options.errorPolicy === 'all') ? json : json.data;
+                }
+                setHeaders(headers) {
+                  this.options = this.options || {};
+                  this.options.headers = Object.assign({}, this.options.headers || {}, headers || {});
+                }
+                setEndpoint(endpoint) { this.endpoint = endpoint; }
+              }
+              function gql(strings, ...values) {
+                let out = '';
+                for (let i = 0; i < strings.length; i++) {
+                  out += strings[i];
+                  if (i < values.length) out += values[i];
+                }
+                return out;
+              }
+              async function graphqlRequest(urlOrConfig, document, variables, requestHeaders) {
+                if (typeof urlOrConfig === 'string') {
+                  const client = new GraphQLClient(urlOrConfig);
+                  return client.request(document, variables, requestHeaders);
+                }
+                const { url, ...rest } = urlOrConfig || {};
+                const client = new GraphQLClient(url, rest);
+                return client.request(document, variables, requestHeaders);
+              }
+
+              window.mcp.GraphQLClient = GraphQLClient;
+              window.mcp.gql = gql;
+              window.mcp.graphqlRequest = graphqlRequest;
+
+              // Expose globals only if not already present
+              if (!window.GraphQLClient) window.GraphQLClient = GraphQLClient;
+              if (!window.gql) window.gql = gql;
+              if (!window.graphqlRequest) window.graphqlRequest = graphqlRequest;
+            }
+          } catch (e) {}
+        })();
+      `,
+            replMode: true,
+        });
+        return true;
+    }
+    catch (error) {
+        debugLog("Failed to inject libraries:", error);
+        return false;
+    }
+}
+const repl = defineTabTool({
+    capability: "core",
+    schema: {
+        name: "browser_repl",
+        title: "Browser REPL",
+        description: "DevTools-like browser REPL. Per-tab state persists across calls (const/let/functions); supports top-level await. Survives SPA nav; resets on full reload or when switching tabs. Helpers available via window.mcp: JSON5, JSONPath, _, GraphQLClient, gql, graphqlRequest. No need for wrapping in IIFE.",
+        inputSchema: replSchema,
+        type: "action",
+    },
+    handle: async (tab, params, response) => {
+        const page = tab.page;
+        const state = getPageState(page);
+        // Get or create CDP session for this page
+        async function getOrCreateSession() {
+            if (!state.cdpSession) {
+                state.cdpSession = await page.context().newCDPSession(page);
+                await state.cdpSession.send("Runtime.enable");
+            }
+            return state.cdpSession;
+        }
+        const session = await getOrCreateSession();
+        // Set up console output capture if not already done
+        if (!state.consoleListenerSetup) {
+            await setupConsoleCapture(page);
+            state.consoleListenerSetup = true;
+        }
+        // Transform Playwright selectors to DOM-compatible code
+        let transformedScript = transformScript(params.script);
+        // Check if script has return statements outside functions
+        const hasReturnOutsideFunction = /^[^{]*\breturn\b/.test(transformedScript.trim());
+        const hasTopLevelAwait = /^[^{]*\bawait\b/.test(transformedScript.trim());
+        // Wrap script appropriately if it has return statements
+        if (hasReturnOutsideFunction && hasTopLevelAwait) {
+            // Wrap in async function for both return and await
+            transformedScript = `(async function() { ${transformedScript} })()`;
+        }
+        else if (hasReturnOutsideFunction) {
+            // Wrap in regular function for return statements
+            transformedScript = `(function() { ${transformedScript} })()`;
+        }
+        // Add code to response - show the original script, not transformed
+        response.addCode(`// Execute in browser REPL\nawait page.evaluate(${javascript.quote(params.script)});`);
+        response.setIncludeSnapshot();
+        await tab.waitForCompletion(async () => {
+            try {
+                // Clear console outputs for this evaluation
+                await page.evaluate(() => {
+                    window.__consoleOutputs = [];
+                });
+                // Inject libraries if not already done
+                if (!state.librariesInjected)
+                    state.librariesInjected = await injectLibraries(session);
+                // Execute the script with REPL mode for console-like behavior
+                let evaluationResponse;
+                try {
+                    evaluationResponse = await session.send("Runtime.evaluate", {
+                        expression: transformedScript,
+                        replMode: true, // Chrome DevTools console behavior (non-standard, tolerated by CDP)
+                        includeCommandLineAPI: true, // Includes console utilities like $, $$, etc.
+                        awaitPromise: true, // Automatically await promises
+                        returnByValue: true, // Return the actual value, not just object reference
+                        timeout: EVALUATE_TIMEOUT_MS,
+                    });
+                }
+                catch (error) {
+                    // If REPL mode fails due to wrapped functions, try without REPL mode
+                    if (hasReturnOutsideFunction || hasTopLevelAwait) {
+                        evaluationResponse = await session.send("Runtime.evaluate", {
+                            expression: transformedScript,
+                            replMode: false, // Disable REPL mode for wrapped functions
+                            includeCommandLineAPI: true,
+                            awaitPromise: true,
+                            returnByValue: true,
+                            timeout: EVALUATE_TIMEOUT_MS,
+                        });
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                if (evaluationResponse.exceptionDetails) {
+                    const details = evaluationResponse.exceptionDetails;
+                    // Try to get the actual error message from multiple sources
+                    let errorMessage = details.text || "Evaluation failed";
+                    // If we have exception details, try to extract more info
+                    if (details.exception) {
+                        if (details.exception.description)
+                            errorMessage = details.exception.description;
+                        else if (details.exception.value !== undefined)
+                            errorMessage = String(details.exception.value);
+                    }
+                    // Add location information if available
+                    if (details.lineNumber !== undefined) {
+                        errorMessage += ` (at line ${details.lineNumber}`;
+                        if (details.columnNumber !== undefined)
+                            errorMessage += `:${details.columnNumber}`;
+                        errorMessage += ")";
+                    }
+                    // Check if it's a timeout error
+                    if (errorMessage.includes("Timeout") ||
+                        errorMessage.includes("timeout"))
+                        throw new Error(`Script execution timed out after ${EVALUATE_TIMEOUT_MS / 1000} seconds`);
+                    throw new Error(errorMessage);
+                }
+                // Get console outputs from page context
+                const consoleOutputs = await page.evaluate(() => {
+                    return window.__consoleOutputs || [];
+                });
+                // Format the output
+                const formatOutput = () => {
+                    const MAX_OUTPUT_LENGTH = 10_000;
+                    const MAX_CONSOLE_OUTPUTS = 100;
+                    let output = "";
+                    // Add console output if any
+                    if (consoleOutputs && consoleOutputs.length > 0) {
+                        // Limit number of console outputs and truncate each one
+                        const truncatedOutputs = consoleOutputs
+                            .slice(0, MAX_CONSOLE_OUTPUTS)
+                            .map((o) => String(truncate(o, { maxStringLength: 1000 })));
+                        output = truncatedOutputs.join("\n");
+                        if (consoleOutputs.length > MAX_CONSOLE_OUTPUTS)
+                            output += `\n... (${consoleOutputs.length - MAX_CONSOLE_OUTPUTS} more console outputs omitted)`;
+                    }
+                    // Add evaluation result only if:
+                    // 1. It's not undefined, OR
+                    // 2. There's no console output (so we need to show something)
+                    const result = evaluationResponse.result.value;
+                    if (result !== undefined) {
+                        let resultString;
+                        try {
+                            resultString =
+                                typeof result === "string"
+                                    ? result
+                                    : JSON.stringify(result, null, 2);
+                        }
+                        catch {
+                            // Handle circular references or other stringify errors
+                            resultString = String(result);
+                        }
+                        // Truncate result if too long (first structure-limit, then clamp string)
+                        const truncatedValue = truncate(result, {
+                            maxStringLength: 200,
+                            maxItems: 20,
+                        });
+                        let limited = "";
+                        try {
+                            limited =
+                                typeof truncatedValue === "string"
+                                    ? truncatedValue
+                                    : JSON.stringify(truncatedValue, null, 2);
+                        }
+                        catch {
+                            limited = resultString;
+                        }
+                        const truncatedResult = limited.length > 5000
+                            ? limited.substring(0, 5000) + "\n... (truncated)"
+                            : limited;
+                        if (output)
+                            output += "\n" + truncatedResult;
+                        else
+                            output = truncatedResult;
+                    }
+                    else if (!consoleOutputs || consoleOutputs.length === 0) {
+                        // Only show "undefined" if there's no console output
+                        output = "undefined";
+                    }
+                    // Final truncation of the entire output
+                    if (output.length > MAX_OUTPUT_LENGTH) {
+                        output =
+                            output.substring(0, MAX_OUTPUT_LENGTH) +
+                                "\n... (output truncated)";
+                    }
+                    return output;
+                };
+                response.addResult(formatOutput());
+            }
+            catch (error) {
+                const errorToMessage = (e) => {
+                    if (e instanceof Error)
+                        return e.message;
+                    if (typeof e === "string")
+                        return e;
+                    try {
+                        return JSON.stringify(e);
+                    }
+                    catch {
+                        return "Unknown error occurred";
+                    }
+                };
+                response.addError(errorToMessage(error));
+            }
+        });
+    },
+});
+export default [repl];

package/lib/tools/screenshot.js

@@ -0,0 +1,103 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from "zod";
+import * as javascript from "../utils/codegen.js";
+import { defineTabTool } from "./tool.js";
+import { generateLocator } from "./utils.js";
+const screenshotSchema = z
+    .object({
+    type: z
+        .enum(["png", "jpeg"])
+        .default("png")
+        .describe("Image format for the screenshot. Default is png."),
+    filename: z
+        .string()
+        .optional()
+        .describe("File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg}` if not specified."),
+    element: z
+        .string()
+        .optional()
+        .describe("Human-readable element description used to obtain permission to screenshot the element. If not provided, the screenshot will be taken of viewport. If element is provided, ref must be provided too."),
+    ref: z
+        .string()
+        .optional()
+        .describe("Exact target element reference from the page snapshot. If not provided, the screenshot will be taken of viewport. If ref is provided, element must be provided too."),
+    fullPage: z
+        .boolean()
+        .optional()
+        .describe("When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots."),
+})
+    .refine((data) => {
+    return !!data.element === !!data.ref;
+}, {
+    message: "Both element and ref must be provided or neither.",
+    path: ["ref", "element"],
+})
+    .refine((data) => {
+    return !(data.fullPage && (data.element || data.ref));
+}, {
+    message: "fullPage cannot be used with element screenshots.",
+    path: ["fullPage"],
+});
+const screenshot = defineTabTool({
+    capability: "core",
+    schema: {
+        name: "browser_take_screenshot",
+        title: "Take a screenshot",
+        description: `Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.`,
+        inputSchema: screenshotSchema,
+        type: "readOnly",
+    },
+    handle: async (tab, params, response) => {
+        const fileType = params.type || "png";
+        const fileName = await tab.context.outputFile(params.filename ?? `page-${new Date().toISOString()}.${fileType}`);
+        const options = {
+            type: fileType,
+            quality: fileType === "png" ? undefined : 90,
+            scale: "css",
+            path: fileName,
+            ...(params.fullPage !== undefined && { fullPage: params.fullPage }),
+        };
+        const isElementScreenshot = params.element && params.ref;
+        const screenshotTarget = isElementScreenshot
+            ? params.element
+            : params.fullPage
+                ? "full page"
+                : "viewport";
+        response.addCode(`// Screenshot ${screenshotTarget} and save it as ${fileName}`);
+        // Only get snapshot when element screenshot is needed
+        const locator = params.ref
+            ? await tab.refLocator({ element: params.element || "", ref: params.ref })
+            : null;
+        if (locator)
+            response.addCode(`await page.${await generateLocator(locator)}.screenshot(${javascript.formatObject(options)});`);
+        else
+            response.addCode(`await page.screenshot(${javascript.formatObject(options)});`);
+        const buffer = locator
+            ? await locator.screenshot(options)
+            : await tab.page.screenshot(options);
+        response.addResult(`Took the ${screenshotTarget} screenshot and saved it as ${fileName}`);
+        // https://github.com/microsoft/playwright-mcp/issues/817
+        // Never return large images to LLM, saving them to the file system is enough.
+        if (!params.fullPage) {
+            response.addImage({
+                contentType: fileType === "png" ? "image/png" : "image/jpeg",
+                data: buffer,
+            });
+        }
+    },
+});
+export default [screenshot];

package/lib/tools/scroll.js

@@ -0,0 +1,131 @@
+import ms from "ms";
+import { z } from "zod";
+import { defineTabTool } from "./tool.js";
+/**
+ * Generate random number between min and max
+ */
+function randomBetween(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+/**
+ * Generate human-like scroll pattern
+ */
+function generateScrollPattern(totalDelta) {
+    const pattern = [];
+    const abs = Math.abs(totalDelta);
+    const direction = totalDelta > 0 ? 1 : -1;
+    // Faster profile: fewer steps overall, still eased
+    const steps = abs < 250
+        ? randomBetween(3, 6)
+        : abs < 1200
+            ? randomBetween(4, 10)
+            : randomBetween(8, 16);
+    const base = abs / steps;
+    const easeInOut = (t) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t); // 0..1
+    for (let i = 0; i < steps; i++) {
+        const t = steps > 1 ? i / (steps - 1) : 0;
+        const momentum = 0.6 + easeInOut(t) * 0.7; // ~0.6 .. 1.3
+        const variation = 0.1 + Math.random() * 0.2; // +/- ~15%
+        const scrollAmount = base * momentum * (1 + (Math.random() - 0.5) * variation);
+        // Larger per-event wheel to reduce total time: clamp 10..180px
+        const clamped = Math.max(10, Math.min(180, Math.round(scrollAmount)));
+        // Short delays: 15–60ms + small size factor
+        const delay = randomBetween(ms("15ms"), ms("60ms")) + Math.floor(clamped * 0.08);
+        pattern.push({
+            delta: clamped * direction,
+            delay,
+        });
+        // Rare micro-pause (short) to keep a bit of human feel
+        if (Math.random() < 0.05 && i < steps - 1)
+            pattern.push({ delta: 0, delay: randomBetween(ms("30ms"), ms("80ms")) });
+    }
+    // Smaller, rarer overshoot for long moves only
+    if (abs > 600 && Math.random() < 0.1) {
+        pattern.push({
+            delta: -direction * randomBetween(6, 18),
+            delay: randomBetween(ms("60ms"), ms("120ms")),
+        });
+    }
+    return pattern;
+}
+const scrollSchema = z.object({
+    amount: z
+        .number()
+        .describe("Vertical scroll amount in pixels (positive scrolls down, negative up)"),
+});
+const scrollWheel = defineTabTool({
+    capability: "core",
+    schema: {
+        name: "browser_scroll",
+        title: "Scroll page",
+        description: "Scroll the page using mouse wheel with human-like behavior",
+        inputSchema: scrollSchema,
+        type: "readOnly",
+    },
+    handle: async (tab, params, response) => {
+        const requestedDeltaY = params.amount || 0;
+        // Capture initial scroll position
+        const initialScrollPosition = await tab.page.evaluate(() => ({
+            x: window.scrollX,
+            y: window.scrollY,
+        }));
+        response.addCode(`// Scroll page by ${requestedDeltaY}px (vertical)`);
+        await tab.waitForCompletion(async () => {
+            // Position mouse at a slightly randomized viewport center
+            const viewport = tab.page.viewportSize();
+            if (viewport) {
+                const x = viewport.width / 2 + randomBetween(-100, 100);
+                const y = viewport.height / 2 + randomBetween(-100, 100);
+                await tab.page.mouse.move(x, y);
+                response.addCode(`await page.mouse.move(${x}, ${y});`);
+            }
+            // Add initial "hover" delay (short)
+            await tab.page.waitForTimeout(randomBetween(ms("40ms"), ms("120ms")));
+            // Generate and execute human-like scroll pattern
+            const scrollPatternY = requestedDeltaY
+                ? generateScrollPattern(requestedDeltaY)
+                : [];
+            const maxSteps = scrollPatternY.length;
+            for (let i = 0; i < maxSteps; i++) {
+                let deltaY = scrollPatternY[i]?.delta || 0;
+                const delay = scrollPatternY[i]?.delay || 0;
+                // Clamp vertical delta to avoid scrolling past page edges
+                const allowedY = await tab.page.evaluate((dy) => {
+                    const doc = document.scrollingElement || document.documentElement;
+                    const maxY = Math.max(0, (doc.scrollHeight || document.documentElement.scrollHeight) -
+                        window.innerHeight);
+                    const curY = window.scrollY || doc.scrollTop || 0;
+                    let a = dy;
+                    if (curY + dy < 0)
+                        a = -curY;
+                    if (curY + dy > maxY)
+                        a = maxY - curY;
+                    return a;
+                }, deltaY);
+                deltaY = allowedY;
+                // Skip if nothing to do (already at edge)
+                if (deltaY === 0)
+                    continue;
+                await tab.page.mouse.wheel(0, deltaY);
+                response.addCode(`await page.mouse.wheel(0, ${deltaY});`);
+                // Wait between scroll events
+                if (i < maxSteps - 1 && delay > 0) {
+                    await tab.page.waitForTimeout(delay);
+                    response.addCode(`await page.waitForTimeout(${delay});`);
+                }
+            }
+            // Short final pause
+            const finalDelay = randomBetween(ms("80ms"), ms("200ms"));
+            await tab.page.waitForTimeout(finalDelay);
+            response.addCode(`await page.waitForTimeout(${finalDelay});`);
+        });
+        // Capture final scroll position
+        const finalScrollPosition = await tab.page.evaluate(() => ({
+            x: window.scrollX,
+            y: window.scrollY,
+        }));
+        // Always show scroll position for scroll tool
+        response.addResult(`Scroll position:\nBefore: x=${initialScrollPosition.x}, y=${initialScrollPosition.y}\nAfter: x=${finalScrollPosition.x}, y=${finalScrollPosition.y}`);
+    },
+});
+export default [scrollWheel];