@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/tests/modules/hook/HookManager.test.js

@@ -1,114 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const loggerState = vi.hoisted(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    success: vi.fn(),
-}));
-const hookGenState = vi.hoisted(() => ({
-    generateHookScript: vi.fn(() => '/*hook*/'),
-    getInjectionInstructions: vi.fn(() => 'inject'),
-    generateAntiDebugBypass: vi.fn(() => 'bypass-code'),
-    generateHookTemplate: vi.fn(() => 'template-code'),
-    generateHookChain: vi.fn(() => 'chain-code'),
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: loggerState,
-}));
-vi.mock('@src/modules/hook/HookGenerator', () => ({
-    generateHookScript: hookGenState.generateHookScript,
-    getInjectionInstructions: hookGenState.getInjectionInstructions,
-    generateAntiDebugBypass: hookGenState.generateAntiDebugBypass,
-    generateHookTemplate: hookGenState.generateHookTemplate,
-    generateHookChain: hookGenState.generateHookChain,
-}));
-import { HookManager } from '../../../src/modules/hook/HookManager.js';
-describe('HookManager', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        Object.values(loggerState).forEach((fn) => fn.mockReset?.());
-        Object.values(hookGenState).forEach((fn) => fn.mockReset?.());
-        hookGenState.generateHookScript.mockReturnValue('/*hook*/');
-        hookGenState.getInjectionInstructions.mockReturnValue('inject');
-        hookGenState.generateAntiDebugBypass.mockReturnValue('bypass-code');
-        hookGenState.generateHookTemplate.mockReturnValue('template-code');
-        hookGenState.generateHookChain.mockReturnValue('chain-code');
-    });
-    it('creates hook script and metadata entries', async () => {
-        const manager = new HookManager();
-        const result = await manager.createHook({
-            target: 'window.fetch',
-            type: 'function',
-            action: 'log',
-            condition: { maxCalls: 5 },
-        });
-        expect(result.script).toBe('/*hook*/');
-        expect(result.instructions).toBe('inject');
-        expect(manager.getAllHooks()).toContain(result.hookId);
-        expect(manager.getHookMetadata(result.hookId)?.enabled).toBe(true);
-    });
-    it('records hook events and supports clear operations', async () => {
-        const manager = new HookManager();
-        const { hookId } = await manager.createHook({ target: 'x', type: 'function' });
-        manager.recordHookEvent(hookId, { args: [1] });
-        manager.recordHookEvent(hookId, { args: [2] });
-        expect(manager.getHookRecords(hookId)).toHaveLength(2);
-        manager.clearHookRecords(hookId);
-        expect(manager.getHookRecords(hookId)).toHaveLength(0);
-    });
-    it('toggles hook enabled state and exposes stats', async () => {
-        const manager = new HookManager();
-        const { hookId } = await manager.createHook({ target: 'x', type: 'function' });
-        manager.disableHook(hookId);
-        expect(manager.getHookStats(hookId)?.enabled).toBe(false);
-        manager.enableHook(hookId);
-        expect(manager.getHookStats(hookId)?.enabled).toBe(true);
-    });
-    it('exports single/all hook payloads', async () => {
-        const manager = new HookManager();
-        const a = await manager.createHook({ target: 'a', type: 'function' });
-        const b = await manager.createHook({ target: 'b', type: 'function' });
-        manager.recordHookEvent(a.hookId, { foo: 1 });
-        const single = manager.exportHookData(a.hookId);
-        const all = manager.exportHookData();
-        expect(single.metadata).toHaveLength(1);
-        expect(single.records[a.hookId]).toHaveLength(1);
-        expect(Object.keys(all.scripts)).toEqual(expect.arrayContaining([a.hookId, b.hookId]));
-    });
-    it('enforces record limits and performs oldest-record cleanup', async () => {
-        const manager = new HookManager();
-        manager.MAX_HOOK_RECORDS = 2;
-        manager.MAX_TOTAL_RECORDS = 3;
-        const h1 = await manager.createHook({ target: 'h1', type: 'function' });
-        const h2 = await manager.createHook({ target: 'h2', type: 'function' });
-        manager.recordHookCall(h1.hookId, { hookId: h1.hookId, timestamp: 1, context: {} });
-        manager.recordHookCall(h1.hookId, { hookId: h1.hookId, timestamp: 2, context: {} });
-        manager.recordHookCall(h1.hookId, { hookId: h1.hookId, timestamp: 3, context: {} });
-        manager.recordHookCall(h2.hookId, { hookId: h2.hookId, timestamp: 4, context: {} });
-        expect(manager.getHookRecords(h1.hookId).length).toBeLessThanOrEqual(2);
-        const stats = manager.getHookRecordsStats();
-        expect(stats.totalRecords).toBeLessThanOrEqual(3);
-    });
-    it('continues batch hook creation when one target fails', async () => {
-        const manager = new HookManager();
-        const createSpy = vi.spyOn(manager, 'createHook');
-        createSpy
-            .mockResolvedValueOnce({ hookId: 'ok-1', script: 's1', instructions: 'i1' })
-            .mockRejectedValueOnce(new Error('boom'))
-            .mockResolvedValueOnce({ hookId: 'ok-2', script: 's2', instructions: 'i2' });
-        const results = await manager.createBatchHooks([
-            { target: 'a', type: 'function' },
-            { target: 'b', type: 'function' },
-            { target: 'c', type: 'function' },
-        ]);
-        expect(results).toHaveLength(2);
-        expect(results.map((r) => r.hookId)).toEqual(['ok-1', 'ok-2']);
-    });
-    it('delegates helper generation methods to HookGenerator functions', () => {
-        const manager = new HookManager();
-        expect(manager.generateAntiDebugBypass()).toBe('bypass-code');
-        expect(manager.generateHookTemplate('x', 'function')).toBe('template-code');
-        expect(manager.generateHookChain([])).toBe('chain-code');
-    });
-});

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.class.additional.test.d.ts

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

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.class.additional.test.js

@@ -1,463 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const classState = vi.hoisted(() => ({
-    logger: {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-    },
-    networkInstances: [],
-    playwrightInstances: [],
-}));
-vi.mock('@utils/logger', () => ({
-    logger: classState.logger,
-}));
-vi.mock('@modules/monitor/NetworkMonitor', () => {
-    class NetworkMonitor {
-        enable = vi.fn(async () => { });
-        disable = vi.fn(async () => { });
-        isEnabled = vi.fn(() => true);
-        getStatus = vi.fn(() => ({
-            enabled: true,
-            requestCount: 0,
-            responseCount: 0,
-            listenerCount: 0,
-            cdpSessionActive: true,
-        }));
-        getRequests = vi.fn(() => []);
-        getResponses = vi.fn(() => []);
-        getActivity = vi.fn(() => ({}));
-        getResponseBody = vi.fn(async () => null);
-        getAllJavaScriptResponses = vi.fn(async () => []);
-        clearRecords = vi.fn();
-        clearInjectedBuffers = vi.fn(async () => ({ xhrCleared: 0, fetchCleared: 0 }));
-        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 () => []);
-        constructor(_session) {
-            classState.networkInstances.push(this);
-        }
-    }
-    return { NetworkMonitor };
-});
-vi.mock('@modules/monitor/PlaywrightNetworkMonitor', () => {
-    class PlaywrightNetworkMonitor {
-        enable = vi.fn(async () => { });
-        disable = vi.fn(async () => { });
-        isEnabled = vi.fn(() => true);
-        setPage = vi.fn();
-        constructor(_page) {
-            classState.playwrightInstances.push(this);
-        }
-    }
-    return { PlaywrightNetworkMonitor };
-});
-import { ConsoleMonitor } from '../../../src/modules/monitor/ConsoleMonitor.impl.core.class.js';
-function createCdpSession() {
-    const listeners = new Map();
-    const session = {
-        send: vi.fn(async (_method) => ({})),
-        on: vi.fn((event, handler) => {
-            const handlers = listeners.get(event) ?? new Set();
-            handlers.add(handler);
-            listeners.set(event, handlers);
-        }),
-        off: vi.fn((event, handler) => {
-            listeners.get(event)?.delete(handler);
-        }),
-        detach: vi.fn().mockResolvedValue(undefined),
-        emit(event, payload) {
-            listeners.get(event)?.forEach((handler) => handler(payload));
-        },
-    };
-    return session;
-}
-function createCollectorMock(session) {
-    return {
-        getActivePage: vi.fn().mockResolvedValue({
-            createCDPSession: vi.fn().mockResolvedValue(session),
-        }),
-    };
-}
-describe('ConsoleMonitor.impl.core.class – additional coverage', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        classState.networkInstances.length = 0;
-        classState.playwrightInstances.length = 0;
-    });
-    describe('console message formatting', () => {
-        it('formats object with description but no value', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            session.emit('Runtime.consoleAPICalled', {
-                type: 'log',
-                args: [{ type: 'object', description: 'HTMLDivElement' }],
-                timestamp: 100,
-            });
-            const logs = monitor.getLogs();
-            expect(logs[0]?.text).toBe('HTMLDivElement');
-        });
-        it('formats undefined type', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            session.emit('Runtime.consoleAPICalled', {
-                type: 'log',
-                args: [{ type: 'undefined' }],
-                timestamp: 100,
-            });
-            const logs = monitor.getLogs();
-            expect(logs[0]?.text).toBe('undefined');
-        });
-        it('formats null object', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            session.emit('Runtime.consoleAPICalled', {
-                type: 'log',
-                args: [{ type: 'object', subtype: 'null' }],
-                timestamp: 100,
-            });
-            const logs = monitor.getLogs();
-            expect(logs[0]?.text).toBe('null');
-        });
-        it('formats unknown type as [type]', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            session.emit('Runtime.consoleAPICalled', {
-                type: 'log',
-                args: [{ type: 'symbol' }],
-                timestamp: 100,
-            });
-            const logs = monitor.getLogs();
-            expect(logs[0]?.text).toBe('[symbol]');
-        });
-        it('extracts objectId into a structured value', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            session.emit('Runtime.consoleAPICalled', {
-                type: 'log',
-                args: [{ type: 'object', objectId: 'obj-123', description: 'Array(3)' }],
-                timestamp: 100,
-            });
-            const logs = monitor.getLogs();
-            expect(logs[0]?.args?.[0]).toMatchObject({
-                __objectId: 'obj-123',
-                __type: 'object',
-                __description: 'Array(3)',
-            });
-        });
-        it('joins multiple args with space', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            session.emit('Runtime.consoleAPICalled', {
-                type: 'log',
-                args: [{ value: 'hello' }, { value: 'world' }],
-                timestamp: 200,
-            });
-            const logs = monitor.getLogs();
-            expect(logs[0]?.text).toBe('hello world');
-        });
-    });
-    describe('Console.messageAdded', () => {
-        it('captures legacy console messages', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            session.emit('Console.messageAdded', {
-                message: {
-                    level: 'warning',
-                    text: 'deprecated API',
-                    url: 'https://site/old.js',
-                    line: 42,
-                    column: 10,
-                },
-            });
-            const logs = monitor.getLogs();
-            expect(logs[0]).toMatchObject({
-                type: 'warning',
-                text: 'deprecated API',
-                url: 'https://site/old.js',
-                lineNumber: 42,
-                columnNumber: 10,
-            });
-        });
-        it('uses log type when level is not provided', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            session.emit('Console.messageAdded', {
-                message: { text: 'no level message' },
-            });
-            const logs = monitor.getLogs();
-            expect(logs[0]?.type).toBe('log');
-        });
-    });
-    describe('buffer trimming', () => {
-        it('trims messages when exceeding MAX_MESSAGES', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            const MAX = monitor.MAX_MESSAGES;
-            for (let i = 0; i <= MAX; i++) {
-                session.emit('Runtime.consoleAPICalled', {
-                    type: 'log',
-                    args: [{ value: `msg-${i}` }],
-                    timestamp: i,
-                });
-            }
-            const logs = monitor.getLogs();
-            expect(logs.length).toBeLessThanOrEqual(MAX);
-            expect(logs.length).toBeGreaterThan(0);
-        });
-        it('trims exceptions when exceeding MAX_EXCEPTIONS', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable({ enableExceptions: true });
-            const MAX = monitor.MAX_EXCEPTIONS;
-            for (let i = 0; i <= MAX; i++) {
-                session.emit('Runtime.exceptionThrown', {
-                    exceptionDetails: {
-                        text: `err-${i}`,
-                        exceptionId: i,
-                    },
-                });
-            }
-            const exceptions = monitor.getExceptions();
-            expect(exceptions.length).toBeLessThanOrEqual(MAX);
-            expect(exceptions.length).toBeGreaterThan(0);
-        });
-    });
-    describe('getLogs filtering', () => {
-        it('filters by since timestamp', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            session.emit('Runtime.consoleAPICalled', {
-                type: 'log',
-                args: [{ value: 'old' }],
-                timestamp: 100,
-            });
-            session.emit('Runtime.consoleAPICalled', {
-                type: 'log',
-                args: [{ value: 'new' }],
-                timestamp: 200,
-            });
-            const logs = monitor.getLogs({ since: 150 });
-            expect(logs).toHaveLength(1);
-            expect(logs[0]?.text).toBe('new');
-        });
-        it('applies limit to returned logs', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            for (let i = 0; i < 10; i++) {
-                session.emit('Runtime.consoleAPICalled', {
-                    type: 'log',
-                    args: [{ value: `msg-${i}` }],
-                    timestamp: i,
-                });
-            }
-            const logs = monitor.getLogs({ limit: 3 });
-            expect(logs).toHaveLength(3);
-        });
-    });
-    describe('getStats', () => {
-        it('returns counts by type', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            session.emit('Runtime.consoleAPICalled', { type: 'log', args: [{ value: 'a' }], timestamp: 1 });
-            session.emit('Runtime.consoleAPICalled', { type: 'warn', args: [{ value: 'b' }], timestamp: 2 });
-            session.emit('Runtime.consoleAPICalled', { type: 'log', args: [{ value: 'c' }], timestamp: 3 });
-            const stats = monitor.getStats();
-            expect(stats.totalMessages).toBe(3);
-            expect(stats.byType.log).toBe(2);
-            expect(stats.byType.warn).toBe(1);
-        });
-    });
-    describe('clear methods', () => {
-        it('clearLogs empties message buffer', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            session.emit('Runtime.consoleAPICalled', { type: 'log', args: [{ value: 'x' }], timestamp: 1 });
-            monitor.clearLogs();
-            expect(monitor.getLogs()).toHaveLength(0);
-        });
-        it('clearExceptions empties exception buffer', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable({ enableExceptions: true });
-            session.emit('Runtime.exceptionThrown', {
-                exceptionDetails: { text: 'err', exceptionId: 1 },
-            });
-            monitor.clearExceptions();
-            expect(monitor.getExceptions()).toHaveLength(0);
-        });
-    });
-    describe('session state', () => {
-        it('isSessionActive returns true after enable', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            expect(monitor.isSessionActive()).toBe(false);
-            await monitor.enable();
-            expect(monitor.isSessionActive()).toBe(true);
-        });
-        it('ensureSession re-enables when session is lost', async () => {
-            const session = createCdpSession();
-            const collectorMock = createCollectorMock(session);
-            const monitor = new ConsoleMonitor(collectorMock);
-            await monitor.enable();
-            session.emit('disconnected');
-            expect(monitor.isSessionActive()).toBe(false);
-            await monitor.ensureSession();
-            expect(monitor.isSessionActive()).toBe(true);
-        });
-    });
-    describe('execute', () => {
-        it('evaluates a Runtime.evaluate expression and returns the value', async () => {
-            const session = createCdpSession();
-            session.send.mockResolvedValue({ result: { value: 42 } });
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            const result = await monitor.execute('2 + 2');
-            expect(result).toBe(42);
-        });
-        it('throws when Runtime.evaluate returns exceptionDetails', async () => {
-            const session = createCdpSession();
-            session.send.mockImplementation(async (method) => {
-                if (method === 'Runtime.evaluate') {
-                    return { result: {}, exceptionDetails: { text: 'SyntaxError: unexpected' } };
-                }
-                return {};
-            });
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            await expect(monitor.execute('bad!code')).rejects.toThrow('SyntaxError: unexpected');
-        });
-    });
-    describe('disable', () => {
-        it('detaches CDP session and disables network monitor', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable({ enableNetwork: true });
-            await monitor.disable();
-            expect(session.send).toHaveBeenCalledWith('Console.disable');
-            expect(session.send).toHaveBeenCalledWith('Runtime.disable');
-            expect(session.detach).toHaveBeenCalled();
-            expect(classState.networkInstances[0]?.disable).toHaveBeenCalled();
-        });
-        it('handles errors gracefully during disable', async () => {
-            const session = createCdpSession();
-            session.send.mockImplementation(async (method) => {
-                if (method === 'Console.disable' || method === 'Runtime.disable') {
-                    throw new Error('already detached');
-                }
-                return {};
-            });
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            await expect(monitor.disable()).resolves.toBeUndefined();
-        });
-    });
-    describe('close', () => {
-        it('calls disable and clears object cache', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable();
-            await monitor.close();
-            expect(monitor.isSessionActive()).toBe(false);
-        });
-    });
-    describe('getExceptions filtering', () => {
-        it('filters by url', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable({ enableExceptions: true });
-            session.emit('Runtime.exceptionThrown', {
-                exceptionDetails: {
-                    text: 'err1',
-                    exceptionId: 1,
-                    url: 'https://site/a.js',
-                },
-            });
-            session.emit('Runtime.exceptionThrown', {
-                exceptionDetails: {
-                    text: 'err2',
-                    exceptionId: 2,
-                    url: 'https://site/b.js',
-                },
-            });
-            const filtered = monitor.getExceptions({ url: 'a.js' });
-            expect(filtered).toHaveLength(1);
-            expect(filtered[0]?.text).toBe('err1');
-        });
-    });
-    describe('enableExceptions: false', () => {
-        it('does not capture exceptions when disabled', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable({ enableExceptions: false });
-            session.emit('Runtime.exceptionThrown', {
-                exceptionDetails: { text: 'ignored', exceptionId: 1 },
-            });
-            expect(monitor.getExceptions()).toHaveLength(0);
-        });
-    });
-    describe('Playwright mode', () => {
-        it('setPlaywrightPage / clearPlaywrightPage lifecycle', () => {
-            const monitor = new ConsoleMonitor({ getActivePage: vi.fn() });
-            const page = { on: vi.fn(), off: vi.fn() };
-            monitor.setPlaywrightPage(page);
-            expect(monitor.isSessionActive()).toBe(true);
-            monitor.clearPlaywrightPage();
-            expect(monitor.isSessionActive()).toBe(false);
-        });
-        it('adds network monitoring to existing Playwright session via applyPostEnableOptions', async () => {
-            const handlers = {};
-            const page = {
-                on: vi.fn((event, handler) => {
-                    handlers[event] = handler;
-                }),
-                off: vi.fn(),
-            };
-            const monitor = new ConsoleMonitor({ getActivePage: vi.fn() });
-            monitor.setPlaywrightPage(page);
-            await monitor.enable();
-            expect(classState.playwrightInstances).toHaveLength(0);
-            await monitor.enable({ enableNetwork: true });
-            expect(classState.playwrightInstances).toHaveLength(1);
-            expect(classState.playwrightInstances[0]?.enable).toHaveBeenCalled();
-        });
-    });
-    describe('exception description fallback', () => {
-        it('uses exception.description when available', async () => {
-            const session = createCdpSession();
-            const monitor = new ConsoleMonitor(createCollectorMock(session));
-            await monitor.enable({ enableExceptions: true });
-            session.emit('Runtime.exceptionThrown', {
-                exceptionDetails: {
-                    text: 'fallback text',
-                    exceptionId: 1,
-                    exception: { description: 'TypeError: x is not a function' },
-                },
-            });
-            const exceptions = monitor.getExceptions();
-            expect(exceptions[0]?.text).toBe('TypeError: x is not a function');
-        });
-    });
-});

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.class.test.d.ts

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