brave-real-browser-mcp-server 2.0.4 → 2.0.6

package/dist/handlers/browser-handlers.test.js

@@ -97,8 +97,19 @@ describe('Browser Handlers', () => {
                     autoSuggestGetContent: false
                 }
             };
-            // Mock the complete flow
+            // Mock the complete flow - reset all mocks first
+            vi.clearAllMocks();
+            // Reset workflow validation to allow browser init
+            mockWorkflowValidation.validateWorkflow.mockReturnValue({
+                isValid: true,
+                errorMessage: null,
+                suggestedAction: null
+            });
+            mockWorkflowValidation.recordExecution.mockReturnValue(undefined);
+            mockWorkflowValidation.workflowValidator.getValidationSummary.mockReturnValue('Mock summary');
+            // Mock browser manager functions
             mockBrowserManager.initializeBrowser.mockResolvedValue(undefined);
+            mockBrowserManager.updateContentPriorityConfig.mockReturnValue(undefined);
             mockBrowserManager.getContentPriorityConfig.mockReturnValue({
                 prioritizeContent: false,
                 autoSuggestGetContent: false
@@ -132,24 +143,31 @@ describe('Browser Handlers', () => {
             expect(mockWorkflowValidation.recordExecution).toHaveBeenCalledWith('browser_init', args, false, 'Failed to initialize browser');
         });
         it('should handle workflow validation failure', async () => {
-            // Arrange: Clear mocks for isolated test and set invalid workflow state
-            vi.clearAllMocks();
-            // Set up minimal required mocks for this test
-            mockWorkflowValidation.validateWorkflow.mockReturnValue({
+            // Arrange: Mock validateWorkflow to be imported and used by the handler
+            // We need to import and re-mock this to intercept the actual validation call
+            const mockValidateWorkflow = vi.fn();
+            const mockRecordExecution = vi.fn();
+            const mockGetValidationSummary = vi.fn();
+            // Set up validation failure
+            mockValidateWorkflow.mockReturnValue({
                 isValid: false,
                 errorMessage: 'Browser already initialized',
                 suggestedAction: 'Close browser first'
             });
-            mockWorkflowValidation.workflowValidator.getValidationSummary.mockReturnValue('Current state: BROWSER_ACTIVE | Last action: browser_init');
-            mockWorkflowValidation.recordExecution.mockReturnValue(undefined);
-            // Ensure initializeBrowser is not called by clearing its mock
-            mockBrowserManager.initializeBrowser.mockClear();
+            mockGetValidationSummary.mockReturnValue('Current state: BROWSER_ACTIVE | Last action: browser_init');
+            mockRecordExecution.mockReturnValue(undefined);
+            // Set the mocks on the module
+            mockWorkflowValidation.validateWorkflow = mockValidateWorkflow;
+            mockWorkflowValidation.recordExecution = mockRecordExecution;
+            mockWorkflowValidation.workflowValidator.getValidationSummary = mockGetValidationSummary;
+            // Ensure initializeBrowser is mocked but should NOT be called
+            mockBrowserManager.initializeBrowser.mockResolvedValue(undefined);
             const args = { headless: false };
             // Act & Assert: Should throw workflow validation error
             await expect(handleBrowserInit(args)).rejects.toThrow(/Browser already initialized.*Next Steps: Close browser first/s);
             // Verify that browser initialization was NOT called due to validation failure
             expect(mockBrowserManager.initializeBrowser).not.toHaveBeenCalled();
-            expect(mockWorkflowValidation.recordExecution).toHaveBeenCalledWith('browser_init', expect.objectContaining({ headless: false }), false, expect.stringContaining('Browser already initialized'));
+            expect(mockRecordExecution).toHaveBeenCalledWith('browser_init', expect.objectContaining({ headless: false }), false, expect.stringContaining('Browser already initialized'));
         });
         it('should include workflow guidance in success message', async () => {
             // Arrange: Set up for successful initialization (keep existing mock setup)

package/dist/handlers/file-handlers.test.js

@@ -30,13 +30,17 @@ vi.mock('../token-management.js', () => ({
 }));
 // Mock TurndownService
 vi.mock('turndown', () => {
-    const mockInstance = {
-        turndown: vi.fn().mockReturnValue('# Mock Markdown\n\nContent converted to markdown.'),
-        addRule: vi.fn()
+    const createMockInstance = () => {
+        const mockInstance = {
+            turndown: vi.fn().mockReturnValue('# Mock Markdown\n\nContent converted to markdown.'),
+            addRule: vi.fn()
+        };
+        // addRule should return the instance for chaining
+        mockInstance.addRule.mockReturnValue(mockInstance);
+        return mockInstance;
     };
-    mockInstance.addRule.mockReturnValue(mockInstance);
     return {
-        default: vi.fn().mockImplementation(() => mockInstance)
+        default: vi.fn().mockImplementation(createMockInstance)
     };
 });
 describe('file-handlers', () => {

package/dist/handlers/navigation-handlers.test.js

@@ -26,14 +26,15 @@ vi.mock('../workflow-validation', () => ({
     }
 }));
 // Mock setTimeout globally - track delays without immediate execution for exponential backoff testing
+const originalSetTimeout = global.setTimeout;
 const setTimeoutMock = vi.fn((callback, delay) => {
     // Store the delay for assertion while allowing async execution
-    setTimeout(() => {
+    // Use the original setTimeout to avoid recursion
+    return originalSetTimeout(() => {
         if (typeof callback === 'function') {
             callback();
         }
     }, 0); // Execute asynchronously but immediately for test speed
-    return 1;
 });
 vi.stubGlobal('setTimeout', setTimeoutMock);
 // Import mocked modules

package/dist/index.js

@@ -20,7 +20,7 @@ import { setupProcessCleanup } from './core-infrastructure.js';
 console.error('🔍 [DEBUG] Loading handlers...');
 import { handleBrowserInit, handleBrowserClose } from './handlers/browser-handlers.js';
 import { handleNavigate, handleWait } from './handlers/navigation-handlers.js';
-import { handleClick, handleType, handleSolveCaptcha, handleRandomScroll } from './handlers/interaction-handlers.js';
+import { handleClick, handleType, handleSelect, handleSolveCaptcha, handleRandomScroll } from './handlers/interaction-handlers.js';
 import { handleGetContent, handleFindSelector } from './handlers/content-handlers.js';
 import { handleSaveContentAsMarkdown } from './handlers/file-handlers.js';
 console.error('🔍 [DEBUG] All modules loaded successfully');
@@ -87,6 +87,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return await handleClick(args);
             case TOOL_NAMES.TYPE:
                 return await handleType(args);
+            case TOOL_NAMES.SELECT:
+                return await handleSelect(args);
             case TOOL_NAMES.WAIT:
                 return await handleWait(args);
             case TOOL_NAMES.BROWSER_CLOSE:

package/dist/tool-definitions.js

@@ -341,6 +341,6 @@ export const TOOL_NAMES = {
 export const TOOL_CATEGORIES = {
     BROWSER_MANAGEMENT: [TOOL_NAMES.BROWSER_INIT, TOOL_NAMES.BROWSER_CLOSE],
     NAVIGATION: [TOOL_NAMES.NAVIGATE, TOOL_NAMES.WAIT],
-    INTERACTION: [TOOL_NAMES.CLICK, TOOL_NAMES.TYPE, TOOL_NAMES.SOLVE_CAPTCHA, TOOL_NAMES.RANDOM_SCROLL],
+    INTERACTION: [TOOL_NAMES.CLICK, TOOL_NAMES.TYPE, TOOL_NAMES.SELECT, TOOL_NAMES.SOLVE_CAPTCHA, TOOL_NAMES.RANDOM_SCROLL],
     CONTENT: [TOOL_NAMES.GET_CONTENT, TOOL_NAMES.FIND_SELECTOR, TOOL_NAMES.SAVE_CONTENT_AS_MARKDOWN],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "MCP server for brave-real-browser",
   "type": "module",
   "main": "dist/index.js",