@jshookmcp/jshook 0.2.0 → 0.2.1

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

@@ -0,0 +1,141 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { PageDataHandlers } from '../../../../src/server/domains/browser/handlers/page-data.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('PageDataHandlers', () => {
+    let pageController;
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        pageController = {
+            getPerformanceMetrics: vi.fn(),
+            setCookies: vi.fn(),
+            getCookies: vi.fn(),
+            clearCookies: vi.fn(),
+            setViewport: vi.fn(),
+            emulateDevice: vi.fn(),
+            getLocalStorage: vi.fn(),
+            setLocalStorage: vi.fn(),
+            getAllLinks: vi.fn(),
+        };
+        handlers = new PageDataHandlers({
+            pageController,
+            getActiveDriver: () => 'chrome',
+            getCamoufoxPage: async () => null,
+        });
+    });
+    it('returns performance metrics', async () => {
+        pageController.getPerformanceMetrics.mockResolvedValue({
+            domContentLoaded: 120,
+            loadEvent: 180,
+        });
+        const body = parseJson(await handlers.handlePageGetPerformance({}));
+        expect(pageController.getPerformanceMetrics).toHaveBeenCalledOnce();
+        expect(body).toEqual({
+            success: true,
+            metrics: {
+                domContentLoaded: 120,
+                loadEvent: 180,
+            },
+        });
+    });
+    it('sets cookies and returns the cookie count message', async () => {
+        const cookies = [
+            { name: 'session', value: 'abc' },
+            { name: 'theme', value: 'dark' },
+        ];
+        pageController.setCookies.mockResolvedValue(undefined);
+        const body = parseJson(await handlers.handlePageSetCookies({ cookies }));
+        expect(pageController.setCookies).toHaveBeenCalledWith(cookies);
+        expect(body).toEqual({
+            success: true,
+            message: 'Set 2 cookies',
+        });
+    });
+    it('returns cookies with a count', async () => {
+        pageController.getCookies.mockResolvedValue([
+            { name: 'session', value: 'abc' },
+            { name: 'theme', value: 'dark' },
+        ]);
+        const body = parseJson(await handlers.handlePageGetCookies({}));
+        expect(pageController.getCookies).toHaveBeenCalledOnce();
+        expect(body).toEqual({
+            count: 2,
+            cookies: [
+                { name: 'session', value: 'abc' },
+                { name: 'theme', value: 'dark' },
+            ],
+        });
+    });
+    it('clears cookies and returns success', async () => {
+        pageController.clearCookies.mockResolvedValue(undefined);
+        const body = parseJson(await handlers.handlePageClearCookies({}));
+        expect(pageController.clearCookies).toHaveBeenCalledOnce();
+        expect(body).toEqual({
+            success: true,
+            message: 'Cookies cleared',
+        });
+    });
+    it('sets viewport dimensions and returns the applied viewport', async () => {
+        pageController.setViewport.mockResolvedValue(undefined);
+        const body = parseJson(await handlers.handlePageSetViewport({ width: 1440, height: 900 }));
+        expect(pageController.setViewport).toHaveBeenCalledWith(1440, 900);
+        expect(body).toEqual({
+            success: true,
+            viewport: { width: 1440, height: 900 },
+        });
+    });
+    it('emulates a device and returns the selected device', async () => {
+        pageController.emulateDevice.mockResolvedValue(undefined);
+        const body = parseJson(await handlers.handlePageEmulateDevice({ device: 'iPhone' }));
+        expect(pageController.emulateDevice).toHaveBeenCalledWith('iPhone');
+        expect(body).toEqual({
+            success: true,
+            device: 'iPhone',
+        });
+    });
+    it('returns local storage entries with a count', async () => {
+        pageController.getLocalStorage.mockResolvedValue({
+            token: 'abc',
+            theme: 'dark',
+        });
+        const body = parseJson(await handlers.handlePageGetLocalStorage({}));
+        expect(pageController.getLocalStorage).toHaveBeenCalledOnce();
+        expect(body).toEqual({
+            count: 2,
+            storage: {
+                token: 'abc',
+                theme: 'dark',
+            },
+        });
+    });
+    it('sets a local storage entry and returns the key', async () => {
+        pageController.setLocalStorage.mockResolvedValue(undefined);
+        const body = parseJson(await handlers.handlePageSetLocalStorage({ key: 'token', value: 'abc123' }));
+        expect(pageController.setLocalStorage).toHaveBeenCalledWith('token', 'abc123');
+        expect(body).toEqual({
+            success: true,
+            key: 'token',
+        });
+    });
+    it('returns all links with a count', async () => {
+        pageController.getAllLinks.mockResolvedValue([
+            { text: 'Docs', href: 'https://vmoranv.github.io/jshookmcp/docs' },
+            { text: 'GitHub', href: 'https://github.com/vmoranv/jshookmcp' },
+        ]);
+        const body = parseJson(await handlers.handlePageGetAllLinks({}));
+        expect(pageController.getAllLinks).toHaveBeenCalledOnce();
+        expect(body).toEqual({
+            count: 2,
+            links: [
+                { text: 'Docs', href: 'https://vmoranv.github.io/jshookmcp/docs' },
+                { text: 'GitHub', href: 'https://github.com/vmoranv/jshookmcp' },
+            ],
+        });
+    });
+    it('rethrows page controller errors when setting cookies', async () => {
+        pageController.setCookies.mockRejectedValue(new Error('set cookies failed'));
+        await expect(handlers.handlePageSetCookies({ cookies: [{ name: 'session', value: 'abc' }] })).rejects.toThrow('set cookies failed');
+    });
+});

package/dist/tests/server/domains/browser/page-evaluation.test.js

@@ -1,38 +1,372 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@utils/outputPaths', () => ({
+    resolveScreenshotOutputPath: vi.fn(async (opts) => ({
+        absolutePath: `/tmp/screenshots/${opts.fallbackName || 'page'}.${opts.type || 'png'}`,
+        displayPath: `screenshots/${opts.fallbackName || 'page'}.${opts.type || 'png'}`,
+        pathRewritten: !opts.requestedPath,
+    })),
+}));
 import { PageEvaluationHandlers } from '../../../../src/server/domains/browser/handlers/page-evaluation.js';
 function parseJson(response) {
     return JSON.parse(response.content[0].text);
 }
-describe('PageEvaluationHandlers', () => {
+function createChromeDeps(overrides = {}) {
+    const pageController = {
+        evaluate: vi.fn(async () => ({ result: 42 })),
+        screenshot: vi.fn(async () => Buffer.from('png-data')),
+        getPage: vi.fn(async () => ({
+            $: vi.fn(async () => ({
+                screenshot: vi.fn(async () => Buffer.from('element-png')),
+            })),
+        })),
+        injectScript: vi.fn(async () => { }),
+        waitForSelector: vi.fn(async () => ({
+            success: true,
+            message: 'found',
+        })),
+        ...overrides.pageController,
+    };
+    const detailedDataManager = {
+        smartHandle: vi.fn((value) => value),
+        ...overrides.detailedDataManager,
+    };
+    return {
+        pageController,
+        detailedDataManager,
+        getActiveDriver: overrides.getActiveDriver ?? (() => 'chrome'),
+        getCamoufoxPage: overrides.getCamoufoxPage ?? (async () => null),
+    };
+}
+describe('PageEvaluationHandlers – handlePageEvaluate', () => {
+    let handlers;
+    let deps;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        deps = createChromeDeps();
+        handlers = new PageEvaluationHandlers(deps);
+    });
+    it('evaluates code on chrome and returns result', async () => {
+        deps.pageController.evaluate.mockResolvedValueOnce({ count: 5 });
+        const body = parseJson(await handlers.handlePageEvaluate({ code: 'document.title' }));
+        expect(deps.pageController.evaluate).toHaveBeenCalledWith('document.title');
+        expect(body.success).toBe(true);
+        expect(body.result).toEqual({ count: 5 });
+    });
+    it('accepts script arg as an alias for code', async () => {
+        deps.pageController.evaluate.mockResolvedValueOnce('title');
+        const body = parseJson(await handlers.handlePageEvaluate({ script: 'document.title' }));
+        expect(deps.pageController.evaluate).toHaveBeenCalledWith('document.title');
+        expect(body.success).toBe(true);
+    });
+    it('uses detailedDataManager.smartHandle with autoSummarize=true (default)', async () => {
+        deps.pageController.evaluate.mockResolvedValueOnce({ big: 'data' });
+        await handlers.handlePageEvaluate({ code: '1+1' });
+        expect(deps.detailedDataManager.smartHandle).toHaveBeenCalledWith({ big: 'data' }, 51200);
+    });
+    it('skips smartHandle when autoSummarize=false', async () => {
+        deps.pageController.evaluate.mockResolvedValueOnce('raw');
+        const body = parseJson(await handlers.handlePageEvaluate({
+            code: '1+1',
+            autoSummarize: false,
+        }));
+        expect(deps.detailedDataManager.smartHandle).not.toHaveBeenCalled();
+        expect(body.result).toBe('raw');
+    });
+    it('respects custom maxSize for smartHandle', async () => {
+        deps.pageController.evaluate.mockResolvedValueOnce('data');
+        await handlers.handlePageEvaluate({ code: '1', maxSize: 1024 });
+        expect(deps.detailedDataManager.smartHandle).toHaveBeenCalledWith('data', 1024);
+    });
+    it('applies fieldFilter to strip specified keys', async () => {
+        deps.pageController.evaluate.mockResolvedValueOnce({
+            name: 'test',
+            secret: 'hidden',
+            nested: { secret: 'also-hidden', visible: true },
+        });
+        const body = parseJson(await handlers.handlePageEvaluate({
+            code: 'obj',
+            fieldFilter: ['secret'],
+            autoSummarize: false,
+        }));
+        expect(body.result.name).toBe('test');
+        expect(body.result.secret).toBeUndefined();
+        expect(body.result.nested.secret).toBeUndefined();
+        expect(body.result.nested.visible).toBe(true);
+    });
+    it('strips base64 data URIs when stripBase64=true', async () => {
+        deps.pageController.evaluate.mockResolvedValueOnce({
+            image: 'data:image/png;base64,' + 'A'.repeat(1000),
+        });
+        const body = parseJson(await handlers.handlePageEvaluate({
+            code: 'img',
+            stripBase64: true,
+            autoSummarize: false,
+        }));
+        expect(body.result.image).toContain('stripped');
+        expect(body.result.image).not.toContain('AAAA');
+    });
+    it('strips bare base64 strings >500 chars when stripBase64=true', async () => {
+        const longBase64 = 'A'.repeat(600);
+        deps.pageController.evaluate.mockResolvedValueOnce({ data: longBase64 });
+        const body = parseJson(await handlers.handlePageEvaluate({
+            code: 'x',
+            stripBase64: true,
+            autoSummarize: false,
+        }));
+        expect(body.result.data).toContain('stripped');
+    });
+    it('does not strip short base64-like strings', async () => {
+        deps.pageController.evaluate.mockResolvedValueOnce({ data: 'AAAA' });
+        const body = parseJson(await handlers.handlePageEvaluate({
+            code: 'x',
+            stripBase64: true,
+            autoSummarize: false,
+        }));
+        expect(body.result.data).toBe('AAAA');
+    });
+    it('evaluates on camoufox driver', async () => {
+        const camoPage = {
+            evaluate: vi.fn(async () => 'camoufox-result'),
+        };
+        deps = createChromeDeps({
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => camoPage,
+        });
+        handlers = new PageEvaluationHandlers(deps);
+        const body = parseJson(await handlers.handlePageEvaluate({ code: 'document.title' }));
+        expect(camoPage.evaluate).toHaveBeenCalled();
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+        expect(body.result).toBe('camoufox-result');
+    });
+});
+describe('PageEvaluationHandlers – handlePageScreenshot', () => {
+    let handlers;
+    let deps;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        deps = createChromeDeps();
+        handlers = new PageEvaluationHandlers(deps);
+    });
+    it('takes a full-page screenshot with defaults', async () => {
+        deps.pageController.screenshot.mockResolvedValueOnce(Buffer.from('png-bytes'));
+        const body = parseJson(await handlers.handlePageScreenshot({}));
+        expect(body.success).toBe(true);
+        expect(body.path).toBeDefined();
+        expect(body.size).toBeGreaterThan(0);
+    });
+    it('takes an element screenshot when selector is provided', async () => {
+        const elementMock = {
+            screenshot: vi.fn(async () => Buffer.from('el-data')),
+        };
+        deps.pageController.getPage.mockResolvedValueOnce({
+            $: vi.fn(async () => elementMock),
+        });
+        const body = parseJson(await handlers.handlePageScreenshot({ selector: '#header' }));
+        expect(body.success).toBe(true);
+        expect(body.selector).toBe('#header');
+    });
+    it('returns error when element not found for selector', async () => {
+        deps.pageController.getPage.mockResolvedValueOnce({
+            $: vi.fn(async () => null),
+        });
+        const body = parseJson(await handlers.handlePageScreenshot({ selector: '#missing' }));
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('Element not found');
+    });
+    it('uses clip option when provided', async () => {
+        const clip = { x: 10, y: 20, width: 100, height: 50 };
+        deps.pageController.screenshot.mockResolvedValueOnce(Buffer.from('clip-data'));
+        const body = parseJson(await handlers.handlePageScreenshot({ clip }));
+        expect(deps.pageController.screenshot).toHaveBeenCalledWith(expect.objectContaining({
+            clip,
+            fullPage: false,
+        }));
+        expect(body.success).toBe(true);
+    });
+    it('ignores selector value "all" (case-insensitive)', async () => {
+        deps.pageController.screenshot.mockResolvedValueOnce(Buffer.from('png-data'));
+        const body = parseJson(await handlers.handlePageScreenshot({ selector: 'ALL' }));
+        expect(body.success).toBe(true);
+        expect(body.selector).toBeUndefined();
+    });
+    it('handles batch mode with multiple selectors', async () => {
+        const elementMock = {
+            screenshot: vi.fn(async () => Buffer.from('batch-el')),
+        };
+        deps.pageController.getPage.mockResolvedValue({
+            $: vi.fn(async () => elementMock),
+        });
+        const body = parseJson(await handlers.handlePageScreenshot({
+            selector: ['#a', '#b'],
+        }));
+        expect(body.success).toBe(true);
+        expect(body.mode).toBe('batch');
+        expect(body.total).toBe(2);
+        expect(body.succeeded).toBe(2);
+        expect(body.results).toHaveLength(2);
+    });
+    it('batch mode records errors for missing elements', async () => {
+        const pageObj = {
+            $: vi.fn()
+                .mockResolvedValueOnce({
+                screenshot: vi.fn(async () => Buffer.from('ok')),
+            })
+                .mockResolvedValueOnce(null),
+        };
+        deps.pageController.getPage.mockResolvedValue(pageObj);
+        const body = parseJson(await handlers.handlePageScreenshot({
+            selector: ['#found', '#missing'],
+        }));
+        expect(body.total).toBe(2);
+        expect(body.succeeded).toBe(1);
+        expect(body.results[0].success).toBe(true);
+        expect(body.results[1].success).toBe(false);
+        expect(body.results[1].error).toContain('Element not found');
+    });
+    it('takes screenshot on camoufox page (no selector)', async () => {
+        const camoPage = {
+            screenshot: vi.fn(async () => Buffer.from('camo-png')),
+            $: vi.fn(),
+        };
+        deps = createChromeDeps({
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => camoPage,
+        });
+        handlers = new PageEvaluationHandlers(deps);
+        const body = parseJson(await handlers.handlePageScreenshot({}));
+        expect(camoPage.screenshot).toHaveBeenCalled();
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+    });
+    it('takes element screenshot on camoufox page', async () => {
+        const elMock = {
+            screenshot: vi.fn(async () => Buffer.from('camo-el')),
+        };
+        const camoPage = {
+            screenshot: vi.fn(),
+            $: vi.fn(async () => elMock),
+        };
+        deps = createChromeDeps({
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => camoPage,
+        });
+        handlers = new PageEvaluationHandlers(deps);
+        const body = parseJson(await handlers.handlePageScreenshot({ selector: '.btn' }));
+        expect(camoPage.$).toHaveBeenCalledWith('.btn');
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+    });
+    it('returns error for missing element on camoufox', async () => {
+        const camoPage = {
+            screenshot: vi.fn(),
+            $: vi.fn(async () => null),
+        };
+        deps = createChromeDeps({
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => camoPage,
+        });
+        handlers = new PageEvaluationHandlers(deps);
+        const body = parseJson(await handlers.handlePageScreenshot({ selector: '#gone' }));
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('Element not found');
+    });
+});
+describe('PageEvaluationHandlers – handlePageInjectScript', () => {
+    let handlers;
+    let deps;
     beforeEach(() => {
         vi.clearAllMocks();
+        deps = createChromeDeps();
+        handlers = new PageEvaluationHandlers(deps);
     });
-    it('waits for selector through camoufox page when camoufox is active', async () => {
-        const page = {
+    it('injects a script and returns success', async () => {
+        const body = parseJson(await handlers.handlePageInjectScript({ script: 'console.log("hi")' }));
+        expect(deps.pageController.injectScript).toHaveBeenCalledWith('console.log("hi")');
+        expect(body.success).toBe(true);
+        expect(body.message).toBe('Script injected');
+    });
+});
+describe('PageEvaluationHandlers – handlePageWaitForSelector', () => {
+    let handlers;
+    let deps;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        deps = createChromeDeps();
+        handlers = new PageEvaluationHandlers(deps);
+    });
+    it('waits for selector via chrome pageController', async () => {
+        deps.pageController.waitForSelector.mockResolvedValueOnce({
+            success: true,
+            message: 'found #btn',
+        });
+        const body = parseJson(await handlers.handlePageWaitForSelector({
+            selector: '#btn',
+            timeout: 5000,
+        }));
+        expect(deps.pageController.waitForSelector).toHaveBeenCalledWith('#btn', 5000);
+        expect(body.success).toBe(true);
+    });
+    it('waits for selector on camoufox and returns element info', async () => {
+        const camoPage = {
             waitForSelector: vi.fn(async () => { }),
             evaluate: vi.fn(async () => ({
-                tagName: 'button',
-                id: 'submit',
-                className: 'primary',
-                textContent: 'Submit',
-                attributes: { type: 'submit' },
+                tagName: 'div',
+                id: 'main',
+                className: 'container',
+                textContent: 'Hello',
+                attributes: { id: 'main' },
             })),
         };
-        const pageController = {
-            waitForSelector: vi.fn(),
-        };
-        const handlers = new PageEvaluationHandlers({
-            pageController,
-            detailedDataManager: { smartHandle: vi.fn((value) => value) },
+        deps = createChromeDeps({
             getActiveDriver: () => 'camoufox',
-            getCamoufoxPage: async () => page,
+            getCamoufoxPage: async () => camoPage,
+        });
+        handlers = new PageEvaluationHandlers(deps);
+        const body = parseJson(await handlers.handlePageWaitForSelector({
+            selector: '#main',
+            timeout: 2000,
+        }));
+        expect(camoPage.waitForSelector).toHaveBeenCalledWith('#main', {
+            timeout: 2000,
         });
-        const body = parseJson(await handlers.handlePageWaitForSelector({ selector: '#submit', timeout: 1500 }));
-        expect(page.waitForSelector).toHaveBeenCalledWith('#submit', { timeout: 1500 });
-        expect(page.evaluate).toHaveBeenCalledTimes(1);
-        expect(pageController.waitForSelector).not.toHaveBeenCalled();
         expect(body.success).toBe(true);
         expect(body.driver).toBe('camoufox');
-        expect(body.element?.id).toBe('submit');
+        expect(body.element.tagName).toBe('div');
+    });
+    it('uses default 30s timeout on camoufox when none provided', async () => {
+        const camoPage = {
+            waitForSelector: vi.fn(async () => { }),
+            evaluate: vi.fn(async () => null),
+        };
+        deps = createChromeDeps({
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => camoPage,
+        });
+        handlers = new PageEvaluationHandlers(deps);
+        await handlers.handlePageWaitForSelector({ selector: '.x' });
+        expect(camoPage.waitForSelector).toHaveBeenCalledWith('.x', {
+            timeout: 30000,
+        });
+    });
+    it('returns timeout error on camoufox when waitForSelector throws', async () => {
+        const camoPage = {
+            waitForSelector: vi.fn(async () => {
+                throw new Error('timeout');
+            }),
+            evaluate: vi.fn(),
+        };
+        deps = createChromeDeps({
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => camoPage,
+        });
+        handlers = new PageEvaluationHandlers(deps);
+        const body = parseJson(await handlers.handlePageWaitForSelector({
+            selector: '#nope',
+            timeout: 100,
+        }));
+        expect(body.success).toBe(false);
+        expect(body.driver).toBe('camoufox');
+        expect(body.message).toContain('Timeout');
     });
 });