erosolar-cli 1.7.439 → 1.7.441

package/dist/tools/browserAutomationTools.js

@@ -0,0 +1,916 @@
+/**
+ * Browser Automation Tools - AI-driven browser control and automation
+ *
+ * Provides browser-use-like functionality for AI agents:
+ * - Browser session management
+ * - Navigation and interaction
+ * - Authentication helpers
+ * - Cookie/session persistence
+ * - Screenshot and content extraction
+ * - Form filling and submission
+ *
+ * @license MIT
+ * @author Bo Shang
+ */
+import { getDefaultBrowserSessionManager, } from '../browser/BrowserSessionManager.js';
+// Singleton manager for tools
+let sessionManager = null;
+function getManager() {
+    if (!sessionManager) {
+        sessionManager = getDefaultBrowserSessionManager();
+    }
+    return sessionManager;
+}
+/**
+ * Create browser automation tools
+ */
+export function createBrowserAutomationTools() {
+    return [
+        // Session Management Tools
+        {
+            name: 'browser_create_session',
+            description: `Create a new browser session for web automation.
+
+Creates a browser instance that can be controlled programmatically.
+Sessions persist cookies and authentication state across operations.
+
+Features:
+- Multiple browser types (Chromium, Firefox, WebKit)
+- Headless or headed mode
+- Stealth mode for avoiding bot detection
+- Proxy support
+- Custom viewport and user agent
+
+Example: Create a session for automated testing or web scraping.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Unique identifier for the session (auto-generated if not provided)',
+                    },
+                    browserType: {
+                        type: 'string',
+                        enum: ['chromium', 'firefox', 'webkit'],
+                        description: 'Browser engine to use (default: chromium)',
+                    },
+                    headless: {
+                        type: 'boolean',
+                        description: 'Run browser in headless mode (default: true)',
+                    },
+                    stealthMode: {
+                        type: 'boolean',
+                        description: 'Enable anti-bot-detection measures (default: false)',
+                    },
+                    viewport: {
+                        type: 'object',
+                        properties: {
+                            width: { type: 'number' },
+                            height: { type: 'number' },
+                        },
+                        description: 'Browser viewport size (default: 1920x1080)',
+                    },
+                    userAgent: {
+                        type: 'string',
+                        description: 'Custom user agent string',
+                    },
+                    proxy: {
+                        type: 'object',
+                        properties: {
+                            server: { type: 'string' },
+                            username: { type: 'string' },
+                            password: { type: 'string' },
+                        },
+                        description: 'Proxy configuration',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: 'Default timeout in milliseconds (default: 30000)',
+                    },
+                },
+            },
+            handler: async (args) => {
+                const config = {
+                    sessionId: args['sessionId'] || `session-${Date.now()}`,
+                    browserType: args['browserType'],
+                    headless: args['headless'] !== false,
+                    stealthMode: args['stealthMode'] === true,
+                    viewport: args['viewport'],
+                    userAgent: args['userAgent'],
+                    proxy: args['proxy'],
+                    timeout: args['timeout'],
+                };
+                try {
+                    const sessionId = await getManager().createSession(config);
+                    const info = getManager().getSessionInfo(sessionId);
+                    return `✅ Browser session created
+
+Session ID: ${sessionId}
+Browser: ${config.browserType || 'chromium'}
+Headless: ${config.headless !== false}
+Stealth Mode: ${config.stealthMode || false}
+Viewport: ${config.viewport ? `${config.viewport.width}x${config.viewport.height}` : '1920x1080'}
+${info?.isAuthenticated ? `Authenticated: Yes (${info.authDomain})` : 'Authenticated: No'}
+${info?.cookies?.length ? `Stored Cookies: ${info.cookies.length}` : ''}
+
+The session is ready for navigation and interaction.`;
+                }
+                catch (error) {
+                    return `❌ Failed to create browser session: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            },
+        },
+        {
+            name: 'browser_navigate',
+            description: `Navigate to a URL in an active browser session.
+
+Loads a webpage and waits for it to be ready.
+Supports different wait strategies for SPAs and dynamic content.
+
+Use this to:
+- Open websites
+- Navigate between pages
+- Follow links programmatically`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    url: {
+                        type: 'string',
+                        description: 'URL to navigate to',
+                    },
+                    waitUntil: {
+                        type: 'string',
+                        enum: ['load', 'domcontentloaded', 'networkidle'],
+                        description: 'Wait strategy (default: domcontentloaded)',
+                    },
+                },
+                required: ['sessionId', 'url'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const url = args['url'];
+                const waitUntil = args['waitUntil'];
+                const result = await getManager().navigateTo(sessionId, url, { waitUntil });
+                if (result.success) {
+                    return `✅ Navigation successful
+
+URL: ${result.url}
+Title: ${result.title}`;
+                }
+                else {
+                    return `❌ Navigation failed: ${result.error}`;
+                }
+            },
+        },
+        // Authentication Tools
+        {
+            name: 'browser_login',
+            description: `Authenticate to a website using various methods.
+
+Supports multiple authentication types:
+- form: Fill login form and submit
+- basic: HTTP Basic Authentication
+- cookie: Load saved authentication cookies
+- token: Set Bearer token in headers
+
+For form authentication, provide selectors for username/password fields and submit button.
+Successful authentication state is saved and can be reused in future sessions.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    authType: {
+                        type: 'string',
+                        enum: ['form', 'basic', 'cookie', 'token'],
+                        description: 'Authentication method',
+                    },
+                    loginUrl: {
+                        type: 'string',
+                        description: 'URL of the login page (for form auth)',
+                    },
+                    username: {
+                        type: 'string',
+                        description: 'Username or email',
+                    },
+                    password: {
+                        type: 'string',
+                        description: 'Password',
+                    },
+                    token: {
+                        type: 'string',
+                        description: 'Authentication token (for token auth)',
+                    },
+                    usernameSelector: {
+                        type: 'string',
+                        description: 'CSS selector for username field (default: input[name="username"], input[type="email"])',
+                    },
+                    passwordSelector: {
+                        type: 'string',
+                        description: 'CSS selector for password field (default: input[type="password"])',
+                    },
+                    submitSelector: {
+                        type: 'string',
+                        description: 'CSS selector for submit button (default: button[type="submit"])',
+                    },
+                    successUrl: {
+                        type: 'string',
+                        description: 'URL pattern that indicates successful login',
+                    },
+                    successSelector: {
+                        type: 'string',
+                        description: 'CSS selector that appears after successful login',
+                    },
+                },
+                required: ['sessionId', 'authType'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const authType = args['authType'];
+                const authConfig = {
+                    type: authType,
+                    credentials: {
+                        username: args['username'],
+                        password: args['password'],
+                        token: args['token'],
+                    },
+                    loginUrl: args['loginUrl'],
+                    formSelectors: authType === 'form' ? {
+                        usernameField: args['usernameSelector'] || 'input[name="username"], input[type="email"], input[name="email"]',
+                        passwordField: args['passwordSelector'] || 'input[type="password"]',
+                        submitButton: args['submitSelector'] || 'button[type="submit"], input[type="submit"]',
+                    } : undefined,
+                    successUrl: args['successUrl'],
+                    successSelector: args['successSelector'],
+                };
+                const result = await getManager().authenticate(sessionId, authConfig);
+                if (result.success) {
+                    const info = getManager().getSessionInfo(sessionId);
+                    return `✅ Authentication successful
+
+${result.message}
+${info?.authDomain ? `Domain: ${info.authDomain}` : ''}
+Cookies saved for future sessions.`;
+                }
+                else {
+                    return `❌ Authentication failed: ${result.message}`;
+                }
+            },
+        },
+        // Interaction Tools
+        {
+            name: 'browser_click',
+            description: `Click on an element in the browser.
+
+Uses CSS selectors to find and click elements.
+Waits for the element to be visible before clicking.
+
+Examples:
+- Click a button: button.submit-btn
+- Click a link: a[href="/dashboard"]
+- Click by text: text="Sign In"`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: 'CSS selector or text selector for the element',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: 'Timeout in milliseconds (default: 10000)',
+                    },
+                    force: {
+                        type: 'boolean',
+                        description: 'Force click even if element is not visible',
+                    },
+                },
+                required: ['sessionId', 'selector'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const selector = args['selector'];
+                const timeout = args['timeout'];
+                const force = args['force'];
+                const result = await getManager().click(sessionId, selector, { timeout, force });
+                if (result.success) {
+                    return `✅ Clicked element: ${selector}`;
+                }
+                else {
+                    return `❌ Failed to click: ${result.error}`;
+                }
+            },
+        },
+        {
+            name: 'browser_type',
+            description: `Type text into an input field.
+
+Simulates human-like typing with configurable delay.
+Can optionally clear the field before typing.
+
+Use for:
+- Filling form fields
+- Search inputs
+- Text areas`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: 'CSS selector for the input element',
+                    },
+                    text: {
+                        type: 'string',
+                        description: 'Text to type',
+                    },
+                    delay: {
+                        type: 'number',
+                        description: 'Delay between keystrokes in ms (default: 50)',
+                    },
+                    clear: {
+                        type: 'boolean',
+                        description: 'Clear field before typing (default: false)',
+                    },
+                },
+                required: ['sessionId', 'selector', 'text'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const selector = args['selector'];
+                const text = args['text'];
+                const delay = args['delay'];
+                const clear = args['clear'];
+                const result = await getManager().type(sessionId, selector, text, { delay, clear });
+                if (result.success) {
+                    return `✅ Typed "${text.slice(0, 50)}${text.length > 50 ? '...' : ''}" into ${selector}`;
+                }
+                else {
+                    return `❌ Failed to type: ${result.error}`;
+                }
+            },
+        },
+        {
+            name: 'browser_fill',
+            description: `Fill an input field instantly (faster than type).
+
+Sets the value of an input field directly.
+Use this for quick form filling when typing simulation isn't needed.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: 'CSS selector for the input element',
+                    },
+                    value: {
+                        type: 'string',
+                        description: 'Value to fill',
+                    },
+                },
+                required: ['sessionId', 'selector', 'value'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const selector = args['selector'];
+                const value = args['value'];
+                const result = await getManager().fill(sessionId, selector, value);
+                if (result.success) {
+                    return `✅ Filled ${selector} with "${value.slice(0, 50)}${value.length > 50 ? '...' : ''}"`;
+                }
+                else {
+                    return `❌ Failed to fill: ${result.error}`;
+                }
+            },
+        },
+        {
+            name: 'browser_select',
+            description: `Select an option from a dropdown menu.
+
+Works with <select> elements.
+Can select by value, label, or index.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: 'CSS selector for the select element',
+                    },
+                    value: {
+                        type: 'string',
+                        description: 'Option value to select',
+                    },
+                },
+                required: ['sessionId', 'selector', 'value'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const selector = args['selector'];
+                const value = args['value'];
+                const result = await getManager().selectOption(sessionId, selector, value);
+                if (result.success) {
+                    return `✅ Selected "${value}" in ${selector}`;
+                }
+                else {
+                    return `❌ Failed to select: ${result.error}`;
+                }
+            },
+        },
+        {
+            name: 'browser_checkbox',
+            description: `Check or uncheck a checkbox.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: 'CSS selector for the checkbox',
+                    },
+                    checked: {
+                        type: 'boolean',
+                        description: 'Whether to check (true) or uncheck (false)',
+                    },
+                },
+                required: ['sessionId', 'selector', 'checked'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const selector = args['selector'];
+                const checked = args['checked'];
+                const result = await getManager().setChecked(sessionId, selector, checked);
+                if (result.success) {
+                    return `✅ ${checked ? 'Checked' : 'Unchecked'} ${selector}`;
+                }
+                else {
+                    return `❌ Failed to set checkbox: ${result.error}`;
+                }
+            },
+        },
+        {
+            name: 'browser_upload_file',
+            description: `Upload a file using a file input.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: 'CSS selector for the file input',
+                    },
+                    filePath: {
+                        type: 'string',
+                        description: 'Path to the file to upload',
+                    },
+                },
+                required: ['sessionId', 'selector', 'filePath'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const selector = args['selector'];
+                const filePath = args['filePath'];
+                const result = await getManager().uploadFile(sessionId, selector, filePath);
+                if (result.success) {
+                    return `✅ Uploaded file to ${selector}`;
+                }
+                else {
+                    return `❌ Failed to upload: ${result.error}`;
+                }
+            },
+        },
+        // Content Extraction Tools
+        {
+            name: 'browser_get_text',
+            description: `Get the text content of an element.
+
+Extracts visible text from the specified element.
+Useful for reading labels, content, or verification.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: 'CSS selector for the element',
+                    },
+                },
+                required: ['sessionId', 'selector'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const selector = args['selector'];
+                const result = await getManager().getText(sessionId, selector);
+                if (result.success) {
+                    return `Text content of ${selector}:\n\n${result.text}`;
+                }
+                else {
+                    return `❌ Failed to get text: ${result.error}`;
+                }
+            },
+        },
+        {
+            name: 'browser_get_page_content',
+            description: `Get the full HTML content of the current page.
+
+Returns the complete HTML source of the page.
+Useful for:
+- Analyzing page structure
+- Extracting data
+- Debugging`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                },
+                required: ['sessionId'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const result = await getManager().getPageContent(sessionId);
+                if (result.success) {
+                    const html = result.html || '';
+                    if (html.length > 50000) {
+                        // CRITICAL: Check if truncated portion might contain error indicators
+                        const truncatedPortion = html.slice(50000);
+                        const errorIndicators = ['error', 'failed', 'exception', '404', '500', 'denied', 'unauthorized'];
+                        const mayContainErrors = errorIndicators.some(indicator => truncatedPortion.toLowerCase().includes(indicator));
+                        let warning = '';
+                        if (mayContainErrors) {
+                            warning = '\n\n⚠️ WARNING: Truncated content may contain error indicators. Full content should be reviewed if operation appears to have failed.';
+                        }
+                        return `Page HTML (truncated to 50000 chars):\n\n${html.slice(0, 50000)}\n\n[... ${html.length - 50000} more characters truncated]${warning}`;
+                    }
+                    return `Page HTML:\n\n${html}`;
+                }
+                else {
+                    return `❌ Failed to get page content: ${result.error}`;
+                }
+            },
+        },
+        {
+            name: 'browser_screenshot',
+            description: `Take a screenshot of the current page.
+
+Captures the visible area or full page.
+Returns base64-encoded PNG image data or saves to file.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    fullPage: {
+                        type: 'boolean',
+                        description: 'Capture full scrollable page (default: false)',
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'File path to save screenshot (optional)',
+                    },
+                },
+                required: ['sessionId'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const fullPage = args['fullPage'];
+                const path = args['path'];
+                const result = await getManager().takeScreenshot(sessionId, { fullPage, path });
+                if (result.success) {
+                    if (result.path) {
+                        return `✅ Screenshot saved to: ${result.path}`;
+                    }
+                    else {
+                        return `✅ Screenshot captured (base64):\n\ndata:image/png;base64,${result.data?.slice(0, 100)}...\n\n[${result.data?.length || 0} characters total]`;
+                    }
+                }
+                else {
+                    return `❌ Failed to take screenshot: ${result.error}`;
+                }
+            },
+        },
+        // Wait Tools
+        {
+            name: 'browser_wait_for',
+            description: `Wait for an element to appear on the page.
+
+Useful for waiting for:
+- Dynamic content to load
+- AJAX responses
+- Animations to complete
+- Elements to become visible`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: 'CSS selector to wait for',
+                    },
+                    state: {
+                        type: 'string',
+                        enum: ['attached', 'visible', 'hidden'],
+                        description: 'Element state to wait for (default: visible)',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: 'Timeout in milliseconds (default: 30000)',
+                    },
+                },
+                required: ['sessionId', 'selector'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const selector = args['selector'];
+                const state = args['state'];
+                const timeout = args['timeout'];
+                const result = await getManager().waitForSelector(sessionId, selector, { state, timeout });
+                if (result.success) {
+                    return `✅ Element ${selector} is now ${state || 'visible'}`;
+                }
+                else {
+                    return `❌ Wait failed: ${result.error}`;
+                }
+            },
+        },
+        // JavaScript Execution
+        {
+            name: 'browser_execute_script',
+            description: `Execute JavaScript in the browser context.
+
+Run custom JavaScript code on the page.
+Can return values from the page context.
+
+Use for:
+- Complex interactions not supported by other tools
+- Reading JavaScript variables
+- Triggering custom events`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    script: {
+                        type: 'string',
+                        description: 'JavaScript code to execute',
+                    },
+                },
+                required: ['sessionId', 'script'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const script = args['script'];
+                const result = await getManager().executeScript(sessionId, script);
+                if (result.success) {
+                    const resultStr = typeof result.result === 'object'
+                        ? JSON.stringify(result.result, null, 2)
+                        : String(result.result);
+                    return `✅ Script executed\n\nResult:\n${resultStr}`;
+                }
+                else {
+                    return `❌ Script execution failed: ${result.error}`;
+                }
+            },
+        },
+        // Cookie Management
+        {
+            name: 'browser_get_cookies',
+            description: `Get all cookies from the browser session.
+
+Returns cookies for the current session.
+Can filter by specific URLs.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    urls: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Filter cookies by URLs (optional)',
+                    },
+                },
+                required: ['sessionId'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const urls = args['urls'];
+                const result = await getManager().getCookies(sessionId, urls);
+                if (result.success) {
+                    const cookies = result.cookies || [];
+                    if (cookies.length === 0) {
+                        return 'No cookies found';
+                    }
+                    const cookieList = cookies.map(c => `- ${c.name}: ${c.value.slice(0, 30)}${c.value.length > 30 ? '...' : ''} (${c.domain})`).join('\n');
+                    return `Cookies (${cookies.length}):\n\n${cookieList}`;
+                }
+                else {
+                    return `❌ Failed to get cookies: ${result.error}`;
+                }
+            },
+        },
+        {
+            name: 'browser_clear_cookies',
+            description: `Clear all cookies from the browser session.
+
+Removes all cookies and resets authentication state.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                },
+                required: ['sessionId'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const result = await getManager().clearCookies(sessionId);
+                if (result.success) {
+                    return '✅ Cookies cleared';
+                }
+                else {
+                    return `❌ Failed to clear cookies: ${result.error}`;
+                }
+            },
+        },
+        // Session Management
+        {
+            name: 'browser_close_session',
+            description: `Close a browser session.
+
+Closes the browser and optionally saves cookies for future use.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to close',
+                    },
+                    saveCookies: {
+                        type: 'boolean',
+                        description: 'Save cookies before closing (default: true)',
+                    },
+                },
+                required: ['sessionId'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const saveCookies = args['saveCookies'] !== false;
+                await getManager().closeSession(sessionId, saveCookies);
+                return `✅ Session ${sessionId} closed${saveCookies ? ' (cookies saved)' : ''}`;
+            },
+        },
+        {
+            name: 'browser_list_sessions',
+            description: `List all stored browser sessions.
+
+Shows sessions that have been saved and can be resumed.`,
+            parameters: {
+                type: 'object',
+                properties: {},
+            },
+            handler: async () => {
+                const sessions = getManager().listStoredSessions();
+                if (sessions.length === 0) {
+                    return 'No stored sessions found';
+                }
+                const sessionInfo = sessions.map(id => {
+                    const info = getManager().getSessionInfo(id);
+                    if (info) {
+                        return `- ${id}
+  Browser: ${info.browserType}
+  Created: ${new Date(info.createdAt).toISOString()}
+  Authenticated: ${info.isAuthenticated ? `Yes (${info.authDomain})` : 'No'}
+  Cookies: ${info.cookies?.length || 0}`;
+                    }
+                    return `- ${id} (no info available)`;
+                }).join('\n\n');
+                return `Stored Sessions:\n\n${sessionInfo}`;
+            },
+        },
+        {
+            name: 'browser_delete_session',
+            description: `Delete stored session data.
+
+Removes saved cookies and authentication state for a session.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to delete',
+                    },
+                },
+                required: ['sessionId'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const deleted = getManager().deleteStoredSession(sessionId);
+                if (deleted) {
+                    return `✅ Session ${sessionId} data deleted`;
+                }
+                else {
+                    return `Session ${sessionId} not found in storage`;
+                }
+            },
+        },
+        // Form Automation
+        {
+            name: 'browser_fill_form',
+            description: `Fill multiple form fields at once.
+
+Accepts a mapping of selectors to values and fills them all.
+More efficient than individual fill calls for complex forms.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID to use',
+                    },
+                    fields: {
+                        type: 'object',
+                        additionalProperties: true,
+                        description: 'Object mapping selectors to values (selector: value pairs)',
+                    },
+                    submit: {
+                        type: 'string',
+                        description: 'Optional selector for submit button to click after filling',
+                    },
+                },
+                required: ['sessionId', 'fields'],
+            },
+            handler: async (args) => {
+                const sessionId = args['sessionId'];
+                const fields = args['fields'];
+                const submit = args['submit'];
+                const results = [];
+                let hasError = false;
+                for (const [selector, value] of Object.entries(fields)) {
+                    const result = await getManager().fill(sessionId, selector, value);
+                    if (result.success) {
+                        results.push(`✅ ${selector}: "${value.slice(0, 20)}${value.length > 20 ? '...' : ''}"`);
+                    }
+                    else {
+                        results.push(`❌ ${selector}: ${result.error}`);
+                        hasError = true;
+                    }
+                }
+                if (submit && !hasError) {
+                    const clickResult = await getManager().click(sessionId, submit);
+                    if (clickResult.success) {
+                        results.push(`✅ Form submitted via ${submit}`);
+                    }
+                    else {
+                        results.push(`❌ Submit failed: ${clickResult.error}`);
+                    }
+                }
+                return `Form Fill Results:\n\n${results.join('\n')}`;
+            },
+        },
+    ];
+}
+export { getManager as getBrowserSessionManager };
+//# sourceMappingURL=browserAutomationTools.js.map