@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/tests/modules/monitor/ConsoleMonitor.test.js

@@ -0,0 +1,291 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+const networkState = vi.hoisted(() => ({
+    ctor: null,
+    instances: [],
+}));
+const playwrightNetworkState = vi.hoisted(() => ({
+    ctor: null,
+    instances: [],
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: loggerState,
+}));
+vi.mock('@src/modules/monitor/NetworkMonitor', () => {
+    const ctorSpy = vi.fn();
+    networkState.ctor = ctorSpy;
+    class NetworkMonitor {
+        session;
+        enabled = false;
+        enable = vi.fn(async () => {
+            this.enabled = true;
+        });
+        disable = vi.fn(async () => {
+            this.enabled = false;
+        });
+        isEnabled = vi.fn(() => this.enabled);
+        getStatus = vi.fn(() => ({
+            enabled: this.enabled,
+            requestCount: 1,
+            responseCount: 1,
+            listenerCount: 1,
+            cdpSessionActive: true,
+        }));
+        getRequests = vi.fn(() => [{ requestId: 'req-1' }]);
+        getResponses = vi.fn(() => [{ requestId: 'req-1', status: 200 }]);
+        getActivity = vi.fn(() => ({ request: { requestId: 'req-1' } }));
+        getResponseBody = vi.fn(async () => ({ body: 'body', base64Encoded: false }));
+        getAllJavaScriptResponses = vi.fn(async () => []);
+        clearRecords = vi.fn();
+        clearInjectedBuffers = vi.fn(async () => ({ xhrCleared: 2, fetchCleared: 1 }));
+        resetInjectedInterceptors = vi.fn(async () => ({ xhrReset: true, fetchReset: true }));
+        getStats = vi.fn(() => ({
+            totalRequests: 1,
+            totalResponses: 1,
+            byMethod: { GET: 1 },
+            byStatus: { 200: 1 },
+            byType: { XHR: 1 },
+        }));
+        injectXHRInterceptor = vi.fn(async () => { });
+        injectFetchInterceptor = vi.fn(async () => { });
+        getXHRRequests = vi.fn(async () => [{ id: 'xhr-1' }]);
+        getFetchRequests = vi.fn(async () => [{ id: 'fetch-1' }]);
+        constructor(session) {
+            ctorSpy(session);
+            this.session = session;
+            networkState.instances.push(this);
+        }
+    }
+    return { NetworkMonitor };
+});
+vi.mock('@src/modules/monitor/PlaywrightNetworkMonitor', () => {
+    const ctorSpy = vi.fn();
+    playwrightNetworkState.ctor = ctorSpy;
+    class PlaywrightNetworkMonitor {
+        page;
+        enabled = false;
+        enable = vi.fn(async () => {
+            this.enabled = true;
+        });
+        disable = vi.fn(async () => {
+            this.enabled = false;
+        });
+        isEnabled = vi.fn(() => this.enabled);
+        getStatus = vi.fn(() => ({
+            enabled: this.enabled,
+            requestCount: 0,
+            responseCount: 0,
+            listenerCount: 2,
+            cdpSessionActive: false,
+        }));
+        getRequests = vi.fn(() => []);
+        getResponses = vi.fn(() => []);
+        getActivity = vi.fn(() => ({}));
+        getResponseBody = vi.fn(async () => ({ body: 'pw-body', base64Encoded: false }));
+        getAllJavaScriptResponses = vi.fn(async () => []);
+        clearRecords = vi.fn();
+        clearInjectedBuffers = vi.fn(async () => ({ xhrCleared: 4, fetchCleared: 5 }));
+        resetInjectedInterceptors = vi.fn(async () => ({ xhrReset: true, fetchReset: true }));
+        getStats = vi.fn(() => ({
+            totalRequests: 0,
+            totalResponses: 0,
+            byMethod: {},
+            byStatus: {},
+            byType: {},
+        }));
+        injectXHRInterceptor = vi.fn(async () => { });
+        injectFetchInterceptor = vi.fn(async () => { });
+        getXHRRequests = vi.fn(async () => []);
+        getFetchRequests = vi.fn(async () => []);
+        setPage = vi.fn((page) => {
+            this.page = page;
+            if (!page) {
+                this.enabled = false;
+            }
+        });
+        constructor(page) {
+            ctorSpy(page);
+            this.page = page;
+            playwrightNetworkState.instances.push(this);
+        }
+    }
+    return { PlaywrightNetworkMonitor };
+});
+import { ConsoleMonitor } from '../../../src/modules/monitor/ConsoleMonitor.js';
+function createMockSession() {
+    const listeners = new Map();
+    const send = vi.fn(async (..._args) => ({}));
+    const on = vi.fn((event, handler) => {
+        const group = listeners.get(event) ?? new Set();
+        group.add(handler);
+        listeners.set(event, group);
+    });
+    const off = vi.fn((event, handler) => {
+        listeners.get(event)?.delete(handler);
+    });
+    const detach = vi.fn(async () => { });
+    const emit = (event, payload) => {
+        listeners.get(event)?.forEach((handler) => handler(payload));
+    };
+    return { session: { send, on, off, detach }, send, emit };
+}
+function createCollectorWithSessions(...sessions) {
+    const createPage = (session) => ({
+        createCDPSession: vi.fn(async () => session),
+    });
+    const getActivePage = vi.fn();
+    sessions.forEach((session) => {
+        getActivePage.mockResolvedValueOnce(createPage(session));
+    });
+    return { getActivePage };
+}
+describe('ConsoleMonitor', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        loggerState.debug.mockReset();
+        loggerState.info.mockReset();
+        loggerState.warn.mockReset();
+        loggerState.error.mockReset();
+        networkState.instances.length = 0;
+        playwrightNetworkState.instances.length = 0;
+        networkState.ctor?.mockClear?.();
+        playwrightNetworkState.ctor?.mockClear?.();
+    });
+    it('enables CDP monitoring and initializes network monitor when requested', async () => {
+        const { session, send } = createMockSession();
+        send.mockImplementation(async (method) => {
+            if (method === 'Runtime.enable' || method === 'Console.enable')
+                return {};
+            return {};
+        });
+        const collector = createCollectorWithSessions(session);
+        const monitor = new ConsoleMonitor(collector);
+        await monitor.enable({ enableNetwork: true });
+        expect(collector.getActivePage).toHaveBeenCalledTimes(1);
+        expect(send).toHaveBeenCalledWith('Runtime.enable');
+        expect(send).toHaveBeenCalledWith('Console.enable');
+        expect(networkState.ctor).toHaveBeenCalledTimes(1);
+        expect(networkState.instances[0].enable).toHaveBeenCalledTimes(1);
+        expect(monitor.isNetworkEnabled()).toBe(true);
+    });
+    it('captures console events and supports typed/sliced log queries', async () => {
+        const { session, emit } = createMockSession();
+        const collector = createCollectorWithSessions(session);
+        const monitor = new ConsoleMonitor(collector);
+        await monitor.enable();
+        emit('Runtime.consoleAPICalled', {
+            type: 'log',
+            args: [{ value: 'hello' }],
+            timestamp: 100,
+            stackTrace: { callFrames: [] },
+        });
+        emit('Runtime.consoleAPICalled', {
+            type: 'warn',
+            args: [{ value: 'warning' }],
+            timestamp: 200,
+            stackTrace: { callFrames: [] },
+        });
+        expect(monitor.getLogs()).toHaveLength(2);
+        expect(monitor.getLogs({ type: 'log' })).toHaveLength(1);
+        expect(monitor.getLogs({ limit: 1 })[0].text).toContain('warning');
+        expect(monitor.getStats().byType.warn).toBe(1);
+    });
+    it('evaluates expressions and surfaces runtime exceptions', async () => {
+        const { session, send } = createMockSession();
+        send.mockImplementation(async (method, params) => {
+            if (method === 'Runtime.enable' || method === 'Console.enable')
+                return {};
+            if (method === 'Runtime.evaluate' && params?.expression === 'ok') {
+                return { result: { value: 42 } };
+            }
+            if (method === 'Runtime.evaluate' && params?.expression === 'bad') {
+                return { exceptionDetails: { text: 'boom' } };
+            }
+            return {};
+        });
+        const collector = createCollectorWithSessions(session);
+        const monitor = new ConsoleMonitor(collector);
+        await monitor.enable();
+        await expect(monitor.execute('ok')).resolves.toBe(42);
+        await expect(monitor.execute('bad')).rejects.toThrow('boom');
+    });
+    it('re-initializes session after CDP disconnect', async () => {
+        const first = createMockSession();
+        const second = createMockSession();
+        const collector = createCollectorWithSessions(first.session, second.session);
+        const monitor = new ConsoleMonitor(collector);
+        await monitor.enable();
+        first.emit('disconnected');
+        await monitor.ensureSession();
+        expect(collector.getActivePage).toHaveBeenCalledTimes(2);
+        expect(second.send).toHaveBeenCalledWith('Runtime.enable');
+        expect(second.send).toHaveBeenCalledWith('Console.enable');
+    });
+    it('supports Playwright mode with console/error capture and network delegation', async () => {
+        const handlers = {};
+        const page = {
+            on: vi.fn((event, handler) => {
+                handlers[event] = handler;
+            }),
+            off: vi.fn((event, handler) => {
+                if (handlers[event] === handler) {
+                    delete handlers[event];
+                }
+            }),
+        };
+        const monitor = new ConsoleMonitor({ getActivePage: vi.fn() });
+        monitor.setPlaywrightPage(page);
+        await monitor.enable({ enableNetwork: true, enableExceptions: true });
+        handlers.console({
+            type: () => 'error',
+            text: () => 'playwright console failure',
+        });
+        handlers.pageerror(new Error('playwright page error'));
+        expect(playwrightNetworkState.ctor).toHaveBeenCalledTimes(1);
+        expect(playwrightNetworkState.instances[0].enable).toHaveBeenCalledTimes(1);
+        expect(monitor.getLogs({ type: 'error' })).toHaveLength(1);
+        expect(monitor.getExceptions()).toHaveLength(1);
+        expect(monitor.isNetworkEnabled()).toBe(true);
+    });
+    it('rebinds the Playwright network monitor when the page changes', async () => {
+        const firstPage = {
+            on: vi.fn(),
+            off: vi.fn(),
+        };
+        const secondPage = {
+            on: vi.fn(),
+            off: vi.fn(),
+        };
+        const monitor = new ConsoleMonitor({ getActivePage: vi.fn() });
+        monitor.setPlaywrightPage(firstPage);
+        await monitor.enable({ enableNetwork: true, enableExceptions: true });
+        monitor.setPlaywrightPage(secondPage);
+        expect(playwrightNetworkState.ctor).toHaveBeenCalledTimes(1);
+        expect(playwrightNetworkState.instances[0].setPage).toHaveBeenCalledWith(secondPage);
+    });
+    it('combines network and dynamic-script cleanup results', async () => {
+        const { session, send } = createMockSession();
+        send.mockImplementation(async (method) => {
+            if (method === 'Runtime.enable' || method === 'Console.enable')
+                return {};
+            if (method === 'Runtime.evaluate') {
+                return { result: { value: { dynamicScriptsCleared: 4 } } };
+            }
+            return {};
+        });
+        const collector = createCollectorWithSessions(session);
+        const monitor = new ConsoleMonitor(collector);
+        await monitor.enable({ enableNetwork: true });
+        const result = await monitor.clearInjectedBuffers();
+        expect(result).toEqual({
+            xhrCleared: 2,
+            fetchCleared: 1,
+            dynamicScriptsCleared: 4,
+        });
+    });
+});

package/dist/tests/modules/monitor/NetworkMonitor.test.d.ts

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

package/dist/tests/modules/monitor/NetworkMonitor.test.js

@@ -0,0 +1,301 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: loggerState,
+}));
+import { NetworkMonitor } from '../../../src/modules/monitor/NetworkMonitor.js';
+function createMockSession() {
+    const listeners = new Map();
+    const send = vi.fn(async (..._args) => ({}));
+    const on = vi.fn((event, handler) => {
+        const group = listeners.get(event) ?? new Set();
+        group.add(handler);
+        listeners.set(event, group);
+    });
+    const off = vi.fn((event, handler) => {
+        listeners.get(event)?.delete(handler);
+    });
+    const emit = (event, payload) => {
+        listeners.get(event)?.forEach((handler) => handler(payload));
+    };
+    return {
+        session: { send, on, off },
+        send,
+        emit,
+    };
+}
+describe('NetworkMonitor', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        loggerState.debug.mockReset();
+        loggerState.info.mockReset();
+        loggerState.warn.mockReset();
+        loggerState.error.mockReset();
+    });
+    it('enables monitoring and captures request/response activity', async () => {
+        const { session, emit } = createMockSession();
+        const monitor = new NetworkMonitor(session);
+        await monitor.enable();
+        emit('Network.requestWillBeSent', {
+            requestId: 'req-1',
+            request: { url: 'https://vmoranv.github.io/jshookmcp/api/users', method: 'GET', headers: {}, postData: '' },
+            timestamp: 1,
+            type: 'XHR',
+            initiator: { type: 'script' },
+        });
+        emit('Network.responseReceived', {
+            requestId: 'req-1',
+            response: {
+                url: 'https://vmoranv.github.io/jshookmcp/api/users',
+                status: 200,
+                statusText: 'OK',
+                headers: { 'content-type': 'application/json' },
+                mimeType: 'application/json',
+                fromDiskCache: false,
+                fromServiceWorker: false,
+                timing: { requestTime: 1 },
+            },
+            timestamp: 2,
+        });
+        expect(monitor.isEnabled()).toBe(true);
+        expect(monitor.getRequests()).toHaveLength(1);
+        expect(monitor.getResponses()).toHaveLength(1);
+        expect(monitor.getActivity('req-1').response?.status).toBe(200);
+        expect(monitor.getStats().byMethod.GET).toBe(1);
+    });
+    it('returns null response body when monitor is disabled or request is incomplete', async () => {
+        const { session, emit } = createMockSession();
+        const monitor = new NetworkMonitor(session);
+        await expect(monitor.getResponseBody('req-missing')).resolves.toBeNull();
+        await monitor.enable();
+        await expect(monitor.getResponseBody('req-missing')).resolves.toBeNull();
+        emit('Network.requestWillBeSent', {
+            requestId: 'req-pending',
+            request: { url: 'https://vmoranv.github.io/jshookmcp/api/pending', method: 'GET', headers: {} },
+            timestamp: 1,
+            type: 'XHR',
+            initiator: {},
+        });
+        await expect(monitor.getResponseBody('req-pending')).resolves.toBeNull();
+    });
+    it('retrieves response body successfully and handles CDP body errors gracefully', async () => {
+        const { session, send, emit } = createMockSession();
+        send.mockImplementation(async (method, params) => {
+            if (method === 'Network.enable')
+                return {};
+            if (method === 'Network.getResponseBody' && params?.requestId === 'req-ok') {
+                return { body: 'payload', base64Encoded: false };
+            }
+            if (method === 'Network.getResponseBody' && params?.requestId === 'req-fail') {
+                throw new Error('Body unavailable');
+            }
+            return {};
+        });
+        const monitor = new NetworkMonitor(session);
+        await monitor.enable();
+        emit('Network.requestWillBeSent', {
+            requestId: 'req-ok',
+            request: { url: 'https://vmoranv.github.io/jshookmcp/api/ok', method: 'GET', headers: {} },
+            timestamp: 1,
+            type: 'XHR',
+            initiator: {},
+        });
+        emit('Network.responseReceived', {
+            requestId: 'req-ok',
+            response: {
+                url: 'https://vmoranv.github.io/jshookmcp/api/ok',
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                mimeType: 'application/json',
+                fromDiskCache: false,
+                fromServiceWorker: false,
+                timing: {},
+            },
+            timestamp: 2,
+        });
+        emit('Network.requestWillBeSent', {
+            requestId: 'req-fail',
+            request: { url: 'https://vmoranv.github.io/jshookmcp/api/fail', method: 'GET', headers: {} },
+            timestamp: 3,
+            type: 'XHR',
+            initiator: {},
+        });
+        emit('Network.responseReceived', {
+            requestId: 'req-fail',
+            response: {
+                url: 'https://vmoranv.github.io/jshookmcp/api/fail',
+                status: 500,
+                statusText: 'FAIL',
+                headers: {},
+                mimeType: 'application/json',
+                fromDiskCache: false,
+                fromServiceWorker: false,
+                timing: {},
+            },
+            timestamp: 4,
+        });
+        await expect(monitor.getResponseBody('req-ok')).resolves.toEqual({
+            body: 'payload',
+            base64Encoded: false,
+        });
+        await expect(monitor.getResponseBody('req-fail')).resolves.toBeNull();
+    });
+    it('collects JavaScript responses and decodes base64 content', async () => {
+        const { session, send, emit } = createMockSession();
+        send.mockImplementation(async (method, params) => {
+            if (method === 'Network.enable')
+                return {};
+            if (method === 'Network.getResponseBody' && params?.requestId === 'js-a') {
+                return {
+                    body: Buffer.from('console.log("A")').toString('base64'),
+                    base64Encoded: true,
+                };
+            }
+            if (method === 'Network.getResponseBody' && params?.requestId === 'js-b') {
+                return {
+                    body: 'console.log("B")',
+                    base64Encoded: false,
+                };
+            }
+            return {};
+        });
+        const monitor = new NetworkMonitor(session);
+        await monitor.enable();
+        emit('Network.requestWillBeSent', {
+            requestId: 'js-a',
+            request: { url: 'https://vmoranv.github.io/jshookmcp/cdn/app.js', method: 'GET', headers: {} },
+            timestamp: 1,
+            type: 'Script',
+            initiator: {},
+        });
+        emit('Network.responseReceived', {
+            requestId: 'js-a',
+            response: {
+                url: 'https://vmoranv.github.io/jshookmcp/cdn/app.js',
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                mimeType: 'application/javascript',
+                fromDiskCache: false,
+                fromServiceWorker: false,
+                timing: {},
+            },
+            timestamp: 2,
+        });
+        emit('Network.requestWillBeSent', {
+            requestId: 'js-b',
+            request: { url: 'https://vmoranv.github.io/jshookmcp/cdn/chunk.js?v=1', method: 'GET', headers: {} },
+            timestamp: 3,
+            type: 'Script',
+            initiator: {},
+        });
+        emit('Network.responseReceived', {
+            requestId: 'js-b',
+            response: {
+                url: 'https://vmoranv.github.io/jshookmcp/cdn/chunk.js?v=1',
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                mimeType: 'text/plain',
+                fromDiskCache: false,
+                fromServiceWorker: false,
+                timing: {},
+            },
+            timestamp: 4,
+        });
+        const jsResponses = await monitor.getAllJavaScriptResponses();
+        expect(jsResponses).toHaveLength(2);
+        expect(jsResponses[0].content).toContain('console.log("A")');
+        expect(jsResponses[1].content).toContain('console.log("B")');
+    });
+    it('fetches JavaScript response bodies concurrently in batches', async () => {
+        const pendingResolvers = new Map();
+        const { session, send, emit } = createMockSession();
+        send.mockImplementation((method, params) => {
+            if (method === 'Network.enable')
+                return Promise.resolve({});
+            if (method === 'Network.getResponseBody' && params?.requestId) {
+                return new Promise((resolve) => {
+                    pendingResolvers.set(params.requestId, () => resolve({
+                        body: `console.log("${params.requestId}")`,
+                        base64Encoded: false,
+                    }));
+                });
+            }
+            return Promise.resolve({});
+        });
+        const monitor = new NetworkMonitor(session);
+        await monitor.enable();
+        for (const requestId of ['js-a', 'js-b']) {
+            emit('Network.requestWillBeSent', {
+                requestId,
+                request: { url: `https://vmoranv.github.io/jshookmcp/cdn/${requestId}.js`, method: 'GET', headers: {} },
+                timestamp: 1,
+                type: 'Script',
+                initiator: {},
+            });
+            emit('Network.responseReceived', {
+                requestId,
+                response: {
+                    url: `https://vmoranv.github.io/jshookmcp/cdn/${requestId}.js`,
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    mimeType: 'application/javascript',
+                    fromDiskCache: false,
+                    fromServiceWorker: false,
+                    timing: {},
+                },
+                timestamp: 2,
+            });
+        }
+        const responsesPromise = monitor.getAllJavaScriptResponses();
+        await Promise.resolve();
+        expect(send.mock.calls.filter(([method]) => method === 'Network.getResponseBody')).toHaveLength(2);
+        pendingResolvers.get('js-a')?.();
+        pendingResolvers.get('js-b')?.();
+        const responses = await responsesPromise;
+        expect(responses).toHaveLength(2);
+    });
+    it('clears and resets injected interceptor buffers with robust fallbacks', async () => {
+        const { session, send } = createMockSession();
+        send
+            .mockResolvedValueOnce({
+            result: {
+                value: {
+                    xhrCleared: 3,
+                    fetchCleared: 5,
+                },
+            },
+        })
+            .mockResolvedValueOnce({
+            result: {
+                value: {
+                    xhrReset: true,
+                    fetchReset: true,
+                },
+            },
+        });
+        const monitor = new NetworkMonitor(session);
+        const cleared = await monitor.clearInjectedBuffers();
+        const reset = await monitor.resetInjectedInterceptors();
+        expect(cleared).toEqual({ xhrCleared: 3, fetchCleared: 5 });
+        expect(reset).toEqual({ xhrReset: true, fetchReset: true });
+        send.mockRejectedValueOnce(new Error('runtime failed'));
+        send.mockRejectedValueOnce(new Error('runtime failed'));
+        await expect(monitor.clearInjectedBuffers()).resolves.toEqual({
+            xhrCleared: 0,
+            fetchCleared: 0,
+        });
+        await expect(monitor.resetInjectedInterceptors()).resolves.toEqual({
+            xhrReset: false,
+            fetchReset: false,
+        });
+    });
+});

package/dist/tests/modules/monitor/PerformanceMonitor.test.d.ts

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