@jshookmcp/jshook 0.2.0 → 0.2.1

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

@@ -0,0 +1,415 @@
+import { describe, it, expect } from 'vitest';
+import { browserTools, advancedBrowserToolDefinitions } from '../../../../src/server/domains/browser/definitions.tools.js';
+import { browserRuntimeTools } from '../../../../src/server/domains/browser/definitions.tools.runtime.js';
+import { browserPageCoreTools } from '../../../../src/server/domains/browser/definitions.tools.page-core.js';
+import { browserPageSystemTools } from '../../../../src/server/domains/browser/definitions.tools.page-system.js';
+import { browserSecurityStateTools } from '../../../../src/server/domains/browser/definitions.tools.security.js';
+import { behaviorTools } from '../../../../src/server/domains/browser/definitions.tools.behavior.js';
+import { browserTools as definitionsReExport, advancedBrowserToolDefinitions as advancedReExport, } from '../../../../src/server/domains/browser/definitions.js';
+function getToolByName(tools, name) {
+    const tool = tools.find((candidate) => candidate.name === name);
+    expect(tool, `Expected tool "${name}" to exist`).toBeDefined();
+    return tool;
+}
+function getInputSchema(tool) {
+    const schema = tool.inputSchema;
+    expect(schema).toBeDefined();
+    expect(schema?.type).toBe('object');
+    expect(schema?.properties).toBeDefined();
+    return schema;
+}
+function getSchemaProperty(tool, propertyName) {
+    const schema = getInputSchema(tool);
+    expect(schema.properties).toHaveProperty(propertyName);
+    return schema.properties[propertyName];
+}
+describe('browser tool definitions', () => {
+    describe('browserTools (composite)', () => {
+        it('is a non-empty array', () => {
+            expect(Array.isArray(browserTools)).toBe(true);
+            expect(browserTools.length).toBeGreaterThan(0);
+        });
+        it('contains all sub-array tools merged together', () => {
+            const expected = browserRuntimeTools.length +
+                browserPageCoreTools.length +
+                browserPageSystemTools.length +
+                browserSecurityStateTools.length +
+                behaviorTools.length;
+            expect(browserTools).toHaveLength(expected);
+        });
+        it('has unique tool names', () => {
+            const names = browserTools.map((t) => t.name);
+            expect(new Set(names).size).toBe(names.length);
+        });
+        it.each(browserTools.map((tool) => [tool.name, tool]))('tool "%s" has required MCP structure', (_name, tool) => {
+            expect(tool).toEqual(expect.objectContaining({
+                name: expect.any(String),
+                description: expect.any(String),
+                inputSchema: expect.objectContaining({
+                    type: 'object',
+                    properties: expect.any(Object),
+                }),
+            }));
+        });
+        it('every tool has a non-empty description', () => {
+            for (const tool of browserTools) {
+                expect((tool.description ?? '').trim().length).toBeGreaterThan(0);
+            }
+        });
+        it('every tool inputSchema.type is "object"', () => {
+            for (const tool of browserTools) {
+                expect(getInputSchema(tool).type).toBe('object');
+            }
+        });
+    });
+    describe('advancedBrowserToolDefinitions', () => {
+        it('is a non-empty array', () => {
+            expect(Array.isArray(advancedBrowserToolDefinitions)).toBe(true);
+            expect(advancedBrowserToolDefinitions.length).toBeGreaterThan(0);
+        });
+        it.each(advancedBrowserToolDefinitions.map((tool) => [tool.name, tool]))('advanced tool "%s" has required MCP structure', (_name, tool) => {
+            expect(tool).toEqual(expect.objectContaining({
+                name: expect.any(String),
+                description: expect.any(String),
+                inputSchema: expect.objectContaining({
+                    type: 'object',
+                    properties: expect.any(Object),
+                }),
+            }));
+        });
+        it('has unique names', () => {
+            const names = advancedBrowserToolDefinitions.map((t) => t.name);
+            expect(new Set(names).size).toBe(names.length);
+        });
+        it('includes js_heap_search', () => {
+            expect(advancedBrowserToolDefinitions.find((t) => t.name === 'js_heap_search')).toBeDefined();
+        });
+        it('includes tab_workflow', () => {
+            expect(advancedBrowserToolDefinitions.find((t) => t.name === 'tab_workflow')).toBeDefined();
+        });
+    });
+    describe('cross-array uniqueness', () => {
+        it('no name collisions between browserTools and advancedBrowserToolDefinitions', () => {
+            const standardNames = new Set(browserTools.map((t) => t.name));
+            const advancedNames = advancedBrowserToolDefinitions.map((t) => t.name);
+            for (const name of advancedNames) {
+                expect(standardNames.has(name)).toBe(false);
+            }
+        });
+    });
+    describe('definitions.ts re-exports', () => {
+        it('re-exports browserTools from definitions.tools', () => {
+            expect(definitionsReExport).toBe(browserTools);
+        });
+        it('re-exports advancedBrowserToolDefinitions from definitions.tools', () => {
+            expect(advancedReExport).toBe(advancedBrowserToolDefinitions);
+        });
+    });
+    describe('browserRuntimeTools', () => {
+        const expectedNames = [
+            'get_detailed_data',
+            'browser_launch',
+            'camoufox_server_launch',
+            'camoufox_server_close',
+            'camoufox_server_status',
+            'browser_attach',
+            'browser_close',
+            'browser_status',
+        ];
+        it.each(expectedNames)('includes tool "%s"', (name) => {
+            expect(browserRuntimeTools.find((t) => t.name === name)).toBeDefined();
+        });
+        it('get_detailed_data requires detailId', () => {
+            const tool = getToolByName(browserRuntimeTools, 'get_detailed_data');
+            const schema = getInputSchema(tool);
+            expect(schema.required).toContain('detailId');
+            expect(schema.properties).toHaveProperty('path');
+        });
+        it('browser_launch has driver enum with chrome and camoufox', () => {
+            const tool = getToolByName(browserRuntimeTools, 'browser_launch');
+            const driverProp = getSchemaProperty(tool, 'driver');
+            expect(driverProp.enum).toEqual(['chrome', 'camoufox']);
+        });
+        it('browser_attach has browserURL and wsEndpoint properties', () => {
+            const tool = getToolByName(browserRuntimeTools, 'browser_attach');
+            const schema = getInputSchema(tool);
+            expect(schema.properties).toHaveProperty('browserURL');
+            expect(schema.properties).toHaveProperty('wsEndpoint');
+            expect(schema.properties).toHaveProperty('pageIndex');
+        });
+        it('browser_close and browser_status have no required properties', () => {
+            const closeTool = getToolByName(browserRuntimeTools, 'browser_close');
+            const statusTool = getToolByName(browserRuntimeTools, 'browser_status');
+            expect(getInputSchema(closeTool).required).toBeUndefined();
+            expect(getInputSchema(statusTool).required).toBeUndefined();
+        });
+    });
+    describe('browserPageCoreTools', () => {
+        it('page_navigate requires url', () => {
+            const tool = getToolByName(browserPageCoreTools, 'page_navigate');
+            expect(getInputSchema(tool).required).toContain('url');
+        });
+        it('page_navigate has waitUntil enum', () => {
+            const tool = getToolByName(browserPageCoreTools, 'page_navigate');
+            const prop = getSchemaProperty(tool, 'waitUntil');
+            expect(prop.enum).toEqual(['load', 'domcontentloaded', 'networkidle', 'commit']);
+        });
+        it('page_navigate has enableNetworkMonitoring boolean', () => {
+            const tool = getToolByName(browserPageCoreTools, 'page_navigate');
+            const prop = getSchemaProperty(tool, 'enableNetworkMonitoring');
+            expect(prop.type).toBe('boolean');
+            expect(prop.default).toBe(false);
+        });
+        const noArgPageTools = ['page_reload', 'page_back', 'page_forward'];
+        it.each(noArgPageTools)('%s has no required properties', (name) => {
+            const tool = getToolByName(browserPageCoreTools, name);
+            expect(getInputSchema(tool).required).toBeUndefined();
+        });
+        it('dom_query_selector requires selector', () => {
+            const tool = getToolByName(browserPageCoreTools, 'dom_query_selector');
+            expect(getInputSchema(tool).required).toContain('selector');
+        });
+        it('dom_query_all requires selector', () => {
+            const tool = getToolByName(browserPageCoreTools, 'dom_query_all');
+            expect(getInputSchema(tool).required).toContain('selector');
+        });
+        it('page_click requires selector', () => {
+            const tool = getToolByName(browserPageCoreTools, 'page_click');
+            expect(getInputSchema(tool).required).toContain('selector');
+            const buttonProp = getSchemaProperty(tool, 'button');
+            expect(buttonProp.enum).toEqual(['left', 'right', 'middle']);
+        });
+        it('page_type requires selector and text', () => {
+            const tool = getToolByName(browserPageCoreTools, 'page_type');
+            const schema = getInputSchema(tool);
+            expect(schema.required).toContain('selector');
+            expect(schema.required).toContain('text');
+        });
+        it('page_select requires selector and values', () => {
+            const tool = getToolByName(browserPageCoreTools, 'page_select');
+            const schema = getInputSchema(tool);
+            expect(schema.required).toContain('selector');
+            expect(schema.required).toContain('values');
+        });
+        it('page_evaluate requires code', () => {
+            const tool = getToolByName(browserPageCoreTools, 'page_evaluate');
+            expect(getInputSchema(tool).required).toContain('code');
+        });
+        it('page_wait_for_selector requires selector', () => {
+            const tool = getToolByName(browserPageCoreTools, 'page_wait_for_selector');
+            expect(getInputSchema(tool).required).toContain('selector');
+        });
+    });
+    describe('browserPageSystemTools', () => {
+        it('console_execute requires expression', () => {
+            const tool = getToolByName(browserPageSystemTools, 'console_execute');
+            expect(getInputSchema(tool).required).toContain('expression');
+        });
+        it('console_get_logs has optional type enum', () => {
+            const tool = getToolByName(browserPageSystemTools, 'console_get_logs');
+            const typeProp = getSchemaProperty(tool, 'type');
+            expect(typeProp.enum).toEqual(['log', 'warn', 'error', 'info', 'debug']);
+        });
+        it('page_set_viewport requires width and height', () => {
+            const tool = getToolByName(browserPageSystemTools, 'page_set_viewport');
+            const schema = getInputSchema(tool);
+            expect(schema.required).toContain('width');
+            expect(schema.required).toContain('height');
+        });
+        it('page_emulate_device requires device', () => {
+            const tool = getToolByName(browserPageSystemTools, 'page_emulate_device');
+            expect(getInputSchema(tool).required).toContain('device');
+        });
+        it('page_set_cookies requires cookies', () => {
+            const tool = getToolByName(browserPageSystemTools, 'page_set_cookies');
+            expect(getInputSchema(tool).required).toContain('cookies');
+        });
+        it('page_set_local_storage requires key and value', () => {
+            const tool = getToolByName(browserPageSystemTools, 'page_set_local_storage');
+            const schema = getInputSchema(tool);
+            expect(schema.required).toContain('key');
+            expect(schema.required).toContain('value');
+        });
+        it('page_press_key requires key', () => {
+            const tool = getToolByName(browserPageSystemTools, 'page_press_key');
+            expect(getInputSchema(tool).required).toContain('key');
+        });
+        it('dom_get_computed_style requires selector', () => {
+            const tool = getToolByName(browserPageSystemTools, 'dom_get_computed_style');
+            expect(getInputSchema(tool).required).toContain('selector');
+        });
+        it('dom_find_by_text requires text', () => {
+            const tool = getToolByName(browserPageSystemTools, 'dom_find_by_text');
+            expect(getInputSchema(tool).required).toContain('text');
+        });
+        it('dom_get_xpath requires selector', () => {
+            const tool = getToolByName(browserPageSystemTools, 'dom_get_xpath');
+            expect(getInputSchema(tool).required).toContain('selector');
+        });
+        it('dom_is_in_viewport requires selector', () => {
+            const tool = getToolByName(browserPageSystemTools, 'dom_is_in_viewport');
+            expect(getInputSchema(tool).required).toContain('selector');
+        });
+        it('page_inject_script requires script', () => {
+            const tool = getToolByName(browserPageSystemTools, 'page_inject_script');
+            expect(getInputSchema(tool).required).toContain('script');
+        });
+        const noArgSystemTools = [
+            'console_enable',
+            'page_get_performance',
+            'page_get_cookies',
+            'page_clear_cookies',
+            'page_get_local_storage',
+            'page_get_all_links',
+        ];
+        it.each(noArgSystemTools)('%s has no required properties', (name) => {
+            const tool = getToolByName(browserPageSystemTools, name);
+            expect(getInputSchema(tool).required).toBeUndefined();
+        });
+    });
+    describe('browserSecurityStateTools', () => {
+        it('captcha_detect has no required properties', () => {
+            const tool = getToolByName(browserSecurityStateTools, 'captcha_detect');
+            expect(getInputSchema(tool).required).toBeUndefined();
+        });
+        it('stealth_inject has no required properties', () => {
+            const tool = getToolByName(browserSecurityStateTools, 'stealth_inject');
+            expect(getInputSchema(tool).required).toBeUndefined();
+        });
+        it('stealth_set_user_agent has platform enum', () => {
+            const tool = getToolByName(browserSecurityStateTools, 'stealth_set_user_agent');
+            const prop = getSchemaProperty(tool, 'platform');
+            expect(prop.enum).toEqual(['windows', 'mac', 'linux']);
+        });
+        it('browser_select_tab has index, urlPattern, and titlePattern', () => {
+            const tool = getToolByName(browserSecurityStateTools, 'browser_select_tab');
+            const schema = getInputSchema(tool);
+            expect(schema.properties).toHaveProperty('index');
+            expect(schema.properties).toHaveProperty('urlPattern');
+            expect(schema.properties).toHaveProperty('titlePattern');
+        });
+        it('framework_state_extract has framework enum', () => {
+            const tool = getToolByName(browserSecurityStateTools, 'framework_state_extract');
+            const prop = getSchemaProperty(tool, 'framework');
+            expect(prop.enum).toEqual(['auto', 'react', 'vue2', 'vue3']);
+        });
+        it('indexeddb_dump has optional database, store, and maxRecords', () => {
+            const tool = getToolByName(browserSecurityStateTools, 'indexeddb_dump');
+            const schema = getInputSchema(tool);
+            expect(schema.properties).toHaveProperty('database');
+            expect(schema.properties).toHaveProperty('store');
+            expect(schema.properties).toHaveProperty('maxRecords');
+            expect(schema.required).toBeUndefined();
+        });
+    });
+    describe('behaviorTools', () => {
+        it('has exactly 5 behavior tools', () => {
+            expect(behaviorTools).toHaveLength(5);
+        });
+        const expectedBehaviorNames = [
+            'human_mouse',
+            'human_scroll',
+            'human_typing',
+            'captcha_vision_solve',
+            'widget_challenge_solve',
+        ];
+        it.each(expectedBehaviorNames)('includes "%s"', (name) => {
+            expect(behaviorTools.find((t) => t.name === name)).toBeDefined();
+        });
+        it('human_typing requires selector and text', () => {
+            const tool = getToolByName(behaviorTools, 'human_typing');
+            const schema = getInputSchema(tool);
+            expect(schema.required).toContain('selector');
+            expect(schema.required).toContain('text');
+        });
+        it('human_mouse has no required properties', () => {
+            const tool = getToolByName(behaviorTools, 'human_mouse');
+            expect(getInputSchema(tool).required).toBeUndefined();
+        });
+        it('human_scroll has no required properties', () => {
+            const tool = getToolByName(behaviorTools, 'human_scroll');
+            expect(getInputSchema(tool).required).toBeUndefined();
+        });
+        it('captcha_vision_solve has mode enum', () => {
+            const tool = getToolByName(behaviorTools, 'captcha_vision_solve');
+            const modeProp = getSchemaProperty(tool, 'mode');
+            expect(modeProp.enum).toEqual(['external_service', 'manual']);
+        });
+        it('captcha_vision_solve has challengeType enum', () => {
+            const tool = getToolByName(behaviorTools, 'captcha_vision_solve');
+            const prop = getSchemaProperty(tool, 'challengeType');
+            expect(prop.enum).toEqual(['image', 'widget', 'browser_check', 'auto']);
+            expect(prop.default).toBe('auto');
+        });
+        it('widget_challenge_solve has mode enum with three options', () => {
+            const tool = getToolByName(behaviorTools, 'widget_challenge_solve');
+            const modeProp = getSchemaProperty(tool, 'mode');
+            expect(modeProp.enum).toEqual(['external_service', 'hook', 'manual']);
+        });
+        it('widget_challenge_solve has injectToken boolean with default true', () => {
+            const tool = getToolByName(behaviorTools, 'widget_challenge_solve');
+            const prop = getSchemaProperty(tool, 'injectToken');
+            expect(prop.type).toBe('boolean');
+            expect(prop.default).toBe(true);
+        });
+    });
+    describe('advanced tool inputSchema', () => {
+        it('js_heap_search requires pattern', () => {
+            const tool = getToolByName(advancedBrowserToolDefinitions, 'js_heap_search');
+            const schema = getInputSchema(tool);
+            expect(schema.required).toContain('pattern');
+            expect(schema.properties).toHaveProperty('maxResults');
+            expect(schema.properties).toHaveProperty('caseSensitive');
+        });
+        it('tab_workflow requires action', () => {
+            const tool = getToolByName(advancedBrowserToolDefinitions, 'tab_workflow');
+            expect(getInputSchema(tool).required).toContain('action');
+        });
+        it('tab_workflow action has correct enum', () => {
+            const tool = getToolByName(advancedBrowserToolDefinitions, 'tab_workflow');
+            const actionProp = getSchemaProperty(tool, 'action');
+            expect(actionProp.enum).toEqual([
+                'list',
+                'alias_bind',
+                'alias_open',
+                'navigate',
+                'wait_for',
+                'context_set',
+                'context_get',
+                'transfer',
+            ]);
+        });
+        it('js_heap_search maxResults has default 50', () => {
+            const tool = getToolByName(advancedBrowserToolDefinitions, 'js_heap_search');
+            const prop = getSchemaProperty(tool, 'maxResults');
+            expect(prop.default).toBe(50);
+        });
+        it('js_heap_search caseSensitive has default false', () => {
+            const tool = getToolByName(advancedBrowserToolDefinitions, 'js_heap_search');
+            const prop = getSchemaProperty(tool, 'caseSensitive');
+            expect(prop.default).toBe(false);
+        });
+    });
+    describe('required fields completeness', () => {
+        const allTools = [...browserTools, ...advancedBrowserToolDefinitions];
+        it('every required field exists in properties', () => {
+            for (const tool of allTools) {
+                const schema = getInputSchema(tool);
+                if (schema.required) {
+                    for (const reqField of schema.required) {
+                        expect(schema.properties, `Tool "${tool.name}" requires "${reqField}" but it is missing from properties`).toHaveProperty(reqField);
+                    }
+                }
+            }
+        });
+        it('tools with required field declare a non-empty array', () => {
+            for (const tool of allTools) {
+                const schema = getInputSchema(tool);
+                if (schema.required) {
+                    expect(Array.isArray(schema.required)).toBe(true);
+                    expect(schema.required.length).toBeGreaterThan(0);
+                }
+            }
+        });
+    });
+});

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

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

package/dist/tests/server/domains/browser/detailed-data.test.js

@@ -0,0 +1,49 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { DetailedDataHandlers } from '../../../../src/server/domains/browser/handlers/detailed-data.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('DetailedDataHandlers', () => {
+    const detailedDataManager = {
+        retrieve: vi.fn(),
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new DetailedDataHandlers({ detailedDataManager });
+    });
+    it('returns detailed data and defaults path to full', async () => {
+        detailedDataManager.retrieve.mockReturnValue({
+            nested: { value: 42 },
+        });
+        const body = parseJson(await handlers.handleGetDetailedData({ detailId: 'detail-1' }));
+        expect(detailedDataManager.retrieve).toHaveBeenCalledWith('detail-1', undefined);
+        expect(body).toEqual({
+            success: true,
+            detailId: 'detail-1',
+            path: 'full',
+            data: {
+                nested: { value: 42 },
+            },
+        });
+    });
+    it('passes through the requested path', async () => {
+        detailedDataManager.retrieve.mockReturnValue(['line 1', 'line 2']);
+        const body = parseJson(await handlers.handleGetDetailedData({
+            detailId: 'detail-2',
+            path: 'scripts[0].source',
+        }));
+        expect(detailedDataManager.retrieve).toHaveBeenCalledWith('detail-2', 'scripts[0].source');
+        expect(body.path).toBe('scripts[0].source');
+        expect(body.data).toEqual(['line 1', 'line 2']);
+    });
+    it('returns an error payload when retrieval fails', async () => {
+        detailedDataManager.retrieve.mockImplementation(() => {
+            throw new Error('detail expired');
+        });
+        const body = parseJson(await handlers.handleGetDetailedData({ detailId: 'expired-detail' }));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('detail expired');
+        expect(body.hint).toContain('TTL: 10 minutes');
+    });
+});

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

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

package/dist/tests/server/domains/browser/dom-query.test.js

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { DOMQueryHandlers } from '../../../../src/server/domains/browser/handlers/dom-query.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('DOMQueryHandlers', () => {
+    let domInspector;
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        domInspector = {
+            querySelector: vi.fn(),
+            querySelectorAll: vi.fn(),
+            getStructure: vi.fn(),
+            findClickable: vi.fn(),
+        };
+        handlers = new DOMQueryHandlers({ domInspector });
+    });
+    it('defaults getAttributes to true for selector queries', async () => {
+        domInspector.querySelector.mockResolvedValue({
+            selector: '#submit',
+            tagName: 'button',
+        });
+        const body = parseJson(await handlers.handleDOMQuerySelector({ selector: '#submit' }));
+        expect(domInspector.querySelector).toHaveBeenCalledWith('#submit', true);
+        expect(body).toEqual({
+            selector: '#submit',
+            tagName: 'button',
+        });
+    });
+    it('passes explicit getAttributes=false for selector queries', async () => {
+        domInspector.querySelector.mockResolvedValue({
+            selector: '#submit',
+            attributes: {},
+        });
+        await handlers.handleDOMQuerySelector({
+            selector: '#submit',
+            getAttributes: false,
+        });
+        expect(domInspector.querySelector).toHaveBeenCalledWith('#submit', false);
+    });
+    it('defaults query all limit to 100 and returns diagnostics', async () => {
+        domInspector.querySelectorAll.mockResolvedValue({
+            elements: [{ selector: '.card' }, { selector: '.card:nth-child(2)' }],
+            diagnostics: { truncated: false },
+        });
+        const body = parseJson(await handlers.handleDOMQueryAll({ selector: '.card' }));
+        expect(domInspector.querySelectorAll).toHaveBeenCalledWith('.card', 100);
+        expect(body).toEqual({
+            count: 2,
+            elements: [{ selector: '.card' }, { selector: '.card:nth-child(2)' }],
+            diagnostics: { truncated: false },
+        });
+    });
+    it('defaults DOM structure args to depth 3 with text included', async () => {
+        domInspector.getStructure.mockResolvedValue({
+            tagName: 'body',
+            children: [{ tagName: 'main' }],
+        });
+        const body = parseJson(await handlers.handleDOMGetStructure({}));
+        expect(domInspector.getStructure).toHaveBeenCalledWith(3, true);
+        expect(body.children).toHaveLength(1);
+    });
+    it('finds clickable elements and forwards optional filter text', async () => {
+        domInspector.findClickable.mockResolvedValue({
+            elements: [{ text: 'Save', selector: 'button.primary' }],
+            diagnostics: { scanned: 4 },
+        });
+        const body = parseJson(await handlers.handleDOMFindClickable({ filterText: 'Save' }));
+        expect(domInspector.findClickable).toHaveBeenCalledWith('Save');
+        expect(body).toEqual({
+            count: 1,
+            elements: [{ text: 'Save', selector: 'button.primary' }],
+            diagnostics: { scanned: 4 },
+        });
+    });
+    it('rethrows inspector errors from selector queries', async () => {
+        domInspector.querySelector.mockRejectedValue(new Error('query failed'));
+        await expect(handlers.handleDOMQuerySelector({ selector: '#missing' })).rejects.toThrow('query failed');
+    });
+});

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

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

package/dist/tests/server/domains/browser/dom-search.test.js

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { DOMSearchHandlers } from '../../../../src/server/domains/browser/handlers/dom-search.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('DOMSearchHandlers', () => {
+    let domInspector;
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        domInspector = {
+            findByText: vi.fn(),
+            getXPath: vi.fn(),
+        };
+        handlers = new DOMSearchHandlers({ domInspector });
+    });
+    it('finds elements by text and forwards an omitted tag as undefined', async () => {
+        domInspector.findByText.mockResolvedValue([
+            { selector: 'button.primary', text: 'Continue' },
+            { selector: 'a.cta', text: 'Continue' },
+        ]);
+        const body = parseJson(await handlers.handleDOMFindByText({ text: 'Continue' }));
+        expect(domInspector.findByText).toHaveBeenCalledWith('Continue', undefined);
+        expect(body).toEqual({
+            count: 2,
+            elements: [
+                { selector: 'button.primary', text: 'Continue' },
+                { selector: 'a.cta', text: 'Continue' },
+            ],
+        });
+    });
+    it('finds elements by text with an explicit tag filter', async () => {
+        domInspector.findByText.mockResolvedValue([{ selector: 'button.primary', text: 'Save' }]);
+        const body = parseJson(await handlers.handleDOMFindByText({ text: 'Save', tag: 'button' }));
+        expect(domInspector.findByText).toHaveBeenCalledWith('Save', 'button');
+        expect(body.count).toBe(1);
+    });
+    it('returns selector and xpath for DOM xpath lookup', async () => {
+        domInspector.getXPath.mockResolvedValue('//*[@id="submit"]');
+        const body = parseJson(await handlers.handleDOMGetXPath({ selector: '#submit' }));
+        expect(domInspector.getXPath).toHaveBeenCalledWith('#submit');
+        expect(body).toEqual({
+            selector: '#submit',
+            xpath: '//*[@id="submit"]',
+        });
+    });
+    it('rethrows inspector errors from xpath lookup', async () => {
+        domInspector.getXPath.mockRejectedValue(new Error('xpath failed'));
+        await expect(handlers.handleDOMGetXPath({ selector: '#bad' })).rejects.toThrow('xpath failed');
+    });
+});

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

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

package/dist/tests/server/domains/browser/dom-style.test.js

@@ -0,0 +1,45 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { DOMStyleHandlers } from '../../../../src/server/domains/browser/handlers/dom-style.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('DOMStyleHandlers', () => {
+    let domInspector;
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        domInspector = {
+            getComputedStyle: vi.fn(),
+            isInViewport: vi.fn(),
+        };
+        handlers = new DOMStyleHandlers({ domInspector });
+    });
+    it('returns computed styles for a selector', async () => {
+        domInspector.getComputedStyle.mockResolvedValue({
+            display: 'block',
+            color: 'rgb(0, 0, 0)',
+        });
+        const body = parseJson(await handlers.handleDOMGetComputedStyle({ selector: '#hero' }));
+        expect(domInspector.getComputedStyle).toHaveBeenCalledWith('#hero');
+        expect(body).toEqual({
+            selector: '#hero',
+            styles: {
+                display: 'block',
+                color: 'rgb(0, 0, 0)',
+            },
+        });
+    });
+    it('returns viewport state for a selector', async () => {
+        domInspector.isInViewport.mockResolvedValue(true);
+        const body = parseJson(await handlers.handleDOMIsInViewport({ selector: '#cta' }));
+        expect(domInspector.isInViewport).toHaveBeenCalledWith('#cta');
+        expect(body).toEqual({
+            selector: '#cta',
+            inViewport: true,
+        });
+    });
+    it('rethrows inspector errors from computed style lookup', async () => {
+        domInspector.getComputedStyle.mockRejectedValue(new Error('style failed'));
+        await expect(handlers.handleDOMGetComputedStyle({ selector: '#missing-style' })).rejects.toThrow('style failed');
+    });
+});

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

@@ -0,0 +1 @@
+import '../shared/manifest-test-mocks.js';