@jshookmcp/jshook 0.1.8 → 0.2.0

package/dist/tests/server/domains/antidebug/handlers.test.js

@@ -0,0 +1,66 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { AntiDebugToolHandlers } from '../../../../src/server/domains/antidebug/handlers.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('AntiDebugToolHandlers', () => {
+    const page = {
+        evaluateOnNewDocument: vi.fn(),
+        evaluate: vi.fn(),
+    };
+    const collector = {
+        getActivePage: vi.fn(async () => page),
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new AntiDebugToolHandlers(collector);
+    });
+    it('clamps maxDrift to minimum value in timing bypass', async () => {
+        const body = parseJson(await handlers.handleAntiDebugBypassTiming({ maxDrift: -10 }));
+        expect(body.success).toBe(true);
+        expect(body.maxDrift).toBe(0);
+        expect(page.evaluateOnNewDocument).toHaveBeenCalledOnce();
+        expect(page.evaluate).toHaveBeenCalledOnce();
+    });
+    it('clamps maxDrift to maximum value in timing bypass', async () => {
+        const body = parseJson(await handlers.handleAntiDebugBypassTiming({ maxDrift: 5000 }));
+        expect(body.success).toBe(true);
+        expect(body.maxDrift).toBe(1000);
+    });
+    it('returns error payload when timing bypass injection fails', async () => {
+        collector.getActivePage.mockRejectedValueOnce(new Error('page unavailable'));
+        const body = parseJson(await handlers.handleAntiDebugBypassTiming({}));
+        expect(body.success).toBe(false);
+        expect(body.tool).toBe('antidebug_bypass_timing');
+        expect(body.error).toContain('page unavailable');
+    });
+    it('uses default mode for invalid debugger bypass mode', async () => {
+        const body = parseJson(await handlers.handleAntiDebugBypassDebuggerStatement({ mode: 'invalid' }));
+        expect(body.success).toBe(true);
+        expect(body.mode).toBe('remove');
+    });
+    it('maps detect protections result fields', async () => {
+        page.evaluate.mockResolvedValueOnce({
+            success: true,
+            detected: true,
+            count: 2,
+            protections: [{ type: 'debugger', severity: 'high', evidence: 'x', recommendedBypass: 'remove' }],
+            recommendations: ['a'],
+            evidence: { key: 1 },
+        });
+        const body = parseJson(await handlers.handleAntiDebugDetectProtections({}));
+        expect(body.success).toBe(true);
+        expect(body.detected).toBe(true);
+        expect(body.count).toBe(2);
+        expect(body.protections.length).toBe(1);
+    });
+    it('returns default empty detect protections payload when page returns null', async () => {
+        page.evaluate.mockResolvedValueOnce(null);
+        const body = parseJson(await handlers.handleAntiDebugDetectProtections({}));
+        expect(body.success).toBe(true);
+        expect(body.detected).toBe(false);
+        expect(body.count).toBe(0);
+        expect(body.protections).toEqual([]);
+    });
+});

package/dist/tests/server/domains/browser/behavior-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/browser/behavior-tools.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { behaviorTools } from '../../../../src/server/domains/browser/definitions.tools.behavior.js';
+function getTool(name) {
+    const tool = behaviorTools.find((entry) => entry.name === name);
+    expect(tool).toBeDefined();
+    return tool;
+}
+describe('behaviorTools', () => {
+    it('describes captcha_vision_solve with generic mode and challenge type fields', () => {
+        const tool = getTool('captcha_vision_solve');
+        const props = tool.inputSchema.properties;
+        expect(tool.description).toContain('mode: "external_service"');
+        expect(tool.description).toContain('challenge class (`image` or `widget`)');
+        expect(tool.description).not.toContain('2captcha');
+        expect(tool.description).not.toContain('reCAPTCHA');
+        expect(tool.description).not.toContain('hCaptcha');
+        expect(props.mode).toBeDefined();
+        expect(props.challengeType).toBeDefined();
+    });
+    it('exposes a generic widget_challenge_solve tool without product branding', () => {
+        const tool = getTool('widget_challenge_solve');
+        const props = tool.inputSchema.properties;
+        expect(tool.description).toContain('embedded widget challenge');
+        expect(tool.description).not.toContain('Turnstile');
+        expect(tool.description).not.toContain('Cloudflare');
+        expect(tool.description).not.toContain('capsolver');
+        expect(props.mode).toBeDefined();
+        expect(props.provider).toBeDefined();
+    });
+});

package/dist/tests/server/domains/browser/browser-control.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/browser/browser-control.test.js

@@ -0,0 +1,74 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    },
+}));
+import { BrowserControlHandlers } from '../../../../src/server/domains/browser/handlers/browser-control.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('BrowserControlHandlers monitoring refresh', () => {
+    const collector = {
+        connect: vi.fn(async () => { }),
+        listPages: vi.fn(async () => []),
+        selectPage: vi.fn(async () => { }),
+        getStatus: vi.fn(async () => ({ connected: true })),
+    };
+    const consoleMonitor = {
+        disable: vi.fn(async () => { }),
+        enable: vi.fn(async () => { }),
+    };
+    const tabRegistry = {
+        setCurrentByIndex: vi.fn((index) => ({ pageId: `page-${index}` })),
+    };
+    const deps = {
+        collector,
+        pageController: {},
+        consoleMonitor,
+        getActiveDriver: () => 'chrome',
+        getCamoufoxManager: () => null,
+        getCamoufoxPage: async () => null,
+        getTabRegistry: () => tabRegistry,
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new BrowserControlHandlers(deps);
+    });
+    it('refreshes monitoring after selecting a tab', async () => {
+        collector.listPages.mockResolvedValueOnce([
+            { index: 0, url: 'https://vmoranv.github.io/jshookmcp/page-a', title: 'A' },
+            { index: 1, url: 'https://vmoranv.github.io/jshookmcp/page-b', title: 'B' },
+        ]);
+        const body = parseJson(await handlers.handleBrowserSelectTab({ index: 1 }));
+        expect(collector.selectPage).toHaveBeenCalledWith(1);
+        expect(consoleMonitor.disable).toHaveBeenCalledTimes(1);
+        expect(consoleMonitor.enable).toHaveBeenCalledWith({
+            enableNetwork: true,
+            enableExceptions: true,
+        });
+        expect(body.selectedIndex).toBe(1);
+        expect(body.networkMonitoringEnabled).toBe(true);
+        expect(body.consoleMonitoringEnabled).toBe(true);
+    });
+    it('resets and re-enables monitoring after browser attach', async () => {
+        collector.listPages.mockResolvedValueOnce([
+            { index: 0, url: 'https://vmoranv.github.io/jshookmcp/workspace/chat', title: 'Workspace Chat' },
+        ]);
+        const body = parseJson(await handlers.handleBrowserAttach({ browserURL: 'http://127.0.0.1:9222', pageIndex: 0 }));
+        expect(collector.connect).toHaveBeenCalledWith('http://127.0.0.1:9222');
+        expect(collector.selectPage).toHaveBeenCalledWith(0);
+        expect(consoleMonitor.disable).toHaveBeenCalledTimes(1);
+        expect(consoleMonitor.enable).toHaveBeenCalledWith({
+            enableNetwork: true,
+            enableExceptions: true,
+        });
+        expect(body.networkMonitoringEnabled).toBe(true);
+        expect(body.consoleMonitoringEnabled).toBe(true);
+        expect(body.currentUrl).toBe('https://vmoranv.github.io/jshookmcp/workspace/chat');
+    });
+});

package/dist/tests/server/domains/browser/captcha-solver.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/browser/captcha-solver.test.js

@@ -0,0 +1,153 @@
+import { describe, expect, it, vi } from 'vitest';
+import { handleCaptchaVisionSolve, handleWidgetChallengeSolve, } from '../../../../src/server/domains/browser/handlers/captcha-solver.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+function createMockCollector(hasPage = true) {
+    const page = hasPage
+        ? {
+            evaluate: vi.fn().mockResolvedValue({ challengeType: 'image', taskKind: 'image', siteKey: '' }),
+            url: () => 'http://test.local/page',
+        }
+        : null;
+    return { getActivePage: vi.fn().mockResolvedValue(page) };
+}
+describe('handleCaptchaVisionSolve', () => {
+    it('throws when no active page', async () => {
+        const collector = createMockCollector(false);
+        await expect(handleCaptchaVisionSolve({}, collector)).rejects.toThrow(/No active page/);
+    });
+    it('returns manual mode instruction when mode is manual', async () => {
+        const collector = createMockCollector(true);
+        const result = parseJson(await handleCaptchaVisionSolve({ mode: 'manual' }, collector));
+        expect(result.success).toBe(true);
+        expect(result.mode).toBe('manual');
+        expect(result.instruction).toBeDefined();
+    });
+    it('rejects an unimplemented legacy external service override', async () => {
+        const collector = createMockCollector(true);
+        const result = parseJson(await handleCaptchaVisionSolve({
+            mode: 'external_service',
+            provider: 'anticaptcha',
+            apiKey: 'test-key',
+        }, collector));
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('implemented');
+    });
+    it('rejects another unimplemented legacy external service override', async () => {
+        const collector = createMockCollector(true);
+        const result = parseJson(await handleCaptchaVisionSolve({
+            mode: 'external_service',
+            provider: 'capsolver',
+            apiKey: 'test-key',
+        }, collector));
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('implemented');
+    });
+    it('rejects unsupported external service overrides', async () => {
+        const collector = createMockCollector(true);
+        const result = parseJson(await handleCaptchaVisionSolve({
+            mode: 'external_service',
+            provider: 'unknown_provider',
+            apiKey: 'test-key',
+        }, collector));
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('Unsupported');
+    });
+    it('requires credentials for external service mode', async () => {
+        const collector = createMockCollector(true);
+        const origKey = process.env.CAPTCHA_API_KEY;
+        delete process.env.CAPTCHA_API_KEY;
+        const result = parseJson(await handleCaptchaVisionSolve({
+            mode: 'external_service',
+        }, collector));
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('credentials');
+        process.env.CAPTCHA_API_KEY = origKey;
+    });
+    it('clamps timeoutMs to [5000, 600000]', async () => {
+        const collector = createMockCollector(true);
+        const result = parseJson(await handleCaptchaVisionSolve({
+            mode: 'manual',
+            timeoutMs: 1,
+        }, collector));
+        expect(result.success).toBe(true);
+    });
+    it('clamps maxRetries to [0, 5]', async () => {
+        const collector = createMockCollector(true);
+        const result = parseJson(await handleCaptchaVisionSolve({
+            mode: 'manual',
+            maxRetries: 100,
+        }, collector));
+        expect(result.success).toBe(true);
+    });
+    it('auto-detects captcha type from page', async () => {
+        const collector = createMockCollector(true);
+        const result = parseJson(await handleCaptchaVisionSolve({
+            mode: 'manual',
+            typeHint: 'auto',
+        }, collector));
+        expect(result.challengeType).toBeDefined();
+    });
+});
+describe('handleWidgetChallengeSolve', () => {
+    it('throws when no active page', async () => {
+        const collector = createMockCollector(false);
+        await expect(handleWidgetChallengeSolve({}, collector)).rejects.toThrow(/No active page/);
+    });
+    it('requires siteKey detection or manual input', async () => {
+        const collector = createMockCollector(true);
+        collector.getActivePage.mockResolvedValue({
+            evaluate: vi.fn().mockResolvedValue(''),
+            url: () => 'http://test.local',
+        });
+        const result = parseJson(await handleWidgetChallengeSolve({ mode: 'external_service' }, collector));
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('siteKey');
+    });
+    it('returns manual mode when mode is manual', async () => {
+        const collector = createMockCollector(true);
+        collector.getActivePage.mockResolvedValue({
+            evaluate: vi.fn().mockResolvedValue('test-site-key'),
+            url: () => 'http://test.local',
+        });
+        const result = parseJson(await handleWidgetChallengeSolve({
+            mode: 'manual',
+            siteKey: 'test-key',
+        }, collector));
+        expect(result.success).toBe(true);
+        expect(result.mode).toBe('manual');
+        expect(result.challengeType).toBe('widget');
+    });
+    it('rejects unimplemented external service overrides', async () => {
+        const collector = createMockCollector(true);
+        const result = parseJson(await handleWidgetChallengeSolve({
+            mode: 'external_service',
+            provider: 'anticaptcha',
+            siteKey: 'test-key',
+        }, collector));
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('implemented');
+    });
+    it('requires credentials for external service mode', async () => {
+        const collector = createMockCollector(true);
+        const origKey = process.env.CAPTCHA_API_KEY;
+        delete process.env.CAPTCHA_API_KEY;
+        const result = parseJson(await handleWidgetChallengeSolve({
+            mode: 'external_service',
+            siteKey: 'test-key',
+        }, collector));
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('credentials');
+        process.env.CAPTCHA_API_KEY = origKey;
+    });
+    it('clamps timeoutMs to [5000, 600000]', async () => {
+        const collector = createMockCollector(true);
+        const result = parseJson(await handleWidgetChallengeSolve({
+            mode: 'manual',
+            siteKey: 'test-key',
+            timeoutMs: 1,
+        }, collector));
+        expect(result.success).toBe(true);
+    });
+});

package/dist/tests/server/domains/browser/handlers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/browser/handlers.test.js

@@ -0,0 +1,287 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { browserControlMocks, pageNavigationMocks, pageInteractionMocks, pageEvaluationMocks, pageDataMocks, domQueryMocks, domStyleMocks, domSearchMocks, consoleMocks, scriptManagementMocks, captchaMocks, stealthMocks, frameworkMocks, indexedMocks, detailedDataHandlerMocks, jsHeapMocks, tabWorkflowMocks, camoufoxBrowserMocks, } = vi.hoisted(() => ({
+    browserControlMocks: {
+        handleBrowserLaunch: vi.fn(async (args) => ({ from: 'browser-launch', args })),
+        handleBrowserClose: vi.fn(async (args) => ({ from: 'browser-close', args })),
+        handleBrowserStatus: vi.fn(async (args) => ({ from: 'browser-status', args })),
+        handleBrowserListTabs: vi.fn(async (args) => ({ from: 'list-tabs', args })),
+        handleBrowserSelectTab: vi.fn(async (args) => ({ from: 'select-tab', args })),
+        handleBrowserAttach: vi.fn(async (args) => ({ from: 'attach', args })),
+    },
+    pageNavigationMocks: {
+        handlePageNavigate: vi.fn(async (args) => ({ from: 'page-nav', args })),
+        handlePageReload: vi.fn(async () => ({ from: 'reload' })),
+        handlePageBack: vi.fn(async () => ({ from: 'back' })),
+        handlePageForward: vi.fn(async () => ({ from: 'forward' })),
+    },
+    pageInteractionMocks: {
+        handlePageClick: vi.fn(),
+        handlePageType: vi.fn(),
+        handlePageSelect: vi.fn(),
+        handlePageHover: vi.fn(),
+        handlePageScroll: vi.fn(),
+        handlePagePressKey: vi.fn(),
+    },
+    pageEvaluationMocks: {
+        handlePageEvaluate: vi.fn(),
+        handlePageScreenshot: vi.fn(),
+        handlePageInjectScript: vi.fn(),
+        handlePageWaitForSelector: vi.fn(),
+    },
+    pageDataMocks: {
+        handlePageGetPerformance: vi.fn(),
+        handlePageSetCookies: vi.fn(),
+        handlePageGetCookies: vi.fn(),
+        handlePageClearCookies: vi.fn(),
+        handlePageSetViewport: vi.fn(),
+        handlePageEmulateDevice: vi.fn(),
+        handlePageGetLocalStorage: vi.fn(),
+        handlePageSetLocalStorage: vi.fn(),
+        handlePageGetAllLinks: vi.fn(),
+    },
+    domQueryMocks: {
+        handleDOMQuerySelector: vi.fn(),
+        handleDOMQueryAll: vi.fn(),
+        handleDOMFindClickable: vi.fn(),
+    },
+    domStyleMocks: {
+        handleDOMGetComputedStyle: vi.fn(),
+        handleDOMIsInViewport: vi.fn(),
+    },
+    domSearchMocks: {
+        handleDOMFindByText: vi.fn(),
+        handleDOMGetXPath: vi.fn(),
+    },
+    consoleMocks: {
+        handleConsoleEnable: vi.fn(),
+        handleConsoleGetLogs: vi.fn(),
+        handleConsoleExecute: vi.fn(),
+    },
+    scriptManagementMocks: {
+        handleGetAllScripts: vi.fn(),
+        handleGetScriptSource: vi.fn(),
+    },
+    captchaMocks: {
+        handleCaptchaDetect: vi.fn(),
+        handleCaptchaWait: vi.fn(),
+        handleCaptchaConfig: vi.fn(),
+    },
+    stealthMocks: {
+        handleStealthInject: vi.fn(),
+        handleStealthSetUserAgent: vi.fn(),
+    },
+    frameworkMocks: {
+        handleFrameworkStateExtract: vi.fn(),
+    },
+    indexedMocks: {
+        handleIndexedDBDump: vi.fn(),
+    },
+    detailedDataHandlerMocks: {
+        handleGetDetailedData: vi.fn(),
+    },
+    jsHeapMocks: {
+        handleJSHeapSearch: vi.fn(),
+    },
+    tabWorkflowMocks: {
+        handleTabWorkflow: vi.fn(),
+    },
+    camoufoxBrowserMocks: {
+        handleCamoufoxServerLaunch: vi.fn(),
+        handleCamoufoxServerClose: vi.fn(),
+        handleCamoufoxServerStatus: vi.fn(),
+    },
+}));
+const { browserControlCtor, camoufoxManagerCtor, resolveOutputDirectoryMock, smartHandleMock } = vi.hoisted(() => ({
+    browserControlCtor: vi.fn(),
+    camoufoxManagerCtor: vi.fn(),
+    resolveOutputDirectoryMock: vi.fn(() => 'screenshots/captcha'),
+    smartHandleMock: vi.fn((v) => ({ wrapped: v })),
+}));
+function classFactory(spy, instance) {
+    return class {
+        constructor(deps) {
+            spy(deps);
+            return instance;
+        }
+    };
+}
+vi.mock('@src/modules/captcha/AICaptchaDetector', () => ({
+    AICaptchaDetector: class {
+        constructor() { }
+    },
+}));
+vi.mock('@src/utils/outputPaths', () => ({
+    resolveOutputDirectory: (...args) => resolveOutputDirectoryMock(...args),
+}));
+vi.mock('@src/utils/DetailedDataManager', () => ({
+    DetailedDataManager: {
+        getInstance: () => ({
+            smartHandle: (...args) => smartHandleMock(...args),
+        }),
+    },
+}));
+vi.mock('@src/modules/browser/CamoufoxBrowserManager', () => ({
+    CamoufoxBrowserManager: class {
+        page;
+        constructor(opts) {
+            camoufoxManagerCtor(opts);
+            this.page = {
+                goto: vi.fn(async () => { }),
+                title: vi.fn(async () => 'Camoufox Page'),
+                url: vi.fn(() => 'https://vmoranv.github.io/jshookmcp'),
+            };
+        }
+        async launch() { }
+        async connectToServer() { }
+        async close() { }
+        async newPage() {
+            return this.page;
+        }
+        getBrowser() {
+            return {};
+        }
+    },
+}));
+vi.mock('@src/server/domains/browser/handlers/browser-control', () => ({
+    BrowserControlHandlers: classFactory(browserControlCtor, browserControlMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/camoufox-browser', () => ({
+    CamoufoxBrowserHandlers: classFactory(vi.fn(), camoufoxBrowserMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/page-navigation', () => ({
+    PageNavigationHandlers: classFactory(vi.fn(), pageNavigationMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/page-interaction', () => ({
+    PageInteractionHandlers: classFactory(vi.fn(), pageInteractionMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/page-evaluation', () => ({
+    PageEvaluationHandlers: classFactory(vi.fn(), pageEvaluationMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/page-data', () => ({
+    PageDataHandlers: classFactory(vi.fn(), pageDataMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/dom-query', () => ({
+    DOMQueryHandlers: classFactory(vi.fn(), domQueryMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/dom-style', () => ({
+    DOMStyleHandlers: classFactory(vi.fn(), domStyleMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/dom-search', () => ({
+    DOMSearchHandlers: classFactory(vi.fn(), domSearchMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/console-handlers', () => ({
+    ConsoleHandlers: classFactory(vi.fn(), consoleMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/script-management', () => ({
+    ScriptManagementHandlers: classFactory(vi.fn(), scriptManagementMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/captcha-handlers', () => ({
+    CaptchaHandlers: classFactory(vi.fn(), captchaMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/stealth-injection', () => ({
+    StealthInjectionHandlers: classFactory(vi.fn(), stealthMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/framework-state', () => ({
+    FrameworkStateHandlers: classFactory(vi.fn(), frameworkMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/indexeddb-dump', () => ({
+    IndexedDBDumpHandlers: classFactory(vi.fn(), indexedMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/detailed-data', () => ({
+    DetailedDataHandlers: classFactory(vi.fn(), detailedDataHandlerMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/js-heap', () => ({
+    JSHeapSearchHandlers: classFactory(vi.fn(), jsHeapMocks),
+}));
+vi.mock('@src/server/domains/browser/handlers/tab-workflow', () => ({
+    TabWorkflowHandlers: classFactory(vi.fn(), tabWorkflowMocks),
+}));
+import { BrowserToolHandlers } from '../../../../src/server/domains/browser/handlers.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('BrowserToolHandlers', () => {
+    const domInspector = {
+        getStructure: vi.fn(async () => ({ node: 'root' })),
+    };
+    const collector = {
+        getActivePage: vi.fn(),
+    };
+    const pageController = {};
+    const scriptManager = {};
+    const consoleMonitor = {
+        setPlaywrightPage: vi.fn(),
+        disable: vi.fn(async () => { }),
+        clearPlaywrightPage: vi.fn(),
+    };
+    const llmService = {};
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new BrowserToolHandlers(collector, pageController, domInspector, scriptManager, consoleMonitor, llmService);
+    });
+    it('constructs BrowserControlHandlers and resolves screenshot dir', () => {
+        expect(browserControlCtor).toHaveBeenCalledOnce();
+        expect(resolveOutputDirectoryMock).toHaveBeenCalled();
+    });
+    it('launches chrome path and closes existing camoufox session', async () => {
+        handlers.activeDriver = 'camoufox';
+        handlers.camoufoxManager = { close: vi.fn(async () => { }) };
+        const result = await handlers.handleBrowserLaunch({ driver: 'chrome' });
+        expect(result).toEqual({ from: 'browser-launch', args: { driver: 'chrome' } });
+        expect(browserControlMocks.handleBrowserLaunch).toHaveBeenCalledWith({ driver: 'chrome' });
+        expect(consoleMonitor.disable).toHaveBeenCalledTimes(1);
+        expect(consoleMonitor.clearPlaywrightPage).toHaveBeenCalledTimes(1);
+    });
+    it('attaches chrome path and closes existing camoufox session', async () => {
+        handlers.activeDriver = 'camoufox';
+        handlers.camoufoxManager = { close: vi.fn(async () => { }) };
+        const result = await handlers.handleBrowserAttach({ browserURL: 'http://127.0.0.1:9222' });
+        expect(result).toEqual({ from: 'attach', args: { browserURL: 'http://127.0.0.1:9222' } });
+        expect(browserControlMocks.handleBrowserAttach).toHaveBeenCalledWith({ browserURL: 'http://127.0.0.1:9222' });
+        expect(consoleMonitor.disable).toHaveBeenCalledTimes(1);
+        expect(consoleMonitor.clearPlaywrightPage).toHaveBeenCalledTimes(1);
+    });
+    it('returns validation error for camoufox connect mode without wsEndpoint', async () => {
+        const response = await handlers.handleBrowserLaunch({
+            driver: 'camoufox',
+            mode: 'connect',
+        });
+        const body = parseJson(response);
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('wsEndpoint is required');
+    });
+    it('returns camoufox close payload when active driver is camoufox', async () => {
+        handlers.activeDriver = 'camoufox';
+        handlers.camoufoxManager = { close: vi.fn(async () => { }), getBrowser: vi.fn(() => ({})) };
+        const body = parseJson(await handlers.handleBrowserClose({}));
+        expect(body.success).toBe(true);
+        expect(body.message).toContain('Camoufox browser closed');
+        expect(browserControlMocks.handleBrowserClose).toHaveBeenCalledWith({});
+        expect(consoleMonitor.disable).toHaveBeenCalledTimes(1);
+        expect(consoleMonitor.clearPlaywrightPage).toHaveBeenCalledTimes(1);
+    });
+    it('wraps DOM structure via DetailedDataManager smartHandle', async () => {
+        const body = parseJson(await handlers.handleDOMGetStructure({ maxDepth: 2, includeText: false }));
+        expect(domInspector.getStructure).toHaveBeenCalledWith(2, false);
+        expect(smartHandleMock).toHaveBeenCalled();
+        expect(body.wrapped).toEqual({ node: 'root' });
+    });
+    it('navigates with camoufox page and updates console monitor', async () => {
+        handlers.activeDriver = 'camoufox';
+        handlers.camoufoxManager = {
+            newPage: vi.fn(async () => ({
+                goto: vi.fn(async () => { }),
+                title: vi.fn(async () => 'Camoufox Page'),
+                url: vi.fn(() => 'https://vmoranv.github.io/jshookmcp/target'),
+            })),
+            close: vi.fn(async () => { }),
+            getBrowser: vi.fn(() => ({})),
+        };
+        const body = parseJson(await handlers.handlePageNavigate({ url: 'https://vmoranv.github.io/jshookmcp/target', waitUntil: 'networkidle2' }));
+        expect(consoleMonitor.setPlaywrightPage).toHaveBeenCalledOnce();
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+        expect(body.url).toBe('https://vmoranv.github.io/jshookmcp/target');
+    });
+});

package/dist/tests/server/domains/browser/human-behavior.test.d.ts

@@ -0,0 +1 @@
+export {};