@jshookmcp/jshook 0.1.9 → 0.2.1

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

@@ -0,0 +1,22 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import '../shared/manifest-test-mocks.js';
+import { assertDomainExportContract } from '../shared/export-contract-helpers.js';
+describe('server/domains/browser exports', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    it('exposes browser tool definitions and a matching manifest', async () => {
+        expect.hasAssertions();
+        await assertDomainExportContract({
+            expectedDomain: 'browser',
+            definitionExportNames: ['advancedBrowserToolDefinitions', 'browserTools'],
+            loadDefinitions: () => import('../../../../src/server/domains/browser/definitions.js'),
+            getToolArrays: (module) => [
+                module.browserTools,
+                module.advancedBrowserToolDefinitions,
+            ],
+            loadManifest: () => import('../../../../src/server/domains/browser/manifest.js'),
+        });
+    });
+});

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

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

package/dist/tests/server/domains/browser/facade-initializer.test.js

@@ -0,0 +1,174 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('@server/domains/shared/modules', () => ({
+    AICaptchaDetector: vi.fn(),
+    CamoufoxBrowserManager: vi.fn(),
+    CodeCollector: vi.fn(),
+    PageController: vi.fn(),
+    DOMInspector: vi.fn(),
+    ScriptManager: vi.fn(),
+    ConsoleMonitor: vi.fn(),
+}));
+vi.mock('@utils/DetailedDataManager', () => ({
+    DetailedDataManager: vi.fn(),
+}));
+vi.mock('@modules/browser/TabRegistry', () => ({
+    TabRegistry: vi.fn().mockImplementation(() => ({ _mock: 'tabRegistry' })),
+}));
+const handlers = vi.hoisted(() => ({
+    BrowserControlHandlers: vi.fn().mockImplementation((d) => ({ _type: 'browserControl', deps: d })),
+    CamoufoxBrowserHandlers: vi.fn().mockImplementation((d) => ({ _type: 'camoufox', deps: d })),
+    PageNavigationHandlers: vi.fn().mockImplementation((d) => ({ _type: 'pageNav', deps: d })),
+    PageInteractionHandlers: vi.fn().mockImplementation((d) => ({ _type: 'pageInteract', deps: d })),
+    PageEvaluationHandlers: vi.fn().mockImplementation((d) => ({ _type: 'pageEval', deps: d })),
+    PageDataHandlers: vi.fn().mockImplementation((d) => ({ _type: 'pageData', deps: d })),
+    DOMQueryHandlers: vi.fn().mockImplementation((d) => ({ _type: 'domQuery', deps: d })),
+    DOMStyleHandlers: vi.fn().mockImplementation((d) => ({ _type: 'domStyle', deps: d })),
+    DOMSearchHandlers: vi.fn().mockImplementation((d) => ({ _type: 'domSearch', deps: d })),
+    ConsoleHandlers: vi.fn().mockImplementation((d) => ({ _type: 'console', deps: d })),
+    ScriptManagementHandlers: vi.fn().mockImplementation((d) => ({ _type: 'scriptMgmt', deps: d })),
+    CaptchaHandlers: vi.fn().mockImplementation((d) => ({ _type: 'captcha', deps: d })),
+    StealthInjectionHandlers: vi.fn().mockImplementation((d) => ({ _type: 'stealth', deps: d })),
+    FrameworkStateHandlers: vi.fn().mockImplementation((d) => ({ _type: 'framework', deps: d })),
+    IndexedDBDumpHandlers: vi.fn().mockImplementation((d) => ({ _type: 'indexeddb', deps: d })),
+    JSHeapSearchHandlers: vi.fn().mockImplementation((d) => ({ _type: 'jsHeap', deps: d })),
+    TabWorkflowHandlers: vi.fn().mockImplementation((d) => ({ _type: 'tabWorkflow', deps: d })),
+    DetailedDataHandlers: vi.fn().mockImplementation((d) => ({ _type: 'detailedData', deps: d })),
+}));
+vi.mock('@server/domains/browser/handlers/browser-control', () => ({ BrowserControlHandlers: handlers.BrowserControlHandlers }));
+vi.mock('@server/domains/browser/handlers/camoufox-browser', () => ({ CamoufoxBrowserHandlers: handlers.CamoufoxBrowserHandlers }));
+vi.mock('@server/domains/browser/handlers/page-navigation', () => ({ PageNavigationHandlers: handlers.PageNavigationHandlers }));
+vi.mock('@server/domains/browser/handlers/page-interaction', () => ({ PageInteractionHandlers: handlers.PageInteractionHandlers }));
+vi.mock('@server/domains/browser/handlers/page-evaluation', () => ({ PageEvaluationHandlers: handlers.PageEvaluationHandlers }));
+vi.mock('@server/domains/browser/handlers/page-data', () => ({ PageDataHandlers: handlers.PageDataHandlers }));
+vi.mock('@server/domains/browser/handlers/dom-query', () => ({ DOMQueryHandlers: handlers.DOMQueryHandlers }));
+vi.mock('@server/domains/browser/handlers/dom-style', () => ({ DOMStyleHandlers: handlers.DOMStyleHandlers }));
+vi.mock('@server/domains/browser/handlers/dom-search', () => ({ DOMSearchHandlers: handlers.DOMSearchHandlers }));
+vi.mock('@server/domains/browser/handlers/console-handlers', () => ({ ConsoleHandlers: handlers.ConsoleHandlers }));
+vi.mock('@server/domains/browser/handlers/script-management', () => ({ ScriptManagementHandlers: handlers.ScriptManagementHandlers }));
+vi.mock('@server/domains/browser/handlers/captcha-handlers', () => ({ CaptchaHandlers: handlers.CaptchaHandlers }));
+vi.mock('@server/domains/browser/handlers/stealth-injection', () => ({ StealthInjectionHandlers: handlers.StealthInjectionHandlers }));
+vi.mock('@server/domains/browser/handlers/framework-state', () => ({ FrameworkStateHandlers: handlers.FrameworkStateHandlers }));
+vi.mock('@server/domains/browser/handlers/indexeddb-dump', () => ({ IndexedDBDumpHandlers: handlers.IndexedDBDumpHandlers }));
+vi.mock('@server/domains/browser/handlers/js-heap', () => ({ JSHeapSearchHandlers: handlers.JSHeapSearchHandlers }));
+vi.mock('@server/domains/browser/handlers/tab-workflow', () => ({ TabWorkflowHandlers: handlers.TabWorkflowHandlers }));
+vi.mock('@server/domains/browser/handlers/detailed-data', () => ({ DetailedDataHandlers: handlers.DetailedDataHandlers }));
+import { initializeBrowserHandlerModules } from '../../../../src/server/domains/browser/handlers/facade-initializer.js';
+describe('initializeBrowserHandlerModules', () => {
+    function makeDeps() {
+        return {
+            collector: { getActivePage: vi.fn() },
+            pageController: {},
+            domInspector: {},
+            scriptManager: {},
+            consoleMonitor: {},
+            captchaDetector: {},
+            detailedDataManager: {},
+            getActiveDriver: vi.fn().mockReturnValue('chrome'),
+            getCamoufoxPage: vi.fn(),
+            getCamoufoxManager: vi.fn().mockReturnValue(null),
+            setCamoufoxManager: vi.fn(),
+            closeCamoufox: vi.fn(),
+            getAutoDetectCaptcha: vi.fn().mockReturnValue(false),
+            getAutoSwitchHeadless: vi.fn().mockReturnValue(false),
+            getCaptchaTimeout: vi.fn().mockReturnValue(30000),
+            setAutoDetectCaptcha: vi.fn(),
+            setAutoSwitchHeadless: vi.fn(),
+            setCaptchaTimeout: vi.fn(),
+        };
+    }
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('returns all required handler modules', () => {
+        const deps = makeDeps();
+        const modules = initializeBrowserHandlerModules(deps);
+        expect(modules.tabRegistry).toBeDefined();
+        expect(modules.browserControl).toBeDefined();
+        expect(modules.camoufoxBrowser).toBeDefined();
+        expect(modules.pageNavigation).toBeDefined();
+        expect(modules.pageInteraction).toBeDefined();
+        expect(modules.pageEvaluation).toBeDefined();
+        expect(modules.pageData).toBeDefined();
+        expect(modules.domQuery).toBeDefined();
+        expect(modules.domStyle).toBeDefined();
+        expect(modules.domSearch).toBeDefined();
+        expect(modules.consoleHandlers).toBeDefined();
+        expect(modules.scriptManagement).toBeDefined();
+        expect(modules.captchaHandlers).toBeDefined();
+        expect(modules.stealthInjection).toBeDefined();
+        expect(modules.frameworkState).toBeDefined();
+        expect(modules.indexedDBDump).toBeDefined();
+        expect(modules.jsHeapSearch).toBeDefined();
+        expect(modules.tabWorkflow).toBeDefined();
+        expect(modules.detailedData).toBeDefined();
+    });
+    it('creates all 18 handler instances', () => {
+        const deps = makeDeps();
+        initializeBrowserHandlerModules(deps);
+        expect(handlers.BrowserControlHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.CamoufoxBrowserHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.PageNavigationHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.PageInteractionHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.PageEvaluationHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.PageDataHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.DOMQueryHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.DOMStyleHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.DOMSearchHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.ConsoleHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.ScriptManagementHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.CaptchaHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.StealthInjectionHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.FrameworkStateHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.IndexedDBDumpHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.JSHeapSearchHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.TabWorkflowHandlers).toHaveBeenCalledTimes(1);
+        expect(handlers.DetailedDataHandlers).toHaveBeenCalledTimes(1);
+    });
+    it('passes correct deps to BrowserControlHandlers', () => {
+        const deps = makeDeps();
+        initializeBrowserHandlerModules(deps);
+        const call = handlers.BrowserControlHandlers.mock.calls[0][0];
+        expect(call.collector).toBe(deps.collector);
+        expect(call.pageController).toBe(deps.pageController);
+        expect(call.consoleMonitor).toBe(deps.consoleMonitor);
+        expect(call.getActiveDriver).toBe(deps.getActiveDriver);
+    });
+    it('passes getCamoufoxManager deps to CamoufoxBrowserHandlers', () => {
+        const deps = makeDeps();
+        initializeBrowserHandlerModules(deps);
+        const call = handlers.CamoufoxBrowserHandlers.mock.calls[0][0];
+        expect(call.getCamoufoxManager).toBe(deps.getCamoufoxManager);
+        expect(call.setCamoufoxManager).toBe(deps.setCamoufoxManager);
+        expect(call.closeCamoufox).toBe(deps.closeCamoufox);
+    });
+    it('passes captcha settings to CaptchaHandlers', () => {
+        const deps = makeDeps();
+        deps.getAutoDetectCaptcha.mockReturnValue(true);
+        deps.getCaptchaTimeout.mockReturnValue(60000);
+        initializeBrowserHandlerModules(deps);
+        const call = handlers.CaptchaHandlers.mock.calls[0][0];
+        expect(call.autoDetectCaptcha).toBe(true);
+        expect(call.captchaTimeout).toBe(60000);
+        expect(call.setAutoDetectCaptcha).toBe(deps.setAutoDetectCaptcha);
+    });
+    it('passes domInspector to DOM handlers', () => {
+        const deps = makeDeps();
+        initializeBrowserHandlerModules(deps);
+        expect(handlers.DOMQueryHandlers.mock.calls[0][0].domInspector).toBe(deps.domInspector);
+        expect(handlers.DOMStyleHandlers.mock.calls[0][0].domInspector).toBe(deps.domInspector);
+        expect(handlers.DOMSearchHandlers.mock.calls[0][0].domInspector).toBe(deps.domInspector);
+    });
+    it('provides getActivePage to framework state handlers', () => {
+        const deps = makeDeps();
+        initializeBrowserHandlerModules(deps);
+        const call = handlers.FrameworkStateHandlers.mock.calls[0][0];
+        expect(call.getActivePage).toBeTypeOf('function');
+    });
+    it('shares tabRegistry between browserControl and tabWorkflow', () => {
+        const deps = makeDeps();
+        const modules = initializeBrowserHandlerModules(deps);
+        expect(modules.tabRegistry).toBeDefined();
+        const controlCall = handlers.BrowserControlHandlers.mock.calls[0][0];
+        expect(controlCall.getTabRegistry()).toBe(modules.tabRegistry);
+    });
+});

package/dist/tests/server/domains/browser/framework-state-additional.test.d.ts

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

package/dist/tests/server/domains/browser/framework-state-additional.test.js

@@ -0,0 +1,247 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { FrameworkStateHandlers } from '../../../../src/server/domains/browser/handlers/framework-state.js';
+function createMockPage() {
+    return {
+        evaluate: vi.fn(),
+    };
+}
+function createHandlers(page) {
+    return new FrameworkStateHandlers({
+        getActivePage: vi.fn(async () => page),
+    });
+}
+function getResponseText(response) {
+    const [content] = response.content;
+    expect(content).toBeDefined();
+    if (!content) {
+        throw new Error('Expected response content');
+    }
+    return content.text;
+}
+function parseJson(response) {
+    return JSON.parse(getResponseText(response));
+}
+describe('FrameworkStateHandlers – additional coverage', () => {
+    let page;
+    let handlers;
+    beforeEach(() => {
+        page = createMockPage();
+        handlers = createHandlers(page);
+    });
+    describe('handleFrameworkStateExtract – React detection', () => {
+        it('extracts React component state', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'react',
+                states: [
+                    { component: 'App', state: [{ count: 0 }] },
+                    { component: 'Counter', state: [{ value: 42 }] },
+                ],
+                found: true,
+            });
+            const result = await handlers.handleFrameworkStateExtract({
+                framework: 'react',
+            });
+            expect(result.content).toHaveLength(1);
+            const parsed = parseJson(result);
+            expect(parsed.detected).toBe('react');
+            expect(parsed.found).toBe(true);
+            expect(parsed.states).toHaveLength(2);
+        });
+        it('returns empty states when no React fiber found', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'react',
+                states: [],
+                found: false,
+            });
+            const result = await handlers.handleFrameworkStateExtract({
+                framework: 'react',
+            });
+            const parsed = parseJson(result);
+            expect(parsed.found).toBe(false);
+            expect(parsed.states).toHaveLength(0);
+        });
+    });
+    describe('handleFrameworkStateExtract – Vue 3 detection', () => {
+        it('extracts Vue 3 component state', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'vue3',
+                states: [
+                    { component: 'App', setupState: { msg: 'Hello' }, data: null },
+                ],
+                found: true,
+            });
+            const result = await handlers.handleFrameworkStateExtract({
+                framework: 'vue3',
+            });
+            const parsed = parseJson(result);
+            expect(parsed.detected).toBe('vue3');
+            expect(parsed.found).toBe(true);
+        });
+    });
+    describe('handleFrameworkStateExtract – Vue 2 detection', () => {
+        it('extracts Vue 2 component state', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'vue2',
+                states: [
+                    { component: 'MyComponent', data: { message: 'world' } },
+                ],
+                found: true,
+            });
+            const result = await handlers.handleFrameworkStateExtract({
+                framework: 'vue2',
+            });
+            const parsed = parseJson(result);
+            expect(parsed.detected).toBe('vue2');
+            expect(parsed.found).toBe(true);
+        });
+    });
+    describe('handleFrameworkStateExtract – auto detection', () => {
+        it('auto-detects React framework', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'react',
+                states: [{ component: 'Root', state: [true] }],
+                found: true,
+            });
+            const result = await handlers.handleFrameworkStateExtract({});
+            const parsed = parseJson(result);
+            expect(parsed.detected).toBe('react');
+        });
+        it('auto-detects Vue 3 framework', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'vue3',
+                states: [{ component: 'App', setupState: {} }],
+                found: true,
+            });
+            const result = await handlers.handleFrameworkStateExtract({
+                framework: 'auto',
+            });
+            const parsed = parseJson(result);
+            expect(parsed.detected).toBe('vue3');
+        });
+        it('auto-detects Vue 2 framework', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'vue2',
+                states: [{ component: 'OldApp', data: {} }],
+                found: true,
+            });
+            const result = await handlers.handleFrameworkStateExtract({
+                framework: 'auto',
+            });
+            const parsed = parseJson(result);
+            expect(parsed.detected).toBe('vue2');
+        });
+        it('returns no framework when none detected', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'auto',
+                states: [],
+                found: false,
+            });
+            const result = await handlers.handleFrameworkStateExtract({});
+            const parsed = parseJson(result);
+            expect(parsed.found).toBe(false);
+        });
+    });
+    describe('handleFrameworkStateExtract – with selector', () => {
+        it('uses custom selector', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'react',
+                states: [{ component: 'Widget', state: [{ open: true }] }],
+                found: true,
+            });
+            const result = await handlers.handleFrameworkStateExtract({
+                selector: '#my-widget',
+                framework: 'react',
+            });
+            const parsed = parseJson(result);
+            expect(parsed.found).toBe(true);
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), { framework: 'react', selector: '#my-widget', maxDepth: 5 });
+        });
+    });
+    describe('handleFrameworkStateExtract – with maxDepth', () => {
+        it('respects custom maxDepth', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'react',
+                states: [],
+                found: false,
+            });
+            await handlers.handleFrameworkStateExtract({
+                maxDepth: 10,
+                framework: 'react',
+            });
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), { framework: 'react', selector: '', maxDepth: 10 });
+        });
+    });
+    describe('handleFrameworkStateExtract – defaults', () => {
+        it('uses default values when no args provided', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'auto',
+                states: [],
+                found: false,
+            });
+            await handlers.handleFrameworkStateExtract({});
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), { framework: 'auto', selector: '', maxDepth: 5 });
+        });
+    });
+    describe('handleFrameworkStateExtract – error handling', () => {
+        it('returns error response when page.evaluate throws', async () => {
+            page.evaluate.mockRejectedValue(new Error('Page navigation interrupted'));
+            const result = await handlers.handleFrameworkStateExtract({
+                framework: 'react',
+            });
+            expect(result.content).toHaveLength(1);
+            const parsed = parseJson(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toBe('Page navigation interrupted');
+        });
+        it('handles non-Error thrown values', async () => {
+            page.evaluate.mockRejectedValue('string error');
+            const result = await handlers.handleFrameworkStateExtract({});
+            const parsed = parseJson(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toBe('string error');
+        });
+    });
+    describe('handleFrameworkStateExtract – complex states', () => {
+        it('handles nested component state tree', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'react',
+                states: [
+                    { component: 'App', state: [{ theme: 'dark', user: { name: 'Test' } }] },
+                    { component: 'Sidebar', state: [{ collapsed: false }] },
+                    { component: 'Header', state: [{ title: 'Dashboard' }] },
+                ],
+                found: true,
+            });
+            const result = await handlers.handleFrameworkStateExtract({
+                framework: 'react',
+                maxDepth: 3,
+            });
+            const parsed = parseJson(result);
+            expect(parsed.states).toHaveLength(3);
+            expect(parsed.states?.[0]).toMatchObject({
+                component: 'App',
+                state: [{ theme: 'dark' }],
+            });
+        });
+        it('handles Vue component with both setupState and data', async () => {
+            page.evaluate.mockResolvedValue({
+                detected: 'vue3',
+                states: [
+                    {
+                        component: 'Dashboard',
+                        setupState: { items: [1, 2, 3], loading: false },
+                        data: { legacyProp: 'old' },
+                    },
+                ],
+                found: true,
+            });
+            const result = await handlers.handleFrameworkStateExtract({
+                framework: 'vue3',
+            });
+            const parsed = parseJson(result);
+            expect(parsed.states?.[0]).toMatchObject({
+                setupState: { items: [1, 2, 3] },
+            });
+        });
+    });
+});

package/dist/tests/server/domains/browser/framework-state-coverage.test.d.ts

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