hanseol 3.2.7

package/dist/tools/browser/browser-tools.js

@@ -0,0 +1,888 @@
+import { browserClient } from './browser-client.js';
+const BROWSER_CATEGORIES = ['llm-simple'];
+const BROWSER_LAUNCH_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_launch',
+        description: `Launch Chrome/Edge browser for web testing and automation.
+Use this tool to start a browser session before navigating to pages.
+The browser runs on Windows via CDP (Chrome DevTools Protocol).`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are launching the browser',
+                },
+                headless: {
+                    type: 'boolean',
+                    description: 'Run browser in headless mode (default: false). Set to true to hide the browser window.',
+                },
+                browser: {
+                    type: 'string',
+                    enum: ['chrome', 'edge'],
+                    description: 'Browser to use (default: chrome). Falls back to edge if chrome is not available.',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function executeBrowserLaunch(args) {
+    const headless = args['headless'] === true;
+    const browser = args['browser'] || 'chrome';
+    try {
+        if (await browserClient.isBrowserActive()) {
+            return {
+                success: true,
+                result: 'Browser is already running.',
+            };
+        }
+        await browserClient.startServer();
+        const response = await browserClient.launch({ headless, browser });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to launch browser',
+            };
+        }
+        return {
+            success: true,
+            result: `${response['browser'] || browser} launched successfully (headless: ${headless})`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to launch browser: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserLaunchTool = {
+    definition: BROWSER_LAUNCH_DEFINITION,
+    execute: executeBrowserLaunch,
+    categories: BROWSER_CATEGORIES,
+    description: 'Launch Chrome/Edge browser',
+};
+const BROWSER_NAVIGATE_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_navigate',
+        description: `Navigate browser to a URL. Use this to open web pages for testing.
+Common URLs:
+- http://localhost:3000 - Local development server
+- http://localhost:8080 - Alternative local server
+- https://example.com - External website`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are navigating to this URL',
+                },
+                url: {
+                    type: 'string',
+                    description: 'The URL to navigate to (e.g., http://localhost:3000)',
+                },
+            },
+            required: ['reason', 'url'],
+        },
+    },
+};
+async function executeBrowserNavigate(args) {
+    const url = args['url'];
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            await browserClient.startServer();
+            await browserClient.launch({ headless: false });
+        }
+        const response = await browserClient.navigate(url);
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to navigate',
+            };
+        }
+        return {
+            success: true,
+            result: `Navigated to ${response.url}\nPage title: ${response.title}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to navigate: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserNavigateTool = {
+    definition: BROWSER_NAVIGATE_DEFINITION,
+    execute: executeBrowserNavigate,
+    categories: BROWSER_CATEGORIES,
+    description: 'Navigate browser to URL',
+};
+const BROWSER_SCREENSHOT_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_screenshot',
+        description: `Take a screenshot of the current browser page.
+Returns a base64-encoded PNG image that you can analyze to understand the page state.
+Screenshots are also saved to ~/.hanseol/screenshots/browser/
+Use this to verify that pages loaded correctly or to check UI elements.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are taking a screenshot',
+                },
+                full_page: {
+                    type: 'boolean',
+                    description: 'Capture the full scrollable page (default: false, captures viewport only)',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function executeBrowserScreenshot(args) {
+    const fullPage = args['full_page'] === true;
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.screenshot(fullPage);
+        if (!response.success || !response.image) {
+            return {
+                success: false,
+                error: response.error || 'Failed to take screenshot',
+            };
+        }
+        const savedPath = browserClient.saveScreenshot(response.image, 'browser');
+        return {
+            success: true,
+            result: `Screenshot captured of "${response.title}" (${response.url})\nSaved to: ${savedPath}`,
+            metadata: {
+                image: response.image,
+                imageType: 'image/png',
+                encoding: 'base64',
+                url: response.url,
+                title: response.title,
+                savedPath,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to take screenshot: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserScreenshotTool = {
+    definition: BROWSER_SCREENSHOT_DEFINITION,
+    execute: executeBrowserScreenshot,
+    categories: BROWSER_CATEGORIES,
+    description: 'Take screenshot of browser',
+};
+const BROWSER_CLICK_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_click',
+        description: `Click an element on the page by CSS selector.
+Examples:
+- button[type="submit"] - Submit button
+- #login-btn - Element with id "login-btn"
+- .nav-link - Element with class "nav-link"
+- a[href="/about"] - Link to /about`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are clicking this element',
+                },
+                selector: {
+                    type: 'string',
+                    description: 'CSS selector of the element to click',
+                },
+            },
+            required: ['reason', 'selector'],
+        },
+    },
+};
+async function executeBrowserClick(args) {
+    const selector = args['selector'];
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.click(selector);
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || `Failed to click: ${selector}`,
+            };
+        }
+        return {
+            success: true,
+            result: `Clicked element: ${selector}\nCurrent URL: ${response['current_url'] || 'unknown'}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to click: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserClickTool = {
+    definition: BROWSER_CLICK_DEFINITION,
+    execute: executeBrowserClick,
+    categories: BROWSER_CATEGORIES,
+    description: 'Click element on page',
+};
+const BROWSER_FILL_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_fill',
+        description: `Fill an input field with text.
+The existing content will be cleared before typing.
+Examples:
+- input[name="email"] - Email input field
+- #password - Password field by id
+- textarea.comment - Comment textarea`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are filling this field',
+                },
+                selector: {
+                    type: 'string',
+                    description: 'CSS selector of the input field',
+                },
+                value: {
+                    type: 'string',
+                    description: 'Text to type into the field',
+                },
+            },
+            required: ['reason', 'selector', 'value'],
+        },
+    },
+};
+async function executeBrowserFill(args) {
+    const selector = args['selector'];
+    const value = args['value'];
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.fill(selector, value);
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || `Failed to fill: ${selector}`,
+            };
+        }
+        return {
+            success: true,
+            result: `Filled "${selector}" with text (${value.length} characters)`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fill: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserFillTool = {
+    definition: BROWSER_FILL_DEFINITION,
+    execute: executeBrowserFill,
+    categories: BROWSER_CATEGORIES,
+    description: 'Fill input field with text',
+};
+const BROWSER_GET_TEXT_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_get_text',
+        description: `Get the text content of an element.
+Use this to read content from the page, like error messages or confirmation text.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are reading this element',
+                },
+                selector: {
+                    type: 'string',
+                    description: 'CSS selector of the element to read',
+                },
+            },
+            required: ['reason', 'selector'],
+        },
+    },
+};
+async function executeBrowserGetText(args) {
+    const selector = args['selector'];
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.getText(selector);
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || `Failed to get text: ${selector}`,
+            };
+        }
+        return {
+            success: true,
+            result: response['text'] || '(empty)',
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get text: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserGetTextTool = {
+    definition: BROWSER_GET_TEXT_DEFINITION,
+    execute: executeBrowserGetText,
+    categories: BROWSER_CATEGORIES,
+    description: 'Get text content of element',
+};
+const BROWSER_CLOSE_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_close',
+        description: `Close the browser and end the automation session.
+Use this when you are done testing.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are closing the browser',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function executeBrowserClose(_args) {
+    try {
+        await browserClient.close();
+        return {
+            success: true,
+            result: 'Browser closed successfully',
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to close browser: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserCloseTool = {
+    definition: BROWSER_CLOSE_DEFINITION,
+    execute: executeBrowserClose,
+    categories: BROWSER_CATEGORIES,
+    description: 'Close browser',
+};
+const BROWSER_GET_CONTENT_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_get_content',
+        description: `Get the HTML content of the current page.
+Returns page URL, title, and HTML source.
+
+Use this tool when you need to:
+- Find elements and their selectors
+- Understand the page structure
+- Check form fields
+- Debug page issues`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you need the page content',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function executeBrowserGetContent(_args) {
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.getHtml();
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to get page content',
+            };
+        }
+        const html = response.html || '';
+        const maxLen = 10000;
+        const truncatedHtml = html.length > maxLen
+            ? html.substring(0, maxLen) + `\n...(truncated, ${html.length} total chars)`
+            : html;
+        return {
+            success: true,
+            result: `Page: ${response.title} (${response.url})\n\nHTML:\n${truncatedHtml}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get page content: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserGetContentTool = {
+    definition: BROWSER_GET_CONTENT_DEFINITION,
+    execute: executeBrowserGetContent,
+    categories: BROWSER_CATEGORIES,
+    description: 'Get page HTML content',
+};
+const BROWSER_GET_CONSOLE_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_get_console',
+        description: `Get console logs from the browser.
+Returns console.log, console.error, console.warn messages.
+
+Use this tool to:
+- Debug JavaScript errors on the page
+- Check API response logs
+- Verify application behavior
+- Find error messages that might explain UI issues`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you need the console logs',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function executeBrowserGetConsole(_args) {
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.getConsole();
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to get console logs',
+            };
+        }
+        const logs = response.logs || [];
+        if (logs.length === 0) {
+            return {
+                success: true,
+                result: 'No console messages captured.',
+            };
+        }
+        const formatted = logs.map(log => {
+            const timestamp = new Date(log.timestamp).toLocaleTimeString('en-GB');
+            const icon = log.level === 'SEVERE' ? '❌' : log.level === 'WARNING' ? '⚠️' : '📝';
+            return `[${timestamp}] ${icon} ${log.level}: ${log.message}`;
+        }).join('\n');
+        return {
+            success: true,
+            result: `Console logs (${logs.length} messages):\n\n${formatted}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get console logs: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserGetConsoleTool = {
+    definition: BROWSER_GET_CONSOLE_DEFINITION,
+    execute: executeBrowserGetConsole,
+    categories: BROWSER_CATEGORIES,
+    description: 'Get browser console logs',
+};
+const BROWSER_GET_NETWORK_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_get_network',
+        description: `Get network request logs from the browser.
+Returns HTTP requests and responses captured during page interactions.
+
+Use this tool to:
+- Debug API calls and responses
+- Check request/response status codes
+- Verify network requests are being made correctly
+- Analyze API endpoints being called
+- Check for failed network requests`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you need the network logs',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function executeBrowserGetNetwork(_args) {
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.getNetwork();
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to get network logs',
+            };
+        }
+        const logs = response.logs || [];
+        if (logs.length === 0) {
+            return {
+                success: true,
+                result: 'No network requests captured.',
+            };
+        }
+        const formatted = logs.map(log => {
+            if (log.type === 'request') {
+                return `➡️ ${log.method} ${log.url}`;
+            }
+            else {
+                const statusIcon = log.status && log.status >= 400 ? '❌' : '✅';
+                return `${statusIcon} ${log.status} ${log.statusText} - ${log.url} (${log.mimeType || 'unknown'})`;
+            }
+        }).join('\n');
+        return {
+            success: true,
+            result: `Network logs (${logs.length} entries):\n\n${formatted}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get network logs: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserGetNetworkTool = {
+    definition: BROWSER_GET_NETWORK_DEFINITION,
+    execute: executeBrowserGetNetwork,
+    categories: BROWSER_CATEGORIES,
+    description: 'Get browser network logs',
+};
+const BROWSER_FOCUS_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_focus',
+        description: `Bring the browser window to the foreground.
+Use this to make the browser window visible and focused when needed.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you need to focus the browser window',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function executeBrowserFocus(_args) {
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.focus();
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to focus browser window',
+            };
+        }
+        return {
+            success: true,
+            result: 'Browser window brought to foreground.',
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to focus browser: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserFocusTool = {
+    definition: BROWSER_FOCUS_DEFINITION,
+    execute: executeBrowserFocus,
+    categories: BROWSER_CATEGORIES,
+    description: 'Bring browser window to foreground',
+};
+const BROWSER_PRESS_KEY_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_press_key',
+        description: `Press a keyboard key in the browser.
+
+Supports special keys:
+- Enter, Tab, Escape, Space
+- ArrowUp, ArrowDown, ArrowLeft, ArrowRight
+- Backspace, Delete, Home, End, PageUp, PageDown
+- F1-F12
+- Control, Alt, Shift, Meta
+
+Key combinations (use + to combine):
+- Control+A (select all)
+- Control+C (copy)
+- Control+V (paste)
+- Shift+Tab (reverse tab)
+
+Use this for form submission (Enter), navigation, or keyboard shortcuts.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are pressing this key',
+                },
+                key: {
+                    type: 'string',
+                    description: 'Key to press (e.g., "Enter", "Tab", "Escape", "Control+A")',
+                },
+                selector: {
+                    type: 'string',
+                    description: 'Optional CSS selector of element to focus before pressing key',
+                },
+            },
+            required: ['reason', 'key'],
+        },
+    },
+};
+async function executeBrowserPressKey(args) {
+    const key = args['key'];
+    const selector = args['selector'];
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.pressKey(key, selector);
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || `Failed to press key: ${key}`,
+            };
+        }
+        return {
+            success: true,
+            result: `Key "${key}" pressed${selector ? ` on ${selector}` : ''}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to press key: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserPressKeyTool = {
+    definition: BROWSER_PRESS_KEY_DEFINITION,
+    execute: executeBrowserPressKey,
+    categories: BROWSER_CATEGORIES,
+    description: 'Press keyboard key',
+};
+const BROWSER_TYPE_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_type',
+        description: `Type text character by character (triggers key events).
+Unlike browser_fill which sets value directly, this simulates actual typing.
+Useful for inputs that have keystroke handlers or autocomplete.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are typing this text',
+                },
+                text: {
+                    type: 'string',
+                    description: 'Text to type',
+                },
+                selector: {
+                    type: 'string',
+                    description: 'Optional CSS selector of element to type into',
+                },
+            },
+            required: ['reason', 'text'],
+        },
+    },
+};
+async function executeBrowserType(args) {
+    const text = args['text'];
+    const selector = args['selector'];
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.type(text, selector);
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to type text',
+            };
+        }
+        return {
+            success: true,
+            result: `Typed ${text.length} characters${selector ? ` into ${selector}` : ''}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to type: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserTypeTool = {
+    definition: BROWSER_TYPE_DEFINITION,
+    execute: executeBrowserType,
+    categories: BROWSER_CATEGORIES,
+    description: 'Type text character by character',
+};
+const BROWSER_EXECUTE_SCRIPT_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_execute_script',
+        description: `Execute JavaScript code in the browser context.
+The script is automatically wrapped in an async function, so you can use 'return' statements and 'await'.
+Use this only when other browser tools don't cover your use case.
+Examples:
+- "return document.title;" - returns page title
+- "return document.querySelectorAll('a').length;" - count all links
+- "return await fetch('/api/data').then(r => r.json());" - async fetch`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you need to execute this script',
+                },
+                script: {
+                    type: 'string',
+                    description: 'JavaScript code to execute (can use return and await)',
+                },
+            },
+            required: ['reason', 'script'],
+        },
+    },
+};
+async function executeBrowserExecuteScript(args) {
+    const script = args['script'];
+    if (!script) {
+        return {
+            success: false,
+            error: "The 'script' argument is required.",
+        };
+    }
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.executeScript(script);
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to execute script',
+                result: response['details'],
+            };
+        }
+        return {
+            success: true,
+            result: JSON.stringify(response['result'], null, 2),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to execute script: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserExecuteScriptTool = {
+    definition: BROWSER_EXECUTE_SCRIPT_DEFINITION,
+    execute: executeBrowserExecuteScript,
+    categories: BROWSER_CATEGORIES,
+    description: 'Execute JavaScript in browser',
+};
+export const BROWSER_TOOLS = [
+    browserLaunchTool,
+    browserNavigateTool,
+    browserScreenshotTool,
+    browserClickTool,
+    browserFillTool,
+    browserGetTextTool,
+    browserGetContentTool,
+    browserGetConsoleTool,
+    browserGetNetworkTool,
+    browserFocusTool,
+    browserPressKeyTool,
+    browserTypeTool,
+    browserExecuteScriptTool,
+    browserCloseTool,
+];
+//# sourceMappingURL=browser-tools.js.map