local-cli-agent 5.0.4 → 5.0.6

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

@@ -6,8 +6,11 @@ const BROWSER_LAUNCH_DEFINITION = {
     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).`,
+Uses Chrome DevTools Protocol (CDP) for browser control.
+If browser is already running, returns existing session.
+
+IMPORTANT: For visual testing or when user needs to see the browser, use headless: false (default).
+Only use headless: true when explicitly requested by the user.`,
         parameters: {
             type: 'object',
             properties: {
@@ -74,7 +77,8 @@ const BROWSER_NAVIGATE_DEFINITION = {
     type: 'function',
     function: {
         name: 'browser_navigate',
-        description: `Navigate browser to a URL. Use this to open web pages for testing.
+        description: `Navigate browser to a URL. Waits for page load to complete.
+
 Common URLs:
 - http://localhost:3000 - Local development server
 - http://localhost:8080 - Alternative local server
@@ -345,21 +349,21 @@ const BROWSER_GET_TEXT_DEFINITION = {
     type: 'function',
     function: {
         name: 'browser_get_text',
-        description: `Get the text content of an element.
+        description: `Get text content from an element or the entire page.
 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',
+                    description: 'Explanation of why you need the text',
                 },
                 selector: {
                     type: 'string',
-                    description: 'CSS selector of the element to read',
+                    description: 'CSS selector of element (optional, gets full page text if not provided)',
                 },
             },
-            required: ['reason', 'selector'],
+            required: ['reason'],
         },
     },
 };
@@ -377,17 +381,18 @@ async function executeBrowserGetText(args) {
         }
         const response = await browserClient.getText(selector);
         if (!response.success) {
-            logger.toolError('browser_get_text', args, new Error(response.error || `Failed to get text: ${selector}`), Date.now() - startTime);
+            logger.toolError('browser_get_text', args, new Error(response.error || 'Failed to get text'), Date.now() - startTime);
             return {
                 success: false,
-                error: response.error || `Failed to get text: ${selector}`,
+                error: response.error || 'Failed to get text',
             };
         }
         const text = response['text'] || '(empty)';
+        const truncated = text.length > 5000 ? text.slice(0, 5000) + '\n... (truncated)' : text;
         logger.toolSuccess('browser_get_text', args, { selector, textLength: text.length }, Date.now() - startTime);
         return {
             success: true,
-            result: text,
+            result: truncated,
         };
     }
     catch (error) {
@@ -447,36 +452,33 @@ export const browserCloseTool = {
     categories: BROWSER_CATEGORIES,
     description: 'Close browser',
 };
-const BROWSER_GET_CONTENT_DEFINITION = {
+const BROWSER_GET_HTML_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`,
+        name: 'browser_get_html',
+        description: `Get the HTML content of the current page or a specific element.`,
         parameters: {
             type: 'object',
             properties: {
                 reason: {
                     type: 'string',
-                    description: 'Explanation of why you need the page content',
+                    description: 'Explanation of why you need the HTML',
+                },
+                selector: {
+                    type: 'string',
+                    description: 'CSS selector to get HTML of specific element (optional, gets full page if not provided)',
                 },
             },
             required: ['reason'],
         },
     },
 };
-async function executeBrowserGetContent(args) {
+async function executeBrowserGetHtml(args) {
     const startTime = Date.now();
-    logger.toolStart('browser_get_content', {});
+    logger.toolStart('browser_get_html', args);
     try {
         if (!(await browserClient.isBrowserActive())) {
-            logger.toolError('browser_get_content', args, new Error('Browser not running'), Date.now() - startTime);
+            logger.toolError('browser_get_html', args, new Error('Browser not running'), Date.now() - startTime);
             return {
                 success: false,
                 error: 'Browser is not running. Use browser_launch first.',
@@ -484,10 +486,10 @@ async function executeBrowserGetContent(args) {
         }
         const response = await browserClient.getHtml();
         if (!response.success) {
-            logger.toolError('browser_get_content', args, new Error(response.error || 'Failed to get page content'), Date.now() - startTime);
+            logger.toolError('browser_get_html', args, new Error(response.error || 'Failed to get HTML'), Date.now() - startTime);
             return {
                 success: false,
-                error: response.error || 'Failed to get page content',
+                error: response.error || 'Failed to get HTML',
             };
         }
         const html = response.html || '';
@@ -495,25 +497,25 @@ async function executeBrowserGetContent(args) {
         const truncatedHtml = html.length > maxLen
             ? html.substring(0, maxLen) + `\n...(truncated, ${html.length} total chars)`
             : html;
-        logger.toolSuccess('browser_get_content', args, { url: response.url, title: response.title, htmlLength: html.length }, Date.now() - startTime);
+        logger.toolSuccess('browser_get_html', args, { url: response.url, title: response.title, htmlLength: html.length }, Date.now() - startTime);
         return {
             success: true,
-            result: `Page: ${response.title} (${response.url})\n\nHTML:\n${truncatedHtml}`,
+            result: truncatedHtml,
         };
     }
     catch (error) {
-        logger.toolError('browser_get_content', args, error, Date.now() - startTime);
+        logger.toolError('browser_get_html', args, error, Date.now() - startTime);
         return {
             success: false,
-            error: `Failed to get page content: ${error instanceof Error ? error.message : String(error)}`,
+            error: `Failed to get HTML: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
 }
-export const browserGetContentTool = {
-    definition: BROWSER_GET_CONTENT_DEFINITION,
-    execute: executeBrowserGetContent,
+export const browserGetHtmlTool = {
+    definition: BROWSER_GET_HTML_DEFINITION,
+    execute: executeBrowserGetHtml,
     categories: BROWSER_CATEGORIES,
-    description: 'Get page HTML content',
+    description: 'Get page HTML',
 };
 const BROWSER_GET_CONSOLE_DEFINITION = {
     type: 'function',
@@ -672,10 +674,10 @@ export const browserGetNetworkTool = {
     categories: BROWSER_CATEGORIES,
     description: 'Get browser network logs',
 };
-const BROWSER_FOCUS_DEFINITION = {
+const BROWSER_BRING_TO_FRONT_DEFINITION = {
     type: 'function',
     function: {
-        name: 'browser_focus',
+        name: 'browser_bring_to_front',
         description: `Bring the browser window to the foreground.
 Use this to make the browser window visible and focused when needed.`,
         parameters: {
@@ -683,19 +685,19 @@ Use this to make the browser window visible and focused when needed.`,
             properties: {
                 reason: {
                     type: 'string',
-                    description: 'Explanation of why you need to focus the browser window',
+                    description: 'Explanation of why you need to bring the browser window to front',
                 },
             },
             required: ['reason'],
         },
     },
 };
-async function executeBrowserFocus(args) {
+async function executeBrowserBringToFront(args) {
     const startTime = Date.now();
-    logger.toolStart('browser_focus', {});
+    logger.toolStart('browser_bring_to_front', {});
     try {
         if (!(await browserClient.isBrowserActive())) {
-            logger.toolError('browser_focus', args, new Error('Browser not running'), Date.now() - startTime);
+            logger.toolError('browser_bring_to_front', args, new Error('Browser not running'), Date.now() - startTime);
             return {
                 success: false,
                 error: 'Browser is not running. Use browser_launch first.',
@@ -703,29 +705,29 @@ async function executeBrowserFocus(args) {
         }
         const response = await browserClient.focus();
         if (!response.success) {
-            logger.toolError('browser_focus', args, new Error(response.error || 'Failed to focus browser window'), Date.now() - startTime);
+            logger.toolError('browser_bring_to_front', args, new Error(response.error || 'Failed to bring browser to front'), Date.now() - startTime);
             return {
                 success: false,
-                error: response.error || 'Failed to focus browser window',
+                error: response.error || 'Failed to bring browser to front',
             };
         }
-        logger.toolSuccess('browser_focus', args, { focused: true }, Date.now() - startTime);
+        logger.toolSuccess('browser_bring_to_front', args, { focused: true }, Date.now() - startTime);
         return {
             success: true,
             result: 'Browser window brought to foreground.',
         };
     }
     catch (error) {
-        logger.toolError('browser_focus', args, error, Date.now() - startTime);
+        logger.toolError('browser_bring_to_front', args, error, Date.now() - startTime);
         return {
             success: false,
-            error: `Failed to focus browser: ${error instanceof Error ? error.message : String(error)}`,
+            error: `Failed to bring browser to front: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
 }
-export const browserFocusTool = {
-    definition: BROWSER_FOCUS_DEFINITION,
-    execute: executeBrowserFocus,
+export const browserBringToFrontTool = {
+    definition: BROWSER_BRING_TO_FRONT_DEFINITION,
+    execute: executeBrowserBringToFront,
     categories: BROWSER_CATEGORIES,
     description: 'Bring browser window to foreground',
 };
@@ -953,6 +955,373 @@ export const browserExecuteScriptTool = {
     categories: BROWSER_CATEGORIES,
     description: 'Execute JavaScript in browser',
 };
+const BROWSER_WAIT_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_wait',
+        description: `Wait for an element to appear or for a specified time.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are waiting',
+                },
+                selector: {
+                    type: 'string',
+                    description: 'CSS selector to wait for (optional)',
+                },
+                timeout: {
+                    type: 'number',
+                    description: 'Timeout in seconds (default: 10)',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function executeBrowserWait(args) {
+    const selector = args['selector'];
+    const timeout = args['timeout'] || 10;
+    const startTime = Date.now();
+    logger.toolStart('browser_wait', { selector, timeout });
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            logger.toolError('browser_wait', args, new Error('Browser not running'), Date.now() - startTime);
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.waitFor(selector || '', timeout);
+        if (!response.success) {
+            logger.toolError('browser_wait', args, new Error(response.error || 'Wait failed'), Date.now() - startTime);
+            return {
+                success: false,
+                error: response.error || 'Wait failed',
+            };
+        }
+        logger.toolSuccess('browser_wait', args, { selector, timeout }, Date.now() - startTime);
+        return {
+            success: true,
+            result: response.message || 'Wait completed',
+        };
+    }
+    catch (error) {
+        logger.toolError('browser_wait', args, error, Date.now() - startTime);
+        return {
+            success: false,
+            error: `Wait failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserWaitTool = {
+    definition: BROWSER_WAIT_DEFINITION,
+    execute: executeBrowserWait,
+    categories: BROWSER_CATEGORIES,
+    description: 'Wait for element or time',
+};
+const BROWSER_CONNECT_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_connect',
+        description: `Connect to an existing browser that has remote debugging enabled.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are connecting',
+                },
+                port: {
+                    type: 'number',
+                    description: 'CDP port to connect to (default: 9222)',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function executeBrowserConnect(args) {
+    const port = args['port'];
+    const startTime = Date.now();
+    logger.toolStart('browser_connect', { port });
+    try {
+        const response = await browserClient.connect(port);
+        if (!response.success) {
+            logger.toolError('browser_connect', args, new Error(response.error || 'Failed to connect'), Date.now() - startTime);
+            return {
+                success: false,
+                error: response.error || 'Failed to connect',
+            };
+        }
+        logger.toolSuccess('browser_connect', args, { url: response['url'] }, Date.now() - startTime);
+        return {
+            success: true,
+            result: `Connected to browser at ${response['url']}`,
+        };
+    }
+    catch (error) {
+        logger.toolError('browser_connect', args, error, Date.now() - startTime);
+        return {
+            success: false,
+            error: `Failed to connect: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserConnectTool = {
+    definition: BROWSER_CONNECT_DEFINITION,
+    execute: executeBrowserConnect,
+    categories: BROWSER_CATEGORIES,
+    description: 'Connect to existing browser',
+};
+const BROWSER_GET_HEALTH_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_get_health',
+        description: `Check browser connection health and status.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are checking health',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function executeBrowserGetHealth(args) {
+    const startTime = Date.now();
+    logger.toolStart('browser_get_health', args);
+    try {
+        const response = await browserClient.getHealth();
+        if (!response) {
+            logger.toolError('browser_get_health', args, new Error('Failed to get health'), Date.now() - startTime);
+            return {
+                success: false,
+                error: 'Failed to get browser health',
+            };
+        }
+        logger.toolSuccess('browser_get_health', args, { status: response.status }, Date.now() - startTime);
+        return {
+            success: true,
+            result: JSON.stringify({
+                status: response.status,
+                version: response.version,
+                browser: response.browser,
+            }, null, 2),
+        };
+    }
+    catch (error) {
+        logger.toolError('browser_get_health', args, error, Date.now() - startTime);
+        return {
+            success: false,
+            error: `Failed to get health: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserGetHealthTool = {
+    definition: BROWSER_GET_HEALTH_DEFINITION,
+    execute: executeBrowserGetHealth,
+    categories: BROWSER_CATEGORIES,
+    description: 'Check browser health',
+};
+const BROWSER_GET_PAGE_INFO_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_get_page_info',
+        description: `Get information about the current page (URL, title, element counts, etc.).`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you need page info',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function executeBrowserGetPageInfo(args) {
+    const startTime = Date.now();
+    logger.toolStart('browser_get_page_info', args);
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            logger.toolError('browser_get_page_info', args, new Error('Browser not running'), Date.now() - startTime);
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.getPageInfo();
+        if (!response.success) {
+            logger.toolError('browser_get_page_info', args, new Error(response.error || 'Failed to get page info'), Date.now() - startTime);
+            return {
+                success: false,
+                error: response.error || 'Failed to get page info',
+            };
+        }
+        logger.toolSuccess('browser_get_page_info', args, { url: response['url'] }, Date.now() - startTime);
+        return {
+            success: true,
+            result: JSON.stringify({
+                url: response['url'],
+                title: response['title'],
+                domain: response['domain'],
+                readyState: response['readyState'],
+                linkCount: response['linkCount'],
+                imageCount: response['imageCount'],
+                formCount: response['formCount'],
+                inputCount: response['inputCount'],
+            }, null, 2),
+        };
+    }
+    catch (error) {
+        logger.toolError('browser_get_page_info', args, error, Date.now() - startTime);
+        return {
+            success: false,
+            error: `Failed to get page info: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserGetPageInfoTool = {
+    definition: BROWSER_GET_PAGE_INFO_DEFINITION,
+    execute: executeBrowserGetPageInfo,
+    categories: BROWSER_CATEGORIES,
+    description: 'Get page information',
+};
+const BROWSER_SEND_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_send',
+        description: `Send a low-level CDP (Chrome DevTools Protocol) command.
+Use this for advanced operations not covered by other tools.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are sending this command',
+                },
+                method: {
+                    type: 'string',
+                    description: 'CDP method name (e.g., "Page.navigate", "DOM.getDocument")',
+                },
+                params: {
+                    type: 'object',
+                    description: 'Parameters for the CDP method',
+                },
+            },
+            required: ['reason', 'method'],
+        },
+    },
+};
+async function executeBrowserSend(args) {
+    const method = args['method'];
+    const params = args['params'];
+    const startTime = Date.now();
+    logger.toolStart('browser_send', { method });
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            logger.toolError('browser_send', args, new Error('Browser not running'), Date.now() - startTime);
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.send(method, params);
+        if (!response.success) {
+            logger.toolError('browser_send', args, new Error(response.error || 'Failed to send CDP command'), Date.now() - startTime);
+            return {
+                success: false,
+                error: response.error || 'Failed to send CDP command',
+            };
+        }
+        logger.toolSuccess('browser_send', args, { method }, Date.now() - startTime);
+        return {
+            success: true,
+            result: JSON.stringify(response['result'], null, 2),
+        };
+    }
+    catch (error) {
+        logger.toolError('browser_send', args, error, Date.now() - startTime);
+        return {
+            success: false,
+            error: `Failed to send CDP command: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserSendTool = {
+    definition: BROWSER_SEND_DEFINITION,
+    execute: executeBrowserSend,
+    categories: BROWSER_CATEGORIES,
+    description: 'Send CDP command',
+};
+const BROWSER_FOCUS_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'browser_focus',
+        description: `Focus on a DOM element by CSS selector.
+Use this to focus input fields or other focusable elements.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why you are focusing this element',
+                },
+                selector: {
+                    type: 'string',
+                    description: 'CSS selector of element to focus',
+                },
+            },
+            required: ['reason', 'selector'],
+        },
+    },
+};
+async function executeBrowserFocus(args) {
+    const selector = args['selector'];
+    const startTime = Date.now();
+    logger.toolStart('browser_focus', { selector });
+    try {
+        if (!(await browserClient.isBrowserActive())) {
+            logger.toolError('browser_focus', args, new Error('Browser not running'), Date.now() - startTime);
+            return {
+                success: false,
+                error: 'Browser is not running. Use browser_launch first.',
+            };
+        }
+        const response = await browserClient.focusElement(selector);
+        if (!response.success) {
+            logger.toolError('browser_focus', args, new Error(response.error || 'Failed to focus element'), Date.now() - startTime);
+            return {
+                success: false,
+                error: response.error || 'Failed to focus element',
+            };
+        }
+        logger.toolSuccess('browser_focus', args, { selector }, Date.now() - startTime);
+        return {
+            success: true,
+            result: `Element focused: ${selector}`,
+        };
+    }
+    catch (error) {
+        logger.toolError('browser_focus', args, error, Date.now() - startTime);
+        return {
+            success: false,
+            error: `Failed to focus element: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export const browserFocusTool = {
+    definition: BROWSER_FOCUS_DEFINITION,
+    execute: executeBrowserFocus,
+    categories: BROWSER_CATEGORIES,
+    description: 'Focus element',
+};
 export const BROWSER_TOOLS = [
     browserLaunchTool,
     browserNavigateTool,
@@ -960,14 +1329,20 @@ export const BROWSER_TOOLS = [
     browserClickTool,
     browserFillTool,
     browserGetTextTool,
-    browserGetContentTool,
+    browserGetHtmlTool,
     browserGetConsoleTool,
     browserGetNetworkTool,
+    browserBringToFrontTool,
     browserFocusTool,
     browserPressKeyTool,
     browserTypeTool,
     browserExecuteScriptTool,
     browserCloseTool,
+    browserWaitTool,
+    browserConnectTool,
+    browserGetHealthTool,
+    browserGetPageInfoTool,
+    browserSendTool,
 ];
 export const BROWSER_SUB_AGENT_TOOLS = [
     browserNavigateTool,
@@ -975,9 +1350,13 @@ export const BROWSER_SUB_AGENT_TOOLS = [
     browserClickTool,
     browserFillTool,
     browserGetTextTool,
+    browserGetHtmlTool,
+    browserGetPageInfoTool,
     browserFocusTool,
     browserPressKeyTool,
     browserTypeTool,
     browserExecuteScriptTool,
+    browserWaitTool,
+    browserSendTool,
 ];
 //# sourceMappingURL=browser-tools.js.map