opera-devtools-mcp 0.2.3 → 0.3.0

package/build/src/tools/input.js

@@ -3,10 +3,61 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { logger } from '../logger.js';
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { zod } from '../third_party/index.js';
 import { parseKey } from '../utils/keyboard.js';
-import { appendWaitForResult, } from '../WaitForHelper.js';
+import { logger } from '../utils/logger.js';
 import { ToolCategory } from './categories.js';
 import { definePageTool } from './ToolDefinition.js';
 const dblClickSchema = zod
@@ -22,47 +73,47 @@ const submitKeySchema = zod
     .optional()
     .describe('Optional key to press after typing. E.g., "Enter", "Tab", "Escape"');
 function handleActionError(error, uid) {
-    logger('failed to act using a locator', error);
+    logger?.('failed to act using a locator', error);
     throw new Error(`Failed to interact with the element with uid ${uid}. The element did not become interactive within the configured timeout.`, {
         cause: error,
     });
 }
 async function selectNativeSelectOption(handle) {
-    const selectHandle = await handle.evaluateHandle(node => {
-        if (!(node instanceof HTMLOptionElement)) {
-            return null;
-        }
-        const select = node.closest('select');
-        if (!select || select.multiple || select.disabled || node.disabled) {
-            return null;
-        }
-        const parentElement = node.parentElement;
-        if (parentElement instanceof HTMLOptGroupElement &&
-            parentElement.disabled) {
-            return null;
-        }
-        return select;
-    });
+    const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const select = selectHandle.asElement();
+        const selectHandle = __addDisposableResource(env_1, await handle.evaluateHandle(node => {
+            if (!(node instanceof HTMLOptionElement)) {
+                return null;
+            }
+            const select = node.closest('select');
+            if (!select || select.multiple || select.disabled || node.disabled) {
+                return null;
+            }
+            const parentElement = node.parentElement;
+            if (parentElement instanceof HTMLOptGroupElement &&
+                parentElement.disabled) {
+                return null;
+            }
+            return select;
+        }), false);
+        const select = __addDisposableResource(env_1, selectHandle.asElement(), false);
         if (!select) {
             return false;
         }
-        const valueHandle = await handle.getProperty('value');
-        try {
-            const value = await valueHandle.jsonValue();
-            if (typeof value !== 'string') {
-                return false;
-            }
-            await select.asLocator().fill(value);
-        }
-        finally {
-            void valueHandle.dispose();
+        const valueHandle = __addDisposableResource(env_1, await handle.getProperty('value'), false);
+        const value = await valueHandle.jsonValue();
+        if (typeof value !== 'string') {
+            return false;
         }
+        await select.asLocator().fill(value);
         return true;
     }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
     finally {
-        void selectHandle.dispose();
+        __disposeResources(env_1);
     }
 }
 export const click = definePageTool({
@@ -80,34 +131,42 @@ export const click = definePageTool({
         includeSnapshot: includeSnapshotSchema,
     },
     blockedByDialog: true,
+    verifyFilesSchema: {},
     handler: async (request, response) => {
-        const uid = request.params.uid;
-        const handle = await request.page.getElementByUid(uid);
-        const aXNode = request.page.getAXNodeByUid(uid);
-        const shouldSelectNativeOption = !request.params.dblClick && aXNode?.role === 'option';
+        const env_2 = { stack: [], error: void 0, hasError: false };
         try {
-            const result = await request.page.waitForEventsAfterAction(async () => {
-                if (shouldSelectNativeOption &&
-                    (await selectNativeSelectOption(handle))) {
-                    return;
-                }
-                await handle.asLocator().click({
-                    count: request.params.dblClick ? 2 : 1,
+            const uid = request.params.uid;
+            const handle = __addDisposableResource(env_2, await request.page.getElementByUid(uid), false);
+            const aXNode = request.page.getAXNodeByUid(uid);
+            const shouldSelectNativeOption = !request.params.dblClick && aXNode?.role === 'option';
+            try {
+                const result = await request.page.waitForEventsAfterAction(async () => {
+                    if (shouldSelectNativeOption &&
+                        (await selectNativeSelectOption(handle))) {
+                        return;
+                    }
+                    await handle.asLocator().click({
+                        count: request.params.dblClick ? 2 : 1,
+                    });
                 });
-            });
-            response.appendResponseLine(request.params.dblClick
-                ? `Successfully double clicked on the element`
-                : `Successfully clicked on the element`);
-            appendWaitForResult(response, result);
-            if (request.params.includeSnapshot) {
-                response.includeSnapshot();
+                response.appendResponseLine(request.params.dblClick
+                    ? `Successfully double clicked on the element`
+                    : `Successfully clicked on the element`);
+                response.attachWaitForResult(result);
+                if (request.params.includeSnapshot) {
+                    response.includeSnapshot();
+                }
+            }
+            catch (error) {
+                handleActionError(error, uid);
             }
         }
-        catch (error) {
-            handleActionError(error, uid);
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
         }
         finally {
-            void handle.dispose();
+            __disposeResources(env_2);
         }
     },
 });
@@ -126,17 +185,18 @@ export const clickAt = definePageTool({
         includeSnapshot: includeSnapshotSchema,
     },
     blockedByDialog: true,
+    verifyFilesSchema: {},
     handler: async (request, response) => {
         const page = request.page;
         const result = await page.waitForEventsAfterAction(async () => {
             await page.pptrPage.mouse.click(request.params.x, request.params.y, {
-                clickCount: request.params.dblClick ? 2 : 1,
+                count: request.params.dblClick ? 2 : 1,
             });
         });
         response.appendResponseLine(request.params.dblClick
             ? `Successfully double clicked at the coordinates`
             : `Successfully clicked at the coordinates`);
-        appendWaitForResult(response, result);
+        response.attachWaitForResult(result);
         if (request.params.includeSnapshot) {
             response.includeSnapshot();
         }
@@ -156,24 +216,32 @@ export const hover = definePageTool({
         includeSnapshot: includeSnapshotSchema,
     },
     blockedByDialog: true,
+    verifyFilesSchema: {},
     handler: async (request, response) => {
-        const uid = request.params.uid;
-        const handle = await request.page.getElementByUid(uid);
+        const env_3 = { stack: [], error: void 0, hasError: false };
         try {
-            const result = await request.page.waitForEventsAfterAction(async () => {
-                await handle.asLocator().hover();
-            });
-            response.appendResponseLine(`Successfully hovered over the element`);
-            appendWaitForResult(response, result);
-            if (request.params.includeSnapshot) {
-                response.includeSnapshot();
+            const uid = request.params.uid;
+            const handle = __addDisposableResource(env_3, await request.page.getElementByUid(uid), false);
+            try {
+                const result = await request.page.waitForEventsAfterAction(async () => {
+                    await handle.asLocator().hover();
+                });
+                response.appendResponseLine(`Successfully hovered over the element`);
+                response.attachWaitForResult(result);
+                if (request.params.includeSnapshot) {
+                    response.includeSnapshot();
+                }
+            }
+            catch (error) {
+                handleActionError(error, uid);
             }
         }
-        catch (error) {
-            handleActionError(error, uid);
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
         }
         finally {
-            void handle.dispose();
+            __disposeResources(env_3);
         }
     },
 });
@@ -185,26 +253,36 @@ async function selectOption(handle, aXNode, value) {
     let optionFound = false;
     for (const child of aXNode.children) {
         if (child.role === 'option' && child.name === value && child.value) {
-            optionFound = true;
-            const childHandle = await child.elementHandle();
-            if (childHandle) {
-                try {
-                    const childValueHandle = await childHandle.getProperty('value');
+            const env_4 = { stack: [], error: void 0, hasError: false };
+            try {
+                optionFound = true;
+                const childHandle = __addDisposableResource(env_4, await child.elementHandle(), false);
+                if (childHandle) {
+                    const env_5 = { stack: [], error: void 0, hasError: false };
                     try {
+                        const childValueHandle = __addDisposableResource(env_5, await childHandle.getProperty('value'), false);
                         const childValue = await childValueHandle.jsonValue();
-                        if (childValue) {
-                            await handle.asLocator().fill(childValue.toString());
+                        if (typeof childValue === 'string') {
+                            await handle.asLocator().fill(childValue);
                         }
+                        break;
+                    }
+                    catch (e_4) {
+                        env_5.error = e_4;
+                        env_5.hasError = true;
                     }
                     finally {
-                        void childValueHandle.dispose();
+                        __disposeResources(env_5);
                     }
-                    break;
-                }
-                finally {
-                    void childHandle.dispose();
                 }
             }
+            catch (e_5) {
+                env_4.error = e_5;
+                env_4.hasError = true;
+            }
+            finally {
+                __disposeResources(env_4);
+            }
         }
     }
     if (!optionFound) {
@@ -215,43 +293,50 @@ function hasOptionChildren(aXNode) {
     return aXNode.children.some(child => child.role === 'option');
 }
 async function fillFormElement(uid, value, context, page) {
-    const handle = await page.getElementByUid(uid);
+    const env_6 = { stack: [], error: void 0, hasError: false };
     try {
-        const aXNode = context.getAXNodeByUid(uid);
-        // We assume that combobox needs to be handled as select if it has
-        // role='combobox' and option children.
-        if (aXNode && aXNode.role === 'combobox' && hasOptionChildren(aXNode)) {
-            await selectOption(handle, aXNode, value);
-        }
-        else {
-            const isToggle = await handle.evaluate(el => {
-                if (el instanceof HTMLInputElement) {
-                    return el.type === 'checkbox' || el.type === 'radio';
-                }
-                const role = el.getAttribute('role');
-                return role === 'checkbox' || role === 'radio' || role === 'switch';
-            });
-            if (isToggle) {
-                if (['true', 'false'].includes(value)) {
-                    await handle.asLocator().fill(value === 'true');
+        const handle = __addDisposableResource(env_6, await page.getElementByUid(uid), false);
+        try {
+            const aXNode = page.getAXNodeByUid(uid);
+            // We assume that combobox needs to be handled as select if it has
+            // role='combobox' and option children.
+            if (aXNode && aXNode.role === 'combobox' && hasOptionChildren(aXNode)) {
+                await selectOption(handle, aXNode, value);
+            }
+            else {
+                const isToggle = await handle.evaluate(el => {
+                    if (el instanceof HTMLInputElement) {
+                        return el.type === 'checkbox' || el.type === 'radio';
+                    }
+                    const role = el.getAttribute('role');
+                    return role === 'checkbox' || role === 'radio' || role === 'switch';
+                });
+                if (isToggle) {
+                    if (['true', 'false'].includes(value)) {
+                        await handle.asLocator().fill(value === 'true');
+                    }
+                    else {
+                        throw new Error(`Checkboxes, radio boxes and toggles require "true" or "false" value, but ${value} was used`);
+                    }
                 }
                 else {
-                    throw new Error(`Checkboxes, radio boxes and toggles require "true" or "false" value, but ${value} was used`);
+                    // Increase timeout for longer input values.
+                    const timeoutPerChar = 10; // ms
+                    const fillTimeout = page.pptrPage.getDefaultTimeout() + value.length * timeoutPerChar;
+                    await handle.asLocator().setTimeout(fillTimeout).fill(value);
                 }
             }
-            else {
-                // Increase timeout for longer input values.
-                const timeoutPerChar = 10; // ms
-                const fillTimeout = page.pptrPage.getDefaultTimeout() + value.length * timeoutPerChar;
-                await handle.asLocator().setTimeout(fillTimeout).fill(value);
-            }
+        }
+        catch (error) {
+            handleActionError(error, uid);
         }
     }
-    catch (error) {
-        handleActionError(error, uid);
+    catch (e_6) {
+        env_6.error = e_6;
+        env_6.hasError = true;
     }
     finally {
-        void handle.dispose();
+        __disposeResources(env_6);
     }
 }
 export const fill = definePageTool({
@@ -271,13 +356,14 @@ export const fill = definePageTool({
         includeSnapshot: includeSnapshotSchema,
     },
     blockedByDialog: true,
+    verifyFilesSchema: {},
     handler: async (request, response, context) => {
         const page = request.page;
         const result = await page.waitForEventsAfterAction(async () => {
             await fillFormElement(request.params.uid, request.params.value, context, page);
         });
         response.appendResponseLine(`Successfully filled out the element`);
-        appendWaitForResult(response, result);
+        response.attachWaitForResult(result);
         if (request.params.includeSnapshot) {
             response.includeSnapshot();
         }
@@ -295,6 +381,7 @@ export const typeText = definePageTool({
         submitKey: submitKeySchema,
     },
     blockedByDialog: true,
+    verifyFilesSchema: {},
     handler: async (request, response) => {
         const page = request.page;
         const result = await page.waitForEventsAfterAction(async () => {
@@ -304,7 +391,7 @@ export const typeText = definePageTool({
             }
         });
         response.appendResponseLine(`Typed text "${request.params.text}${request.params.submitKey ? ` + ${request.params.submitKey}` : ''}"`);
-        appendWaitForResult(response, result);
+        response.attachWaitForResult(result);
     },
 });
 export const drag = definePageTool({
@@ -320,24 +407,29 @@ export const drag = definePageTool({
         includeSnapshot: includeSnapshotSchema,
     },
     blockedByDialog: true,
+    verifyFilesSchema: {},
     handler: async (request, response) => {
-        const fromHandle = await request.page.getElementByUid(request.params.from_uid);
-        const toHandle = await request.page.getElementByUid(request.params.to_uid);
+        const env_7 = { stack: [], error: void 0, hasError: false };
         try {
+            const fromHandle = __addDisposableResource(env_7, await request.page.getElementByUid(request.params.from_uid), false);
+            const toHandle = __addDisposableResource(env_7, await request.page.getElementByUid(request.params.to_uid), false);
             const result = await request.page.waitForEventsAfterAction(async () => {
                 await fromHandle.drag(toHandle);
                 await new Promise(resolve => setTimeout(resolve, 50));
                 await toHandle.drop(fromHandle);
             });
             response.appendResponseLine(`Successfully dragged an element`);
-            appendWaitForResult(response, result);
+            response.attachWaitForResult(result);
             if (request.params.includeSnapshot) {
                 response.includeSnapshot();
             }
         }
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
+        }
         finally {
-            void fromHandle.dispose();
-            void toHandle.dispose();
+            __disposeResources(env_7);
         }
     },
 });
@@ -362,6 +454,7 @@ export const fillForm = definePageTool({
         includeSnapshot: includeSnapshotSchema,
     },
     blockedByDialog: true,
+    verifyFilesSchema: {},
     handler: async (request, response, context) => {
         const page = request.page;
         let lastResult = {};
@@ -371,7 +464,7 @@ export const fillForm = definePageTool({
             });
         }
         response.appendResponseLine(`Successfully filled out the form`);
-        appendWaitForResult(response, lastResult);
+        response.attachWaitForResult(lastResult);
         if (request.params.includeSnapshot) {
             response.includeSnapshot();
         }
@@ -388,17 +481,28 @@ export const uploadFile = definePageTool({
         uid: zod
             .string()
             .describe('The uid of the file input element or an element that will open file chooser on the page from the page content snapshot'),
-        filePath: zod.string().describe('The local path of the file to upload'),
+        filePaths: zod
+            .array(zod.string())
+            .min(1)
+            .describe('One or more files paths to upload. File paths have to be local to the browser instance (not the MCP).'),
         includeSnapshot: includeSnapshotSchema,
     },
     blockedByDialog: true,
-    handler: async (request, response, context) => {
-        const { uid, filePath } = request.params;
-        context.validatePath(filePath);
-        const handle = (await request.page.getElementByUid(uid));
+    // We do not validate file paths for remote browser instances
+    // because they are on the remote host and not accessed by the MCP server.
+    verifyFilesSchema: {
+        filePaths: {
+            local: true,
+            remote: false,
+        },
+    },
+    handler: async (request, response) => {
+        const env_8 = { stack: [], error: void 0, hasError: false };
         try {
+            const { uid, filePaths } = request.params;
+            const handle = __addDisposableResource(env_8, (await request.page.getElementByUid(uid)), false);
             try {
-                await handle.uploadFile(filePath);
+                await handle.uploadFile(...filePaths);
             }
             catch {
                 // Some sites use a proxy element to trigger file upload instead of
@@ -409,7 +513,7 @@ export const uploadFile = definePageTool({
                         request.page.pptrPage.waitForFileChooser({ timeout: 3000 }),
                         handle.asLocator().click(),
                     ]);
-                    await fileChooser.accept([filePath]);
+                    await fileChooser.accept(filePaths);
                 }
                 catch {
                     throw new Error(`Failed to upload file. The element could not accept the file directly, and clicking it did not trigger a file chooser.`);
@@ -418,10 +522,14 @@ export const uploadFile = definePageTool({
             if (request.params.includeSnapshot) {
                 response.includeSnapshot();
             }
-            response.appendResponseLine(`File uploaded from ${filePath}.`);
+            response.appendResponseLine(`File uploaded from ${filePaths.join(', ')}.`);
+        }
+        catch (e_8) {
+            env_8.error = e_8;
+            env_8.hasError = true;
         }
         finally {
-            void handle.dispose();
+            __disposeResources(env_8);
         }
     },
 });
@@ -439,21 +547,31 @@ export const pressKey = definePageTool({
         includeSnapshot: includeSnapshotSchema,
     },
     blockedByDialog: true,
+    verifyFilesSchema: {},
     handler: async (request, response) => {
         const page = request.page;
         const tokens = parseKey(request.params.key);
         const [key, ...modifiers] = tokens;
         const result = await page.waitForEventsAfterAction(async () => {
-            for (const modifier of modifiers) {
-                await page.pptrPage.keyboard.down(modifier);
+            const heldModifiers = [];
+            try {
+                for (const modifier of modifiers) {
+                    await page.pptrPage.keyboard.down(modifier);
+                    heldModifiers.push(modifier);
+                }
+                await page.pptrPage.keyboard.press(key);
             }
-            await page.pptrPage.keyboard.press(key);
-            for (const modifier of modifiers.toReversed()) {
-                await page.pptrPage.keyboard.up(modifier);
+            finally {
+                // Release every modifier that was successfully pressed, even if a
+                // later key event throws. Otherwise a failed press leaves modifiers
+                // logically held down in the browser (see #2309).
+                for (const modifier of heldModifiers.toReversed()) {
+                    await page.pptrPage.keyboard.up(modifier);
+                }
             }
         });
         response.appendResponseLine(`Successfully pressed key: ${request.params.key}`);
-        appendWaitForResult(response, result);
+        response.attachWaitForResult(result);
         if (request.params.includeSnapshot) {
             response.includeSnapshot();
         }

package/build/src/tools/lighthouse.js

@@ -30,6 +30,9 @@ export const lighthouseAudit = definePageTool({
             .describe('Directory for reports. If omitted, uses temporary files.'),
     },
     blockedByDialog: true,
+    verifyFilesSchema: {
+        outputDirPath: true,
+    },
     handler: async (request, response, context) => {
         const page = request.page;
         const categories = [
@@ -40,7 +43,6 @@ export const lighthouseAudit = definePageTool({
         ];
         const formats = ['json', 'html'];
         const { mode = 'navigation', device = 'desktop', outputDirPath, } = request.params;
-        context.validatePath(outputDirPath);
         const flags = {
             onlyCategories: categories,
             output: formats,
@@ -84,23 +86,28 @@ export const lighthouseAudit = definePageTool({
             }
         }
         finally {
-            await context.restoreEmulation(page);
+            await page.restoreEmulation();
         }
         const lhr = result.lhr;
         const reportPaths = [];
         const encoder = new TextEncoder();
-        for (const format of formats) {
+        const savePromises = formats.map(async (format) => {
             const report = generateReport(lhr, format);
             const data = encoder.encode(report);
             if (outputDirPath) {
                 const reportPath = path.join(outputDirPath, `report`);
                 const { filename } = await context.saveFile(data, reportPath, `.${format}`);
-                reportPaths.push(filename);
+                return filename;
             }
-            else {
-                const { filepath } = await context.saveTemporaryFile(data, `report.${format}`);
-                reportPaths.push(filepath);
+            const { filepath } = await context.saveTemporaryFile(data, `report.${format}`);
+            return filepath;
+        });
+        const results = await Promise.allSettled(savePromises);
+        for (const res of results) {
+            if (res.status === 'rejected') {
+                throw res.reason;
             }
+            reportPaths.push(res.value);
         }
         const categoryScores = Object.values(lhr.categories).map(c => ({
             id: c.id,