erosolar-cli 2.1.249 → 2.1.253

package/dist/tools/browserAutomationTools.js

@@ -1,916 +0,0 @@
-/**
- * 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