@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/domains/browser/indexeddb-dump-coverage.test.js

@@ -0,0 +1,327 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { IndexedDBDumpHandlers } from '../../../../src/server/domains/browser/handlers/indexeddb-dump.js';
+function getTextContent(response) {
+    const first = response.content[0];
+    expect(first).toBeDefined();
+    expect(first?.type).toBe('text');
+    if (!first || first.type !== 'text') {
+        throw new Error('Expected text tool response');
+    }
+    return first.text;
+}
+function parseJson(response) {
+    return JSON.parse(getTextContent(response));
+}
+describe('IndexedDBDumpHandlers — coverage expansion', () => {
+    let page;
+    let getActivePage;
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        page = {
+            evaluate: vi.fn(),
+        };
+        getActivePage = vi.fn(async () => page);
+        handlers = new IndexedDBDumpHandlers({ getActivePage });
+    });
+    describe('default arguments', () => {
+        it('passes empty database, empty store, and maxRecords 100 by default', async () => {
+            page.evaluate.mockResolvedValueOnce({});
+            await handlers.handleIndexedDBDump({});
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+                database: '',
+                store: '',
+                maxRecords: 100,
+            });
+        });
+    });
+    describe('explicit arguments', () => {
+        it('passes explicit database filter', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                myDb: { users: [{ id: 1 }] },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({ database: 'myDb' }));
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+                database: 'myDb',
+                store: '',
+                maxRecords: 100,
+            });
+            expect(body.myDb.users).toEqual([{ id: 1 }]);
+        });
+        it('passes explicit store filter', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                myDb: { targetStore: [{ key: 'val' }] },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({ store: 'targetStore' }));
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+                database: '',
+                store: 'targetStore',
+                maxRecords: 100,
+            });
+            expect(body.myDb.targetStore).toEqual([{ key: 'val' }]);
+        });
+        it('passes explicit maxRecords', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                db: { store: [{ a: 1 }, { a: 2 }] },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({ maxRecords: 2 }));
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+                database: '',
+                store: '',
+                maxRecords: 2,
+            });
+            expect(body.db.store).toHaveLength(2);
+        });
+        it('passes all three arguments together', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                specificDb: { specificStore: [{ x: 1 }] },
+            });
+            await handlers.handleIndexedDBDump({
+                database: 'specificDb',
+                store: 'specificStore',
+                maxRecords: 50,
+            });
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+                database: 'specificDb',
+                store: 'specificStore',
+                maxRecords: 50,
+            });
+        });
+    });
+    describe('multiple databases', () => {
+        it('returns data from multiple databases', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                db1: { users: [{ id: 1 }], settings: [{ key: 'theme', value: 'dark' }] },
+                db2: { logs: [{ msg: 'hello' }] },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(Object.keys(body)).toEqual(['db1', 'db2']);
+            expect(body.db1.users).toHaveLength(1);
+            expect(body.db1.settings).toHaveLength(1);
+            expect(body.db2.logs).toHaveLength(1);
+        });
+    });
+    describe('empty results', () => {
+        it('returns empty object when no databases exist', async () => {
+            page.evaluate.mockResolvedValueOnce({});
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body).toEqual({});
+        });
+        it('returns database with empty stores', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                emptyDb: {},
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.emptyDb).toEqual({});
+        });
+        it('returns stores with empty arrays', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                db: { emptyStore: [] },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.db.emptyStore).toEqual([]);
+        });
+    });
+    describe('error handling', () => {
+        it('returns error payload when page.evaluate rejects with Error', async () => {
+            page.evaluate.mockRejectedValueOnce(new Error('IndexedDB not available'));
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.success).toBe(false);
+            expect(body.error).toBe('IndexedDB not available');
+        });
+        it('returns error payload when page.evaluate rejects with string', async () => {
+            page.evaluate.mockRejectedValueOnce('string error');
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.success).toBe(false);
+            expect(body.error).toBe('string error');
+        });
+        it('returns error payload when page.evaluate rejects with number', async () => {
+            page.evaluate.mockRejectedValueOnce(42);
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.success).toBe(false);
+            expect(body.error).toBe('42');
+        });
+        it('returns error payload when page.evaluate rejects with null', async () => {
+            page.evaluate.mockRejectedValueOnce(null);
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.success).toBe(false);
+            expect(body.error).toBe('null');
+        });
+        it('returns error when getActivePage rejects', async () => {
+            getActivePage.mockRejectedValueOnce(new Error('no browser'));
+            handlers = new IndexedDBDumpHandlers({ getActivePage });
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.success).toBe(false);
+            expect(body.error).toBe('no browser');
+        });
+        it('returns error when getActivePage rejects with non-Error', async () => {
+            getActivePage.mockRejectedValueOnce('connection lost');
+            handlers = new IndexedDBDumpHandlers({ getActivePage });
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.success).toBe(false);
+            expect(body.error).toBe('connection lost');
+        });
+    });
+    describe('database-level error simulation', () => {
+        it('returns __error__ for databases that fail to open', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                failedDb: { __error__: ['failed to open'] },
+                goodDb: { store1: [{ a: 1 }] },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.failedDb.__error__).toEqual(['failed to open']);
+            expect(body.goodDb.store1).toEqual([{ a: 1 }]);
+        });
+        it('returns error string for stores that fail to read', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                db: {
+                    goodStore: [{ key: 'val' }],
+                    badStore: ['__error reading store__'],
+                },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.db.goodStore).toEqual([{ key: 'val' }]);
+            expect(body.db.badStore).toEqual(['__error reading store__']);
+        });
+    });
+    describe('complex data types', () => {
+        it('handles nested objects in store records', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                appDb: {
+                    config: [{
+                            id: 1,
+                            settings: {
+                                theme: { primary: '#000', secondary: '#fff' },
+                                layout: { sidebar: true, compact: false },
+                            },
+                        }],
+                },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.appDb.config[0].settings.theme.primary).toBe('#000');
+            expect(body.appDb.config[0].settings.layout.sidebar).toBe(true);
+        });
+        it('handles arrays of various types in records', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                testDb: {
+                    mixed: [{
+                            strings: ['a', 'b'],
+                            numbers: [1, 2, 3],
+                            booleans: [true, false],
+                            nested: [{ x: 1 }, { y: 2 }],
+                        }],
+                },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.testDb.mixed[0].strings).toEqual(['a', 'b']);
+            expect(body.testDb.mixed[0].numbers).toEqual([1, 2, 3]);
+            expect(body.testDb.mixed[0].nested).toEqual([{ x: 1 }, { y: 2 }]);
+        });
+        it('handles large number of records', async () => {
+            const records = Array.from({ length: 100 }, (_, i) => ({ id: i, value: `item-${i}` }));
+            page.evaluate.mockResolvedValueOnce({
+                largeDb: { bigStore: records },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(body.largeDb.bigStore).toHaveLength(100);
+            expect(body.largeDb.bigStore[99].id).toBe(99);
+        });
+    });
+    describe('response structure', () => {
+        it('wraps result in content array with type text', async () => {
+            page.evaluate.mockResolvedValueOnce({});
+            const response = await handlers.handleIndexedDBDump({});
+            const first = response.content[0];
+            expect(response.content).toHaveLength(1);
+            expect(first).toBeDefined();
+            expect(first?.type).toBe('text');
+            expect(() => JSON.parse(getTextContent(response))).not.toThrow();
+        });
+        it('wraps error in content array with type text', async () => {
+            page.evaluate.mockRejectedValueOnce(new Error('fail'));
+            const response = await handlers.handleIndexedDBDump({});
+            const first = response.content[0];
+            expect(response.content).toHaveLength(1);
+            expect(first).toBeDefined();
+            expect(first?.type).toBe('text');
+        });
+        it('success result JSON is indented with 2 spaces', async () => {
+            page.evaluate.mockResolvedValueOnce({ db: { store: [1] } });
+            const response = await handlers.handleIndexedDBDump({});
+            const text = getTextContent(response);
+            expect(text).toContain('\n  ');
+        });
+        it('error result JSON is indented with 2 spaces', async () => {
+            page.evaluate.mockRejectedValueOnce(new Error('err'));
+            const response = await handlers.handleIndexedDBDump({});
+            const text = getTextContent(response);
+            expect(text).toContain('\n  ');
+        });
+    });
+    describe('partial arguments', () => {
+        it('uses empty string for database when only store is provided', async () => {
+            page.evaluate.mockResolvedValueOnce({});
+            await handlers.handleIndexedDBDump({ store: 'myStore' });
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+                database: '',
+                store: 'myStore',
+                maxRecords: 100,
+            });
+        });
+        it('uses empty string for store when only database is provided', async () => {
+            page.evaluate.mockResolvedValueOnce({});
+            await handlers.handleIndexedDBDump({ database: 'myDb' });
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+                database: 'myDb',
+                store: '',
+                maxRecords: 100,
+            });
+        });
+        it('uses default maxRecords when only database and store are provided', async () => {
+            page.evaluate.mockResolvedValueOnce({});
+            await handlers.handleIndexedDBDump({ database: 'db', store: 'store' });
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+                database: 'db',
+                store: 'store',
+                maxRecords: 100,
+            });
+        });
+        it('uses maxRecords of 1 to get single record', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                db: { store: [{ only: 'one' }] },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({ maxRecords: 1 }));
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+                database: '',
+                store: '',
+                maxRecords: 1,
+            });
+            expect(body.db.store).toEqual([{ only: 'one' }]);
+        });
+        it('uses large maxRecords value', async () => {
+            page.evaluate.mockResolvedValueOnce({});
+            await handlers.handleIndexedDBDump({ maxRecords: 10000 });
+            expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+                database: '',
+                store: '',
+                maxRecords: 10000,
+            });
+        });
+    });
+    describe('multiple stores per database', () => {
+        it('returns data from all stores within a database', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                appDb: {
+                    users: [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }],
+                    sessions: [{ sid: 'abc', active: true }],
+                    settings: [{ key: 'lang', value: 'en' }],
+                },
+            });
+            const body = parseJson(await handlers.handleIndexedDBDump({}));
+            expect(Object.keys(body.appDb)).toEqual(['users', 'sessions', 'settings']);
+            expect(body.appDb.users).toHaveLength(2);
+            expect(body.appDb.sessions).toHaveLength(1);
+            expect(body.appDb.settings).toHaveLength(1);
+        });
+    });
+});

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

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

package/dist/tests/server/domains/browser/indexeddb-dump.test.js

@@ -0,0 +1,63 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { IndexedDBDumpHandlers } from '../../../../src/server/domains/browser/handlers/indexeddb-dump.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('IndexedDBDumpHandlers', () => {
+    let page;
+    let getActivePage;
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        page = {
+            evaluate: vi.fn(),
+        };
+        getActivePage = vi.fn(async () => page);
+        handlers = new IndexedDBDumpHandlers({ getActivePage });
+    });
+    it('uses default dump options when args are omitted', async () => {
+        page.evaluate.mockResolvedValueOnce({
+            appDb: {
+                users: [{ id: 1, name: 'alice' }],
+            },
+        });
+        const body = parseJson(await handlers.handleIndexedDBDump({}));
+        expect(getActivePage).toHaveBeenCalledOnce();
+        expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+            database: '',
+            store: '',
+            maxRecords: 100,
+        });
+        expect(body).toEqual({
+            appDb: {
+                users: [{ id: 1, name: 'alice' }],
+            },
+        });
+    });
+    it('passes explicit database, store, and maxRecords values through to page.evaluate', async () => {
+        page.evaluate.mockResolvedValueOnce({
+            analyticsDb: {
+                events: [{ id: 9, type: 'click' }],
+            },
+        });
+        const body = parseJson(await handlers.handleIndexedDBDump({
+            database: 'analyticsDb',
+            store: 'events',
+            maxRecords: 10,
+        }));
+        expect(page.evaluate).toHaveBeenCalledWith(expect.any(Function), {
+            database: 'analyticsDb',
+            store: 'events',
+            maxRecords: 10,
+        });
+        expect(body.analyticsDb.events).toEqual([{ id: 9, type: 'click' }]);
+    });
+    it('returns an error payload when the dump fails', async () => {
+        page.evaluate.mockRejectedValueOnce(new Error('indexeddb failed'));
+        const body = parseJson(await handlers.handleIndexedDBDump({
+            database: 'appDb',
+        }));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('indexeddb failed');
+    });
+});

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

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

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

@@ -0,0 +1,135 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { cdpLimitMock, smartHandleMock, loggerMocks } = vi.hoisted(() => ({
+    cdpLimitMock: vi.fn(),
+    smartHandleMock: vi.fn(),
+    loggerMocks: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    },
+}));
+vi.mock('@src/utils/concurrency', () => ({
+    cdpLimit: (...args) => cdpLimitMock(...args),
+}));
+vi.mock('@src/utils/DetailedDataManager', () => ({
+    DetailedDataManager: {
+        getInstance: () => ({
+            smartHandle: (...args) => smartHandleMock(...args),
+        }),
+    },
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: loggerMocks,
+}));
+import { JSHeapSearchHandlers } from '../../../../src/server/domains/browser/handlers/js-heap.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('JSHeapSearchHandlers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        cdpLimitMock.mockImplementation(async (fn) => fn());
+        smartHandleMock.mockImplementation((value) => value);
+    });
+    it('returns a validation error when pattern is missing', async () => {
+        const getActivePage = vi.fn();
+        const handlers = new JSHeapSearchHandlers({
+            getActivePage,
+            getActiveDriver: () => 'chrome',
+        });
+        const body = parseJson(await handlers.handleJSHeapSearch({}));
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('pattern is required');
+        expect(cdpLimitMock).not.toHaveBeenCalled();
+        expect(getActivePage).not.toHaveBeenCalled();
+    });
+    it('takes a heap snapshot with default options and returns matched strings', async () => {
+        let chunkListener = (_params) => { };
+        const snapshot = JSON.stringify({
+            snapshot: {
+                meta: {
+                    node_fields: ['type', 'name', 'id'],
+                    node_types: [['hidden', 'array', 'string', 'object']],
+                },
+            },
+            strings: ['unused', 'secret token', 'other value'],
+            nodes: [2, 1, 101, 2, 2, 102],
+        });
+        const cdpSession = {
+            send: vi.fn(async (method) => {
+                if (method === 'HeapProfiler.takeHeapSnapshot') {
+                    const midpoint = Math.floor(snapshot.length / 2);
+                    chunkListener({ chunk: snapshot.slice(0, midpoint) });
+                    chunkListener({ chunk: snapshot.slice(midpoint) });
+                }
+            }),
+            on: vi.fn((event, listener) => {
+                if (event === 'HeapProfiler.addHeapSnapshotChunk') {
+                    chunkListener = listener;
+                }
+            }),
+            detach: vi.fn(async () => { }),
+        };
+        const page = {
+            createCDPSession: vi.fn(async () => cdpSession),
+        };
+        const handlers = new JSHeapSearchHandlers({
+            getActivePage: vi.fn(async () => page),
+            getActiveDriver: () => 'chrome',
+        });
+        const body = parseJson(await handlers.handleJSHeapSearch({ pattern: 'secret' }));
+        expect(cdpLimitMock).toHaveBeenCalledOnce();
+        expect(page.createCDPSession).toHaveBeenCalledOnce();
+        expect(cdpSession.on).toHaveBeenCalledWith('HeapProfiler.addHeapSnapshotChunk', expect.any(Function));
+        expect(cdpSession.send).toHaveBeenNthCalledWith(1, 'HeapProfiler.enable');
+        expect(cdpSession.send).toHaveBeenNthCalledWith(2, 'HeapProfiler.takeHeapSnapshot', {
+            reportProgress: false,
+            treatGlobalObjectsAsRoots: true,
+            captureNumericValue: false,
+        });
+        expect(cdpSession.send).toHaveBeenNthCalledWith(3, 'HeapProfiler.disable');
+        expect(smartHandleMock).toHaveBeenCalledWith(expect.objectContaining({
+            success: true,
+            pattern: 'secret',
+            caseSensitive: false,
+            matchCount: 1,
+            truncated: false,
+        }), 51200);
+        expect(body.success).toBe(true);
+        expect(body.matchCount).toBe(1);
+        expect(body.matches[0]).toMatchObject({
+            nodeId: 101,
+            nodeType: 'string',
+            objectPath: '[HeapNode #101]',
+            value: 'secret token',
+        });
+        expect(body.tip).toContain('page_evaluate');
+        expect(cdpSession.detach).toHaveBeenCalledOnce();
+    });
+    it('returns an error payload and detaches the CDP session when snapshot capture fails', async () => {
+        const cdpSession = {
+            send: vi.fn(async (method) => {
+                if (method === 'HeapProfiler.takeHeapSnapshot') {
+                    throw new Error('snapshot failed');
+                }
+            }),
+            on: vi.fn(),
+            detach: vi.fn(async () => { }),
+        };
+        const page = {
+            createCDPSession: vi.fn(async () => cdpSession),
+        };
+        const handlers = new JSHeapSearchHandlers({
+            getActivePage: vi.fn(async () => page),
+            getActiveDriver: () => 'chrome',
+        });
+        const body = parseJson(await handlers.handleJSHeapSearch({
+            pattern: 'secret',
+            maxResults: 3,
+            caseSensitive: true,
+        }));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('snapshot failed');
+        expect(cdpSession.detach).toHaveBeenCalledOnce();
+    });
+});

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

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

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

@@ -0,0 +1,123 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import '../shared/manifest-test-mocks.js';
+describe('server/domains/browser/manifest', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    it('exports a valid domain manifest as default', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        expect(manifest).toEqual(expect.objectContaining({
+            kind: 'domain-manifest',
+            version: 1,
+            domain: 'browser',
+            depKey: 'browserHandlers',
+            profiles: ['workflow', 'full'],
+            ensure: expect.any(Function),
+            registrations: expect.any(Array),
+        }));
+    });
+    it('has registrations that each reference the browser domain', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        expect(manifest.registrations.length).toBeGreaterThan(0);
+        manifest.registrations.forEach((reg) => {
+            expect(reg.domain).toBe('browser');
+            expect(reg.tool).toBeDefined();
+            expect(typeof reg.bind).toBe('function');
+        });
+    });
+    it('includes camoufox server tools in registrations', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        const toolNames = manifest.registrations.map((r) => r.tool.name);
+        expect(toolNames).toContain('camoufox_server_launch');
+        expect(toolNames).toContain('camoufox_server_close');
+        expect(toolNames).toContain('camoufox_server_status');
+    });
+    it('includes core browser tools in registrations', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        const toolNames = manifest.registrations.map((r) => r.tool.name);
+        expect(toolNames).toContain('browser_attach');
+        expect(toolNames).toContain('browser_launch');
+        expect(toolNames).toContain('browser_close');
+        expect(toolNames).toContain('browser_status');
+        expect(toolNames).toContain('browser_list_tabs');
+        expect(toolNames).toContain('browser_select_tab');
+    });
+    it('includes page interaction tools in registrations', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        const toolNames = manifest.registrations.map((r) => r.tool.name);
+        expect(toolNames).toContain('page_navigate');
+        expect(toolNames).toContain('page_reload');
+        expect(toolNames).toContain('page_click');
+        expect(toolNames).toContain('page_type');
+        expect(toolNames).toContain('page_screenshot');
+        expect(toolNames).toContain('page_evaluate');
+    });
+    it('includes DOM tools in registrations', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        const toolNames = manifest.registrations.map((r) => r.tool.name);
+        expect(toolNames).toContain('dom_query_selector');
+        expect(toolNames).toContain('dom_query_all');
+        expect(toolNames).toContain('dom_get_structure');
+        expect(toolNames).toContain('dom_find_clickable');
+        expect(toolNames).toContain('dom_find_by_text');
+    });
+    it('includes advanced browser tools in registrations', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        const toolNames = manifest.registrations.map((r) => r.tool.name);
+        expect(toolNames).toContain('captcha_detect');
+        expect(toolNames).toContain('stealth_inject');
+        expect(toolNames).toContain('tab_workflow');
+        expect(toolNames).toContain('framework_state_extract');
+        expect(toolNames).toContain('indexeddb_dump');
+        expect(toolNames).toContain('js_heap_search');
+    });
+    it('includes human behavior simulation tools in registrations', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        const toolNames = manifest.registrations.map((r) => r.tool.name);
+        expect(toolNames).toContain('human_mouse');
+        expect(toolNames).toContain('human_scroll');
+        expect(toolNames).toContain('human_typing');
+    });
+    it('includes captcha solving tools in registrations', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        const toolNames = manifest.registrations.map((r) => r.tool.name);
+        expect(toolNames).toContain('captcha_vision_solve');
+        expect(toolNames).toContain('widget_challenge_solve');
+    });
+    it('has no duplicate tool names across registrations', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        const toolNames = manifest.registrations.map((r) => r.tool.name);
+        expect(new Set(toolNames).size).toBe(toolNames.length);
+    });
+    it('ensure function creates handlers when context has browser core', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        const ctx = {
+            collector: {},
+            pageController: {},
+            domInspector: {},
+            scriptManager: {},
+            consoleMonitor: {},
+            llm: {},
+            browserHandlers: undefined,
+        };
+        const result = manifest.ensure(ctx);
+        expect(result).toBeDefined();
+        expect(ctx.browserHandlers).toBeDefined();
+    });
+    it('ensure function returns existing handlers on subsequent calls', async () => {
+        const { default: manifest } = await import('../../../../src/server/domains/browser/manifest.js');
+        const existingHandlers = { existing: true };
+        const ctx = {
+            collector: {},
+            pageController: {},
+            domInspector: {},
+            scriptManager: {},
+            consoleMonitor: {},
+            llm: {},
+            browserHandlers: existingHandlers,
+        };
+        const result = manifest.ensure(ctx);
+        expect(result).toBe(existingHandlers);
+    });
+});

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

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