@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/domains/streaming/streaming-sse-additional.test.js

@@ -0,0 +1,375 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { StreamingToolHandlersSse } from '../../../../src/server/domains/streaming/handlers.impl.streaming-sse.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+function createMocks() {
+    const session = {
+        send: vi.fn().mockResolvedValue(undefined),
+        on: vi.fn(),
+        off: vi.fn(),
+        detach: vi.fn().mockResolvedValue(undefined),
+    };
+    const page = {
+        createCDPSession: vi.fn(async () => session),
+        evaluate: vi.fn(),
+    };
+    const collector = {
+        getActivePage: vi.fn(async () => page),
+    };
+    return { session, page, collector };
+}
+describe('StreamingToolHandlersSse — additional coverage', () => {
+    let handler;
+    let mocks;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mocks = createMocks();
+        handler = new StreamingToolHandlersSse(mocks.collector);
+    });
+    describe('enableSseInterceptor — evaluate callback returns', () => {
+        it('returns success:false when EventSource is unavailable', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: false,
+                error: 'EventSource is not available in current page context',
+            });
+            const body = parseJson(await handler.handleSseMonitorEnable({}));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('EventSource');
+        });
+        it('preserves existing events count from interceptor', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                maxEvents: 2000,
+                existingEvents: 150,
+            });
+            const body = parseJson(await handler.handleSseMonitorEnable({}));
+            expect(body.success).toBe(true);
+            expect(body.existingEvents).toBe(150);
+        });
+        it('handles patched=false on first enable', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: false,
+                maxEvents: 2000,
+                existingEvents: 0,
+            });
+            const body = parseJson(await handler.handleSseMonitorEnable({}));
+            expect(body.success).toBe(true);
+            expect(body.patched).toBe(false);
+        });
+        it('forwards urlFilter in interceptor result', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                urlFilter: '/api/.*',
+                maxEvents: 2000,
+                existingEvents: 0,
+            });
+            const body = parseJson(await handler.handleSseMonitorEnable({ urlFilter: '/api/.*' }));
+            expect(body.success).toBe(true);
+            expect(body.config.urlFilter).toBe('/api/.*');
+        });
+        it('does not update sseConfig when interceptor returns success:false', async () => {
+            mocks.page.evaluate.mockResolvedValueOnce({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                maxEvents: 500,
+                existingEvents: 0,
+            });
+            const first = parseJson(await handler.handleSseMonitorEnable({ maxEvents: 500 }));
+            expect(first.config.maxEvents).toBe(500);
+            mocks.page.evaluate.mockResolvedValueOnce({
+                success: false,
+                error: 'EventSource is not available in current page context',
+            });
+            const second = parseJson(await handler.handleSseMonitorEnable({ maxEvents: 999 }));
+            expect(second.success).toBe(false);
+        });
+    });
+    describe('handleSseMonitorEnable — argument edge cases', () => {
+        it('handles non-finite maxEvents by using default', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                maxEvents: 2000,
+                existingEvents: 0,
+            });
+            const body = parseJson(await handler.handleSseMonitorEnable({ maxEvents: Infinity }));
+            expect(body.success).toBe(true);
+            expect(body.config.maxEvents).toBe(2000);
+        });
+        it('handles NaN maxEvents by using default', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                maxEvents: 2000,
+                existingEvents: 0,
+            });
+            const body = parseJson(await handler.handleSseMonitorEnable({ maxEvents: NaN }));
+            expect(body.success).toBe(true);
+            expect(body.config.maxEvents).toBe(2000);
+        });
+        it('handles null urlFilter (not string)', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                maxEvents: 2000,
+                existingEvents: 0,
+            });
+            const body = parseJson(await handler.handleSseMonitorEnable({ urlFilter: null }));
+            expect(body.success).toBe(true);
+            expect(body.config.urlFilter).toBeNull();
+        });
+        it('handles numeric urlFilter (not string)', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                maxEvents: 2000,
+                existingEvents: 0,
+            });
+            const body = parseJson(await handler.handleSseMonitorEnable({ urlFilter: 12345 }));
+            expect(body.success).toBe(true);
+            expect(body.config.urlFilter).toBeNull();
+        });
+        it('handles boolean maxEvents (falls back to default)', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                maxEvents: 2000,
+                existingEvents: 0,
+            });
+            const body = parseJson(await handler.handleSseMonitorEnable({ maxEvents: true }));
+            expect(body.success).toBe(true);
+            expect(body.config.maxEvents).toBe(2000);
+        });
+        it('handles object maxEvents (falls back to default)', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                maxEvents: 2000,
+                existingEvents: 0,
+            });
+            const body = parseJson(await handler.handleSseMonitorEnable({ maxEvents: {} }));
+            expect(body.success).toBe(true);
+            expect(body.config.maxEvents).toBe(2000);
+        });
+    });
+    describe('handleSseGetEvents — additional edge cases', () => {
+        it('handles whitespace-only sourceUrl by treating as undefined', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                filters: { sourceUrl: null, eventType: null },
+                page: {
+                    offset: 0, limit: 100, returned: 0,
+                    totalAfterFilter: 0, hasMore: false, nextOffset: null,
+                },
+                monitor: {
+                    enabled: true, patched: true, maxEvents: 2000,
+                    urlFilter: null, sourceCount: 0,
+                },
+                events: [],
+            });
+            await handler.handleSseGetEvents({ sourceUrl: '   ' });
+            const evaluateArgs = mocks.page.evaluate.mock.calls[0][1];
+            expect(evaluateArgs.sourceUrl).toBeUndefined();
+        });
+        it('handles whitespace-only eventType by treating as undefined', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                filters: { sourceUrl: null, eventType: null },
+                page: {
+                    offset: 0, limit: 100, returned: 0,
+                    totalAfterFilter: 0, hasMore: false, nextOffset: null,
+                },
+                monitor: {
+                    enabled: true, patched: true, maxEvents: 2000,
+                    urlFilter: null, sourceCount: 0,
+                },
+                events: [],
+            });
+            await handler.handleSseGetEvents({ eventType: '   ' });
+            const evaluateArgs = mocks.page.evaluate.mock.calls[0][1];
+            expect(evaluateArgs.eventType).toBeUndefined();
+        });
+        it('handles boolean sourceUrl by treating as undefined', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                filters: { sourceUrl: null, eventType: null },
+                page: {
+                    offset: 0, limit: 100, returned: 0,
+                    totalAfterFilter: 0, hasMore: false, nextOffset: null,
+                },
+                monitor: {
+                    enabled: true, patched: true, maxEvents: 2000,
+                    urlFilter: null, sourceCount: 0,
+                },
+                events: [],
+            });
+            await handler.handleSseGetEvents({ sourceUrl: true });
+            const evaluateArgs = mocks.page.evaluate.mock.calls[0][1];
+            expect(evaluateArgs.sourceUrl).toBeUndefined();
+        });
+        it('handles Infinity limit by clamping to max 5000', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                filters: { sourceUrl: null, eventType: null },
+                page: {
+                    offset: 0, limit: 5000, returned: 0,
+                    totalAfterFilter: 0, hasMore: false, nextOffset: null,
+                },
+                monitor: {
+                    enabled: true, patched: true, maxEvents: 2000,
+                    urlFilter: null, sourceCount: 0,
+                },
+                events: [],
+            });
+            await handler.handleSseGetEvents({ limit: Infinity });
+            const evaluateArgs = mocks.page.evaluate.mock.calls[0][1];
+            expect(evaluateArgs.limit).toBe(100);
+        });
+        it('passes all four arguments to page.evaluate', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                filters: { sourceUrl: 'http://a.com', eventType: 'data' },
+                page: {
+                    offset: 5, limit: 50, returned: 0,
+                    totalAfterFilter: 0, hasMore: false, nextOffset: null,
+                },
+                monitor: {
+                    enabled: true, patched: true, maxEvents: 2000,
+                    urlFilter: null, sourceCount: 0,
+                },
+                events: [],
+            });
+            await handler.handleSseGetEvents({
+                sourceUrl: 'http://a.com',
+                eventType: 'data',
+                limit: 50,
+                offset: 5,
+            });
+            const evaluateArgs = mocks.page.evaluate.mock.calls[0][1];
+            expect(evaluateArgs).toEqual({
+                sourceUrl: 'http://a.com',
+                eventType: 'data',
+                limit: 50,
+                offset: 5,
+            });
+        });
+        it('handles monitor state with multiple sources', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                filters: { sourceUrl: null, eventType: null },
+                page: {
+                    offset: 0, limit: 100, returned: 3,
+                    totalAfterFilter: 3, hasMore: false, nextOffset: null,
+                },
+                monitor: {
+                    enabled: true, patched: true, maxEvents: 2000,
+                    urlFilter: null, sourceCount: 3,
+                },
+                events: [
+                    { sourceUrl: 'http://a.com/sse', eventType: 'message', dataPreview: 'a', dataLength: 1, lastEventId: null, timestamp: 1000 },
+                    { sourceUrl: 'http://b.com/sse', eventType: 'update', dataPreview: 'b', dataLength: 1, lastEventId: '2', timestamp: 2000 },
+                    { sourceUrl: 'http://c.com/sse', eventType: 'open', dataPreview: '', dataLength: 0, lastEventId: null, timestamp: 3000 },
+                ],
+            });
+            const body = parseJson(await handler.handleSseGetEvents({}));
+            expect(body.events).toHaveLength(3);
+            expect(body.monitor.sourceCount).toBe(3);
+            expect(body.events[1].lastEventId).toBe('2');
+        });
+    });
+    describe('handleSseMonitorEnable — sequential enables', () => {
+        it('can enable, then re-enable with different config', async () => {
+            mocks.page.evaluate.mockResolvedValueOnce({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                maxEvents: 100,
+                existingEvents: 0,
+            });
+            const first = parseJson(await handler.handleSseMonitorEnable({ maxEvents: 100 }));
+            expect(first.config.maxEvents).toBe(100);
+            mocks.page.evaluate.mockResolvedValueOnce({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                maxEvents: 5000,
+                existingEvents: 10,
+            });
+            const second = parseJson(await handler.handleSseMonitorEnable({ maxEvents: 5000, urlFilter: '/events/.*' }));
+            expect(second.config.maxEvents).toBe(5000);
+            expect(second.config.urlFilter).toBe('/events/.*');
+            expect(second.existingEvents).toBe(10);
+        });
+        it('page.evaluate receives the function as first arg and config as second', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                maxEvents: 2000,
+                existingEvents: 0,
+            });
+            await handler.handleSseMonitorEnable({});
+            expect(mocks.page.evaluate).toHaveBeenCalledOnce();
+            const call = mocks.page.evaluate.mock.calls[0];
+            expect(typeof call[0]).toBe('function');
+            expect(call[1]).toEqual({ maxEvents: 2000, urlFilterRaw: undefined });
+        });
+    });
+    describe('handleSseGetEvents — response shape', () => {
+        it('returns proper TextToolResponse shape', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                filters: { sourceUrl: null, eventType: null },
+                page: {
+                    offset: 0, limit: 100, returned: 0,
+                    totalAfterFilter: 0, hasMore: false, nextOffset: null,
+                },
+                monitor: {
+                    enabled: true, patched: true, maxEvents: 2000,
+                    urlFilter: null, sourceCount: 0,
+                },
+                events: [],
+            });
+            const response = await handler.handleSseGetEvents({});
+            expect(response.content).toHaveLength(1);
+            expect(response.content[0].type).toBe('text');
+            expect(typeof response.content[0].text).toBe('string');
+            expect(() => JSON.parse(response.content[0].text)).not.toThrow();
+        });
+        it('returns monitor info block in getEvents response', async () => {
+            mocks.page.evaluate.mockResolvedValue({
+                success: true,
+                filters: { sourceUrl: null, eventType: null },
+                page: {
+                    offset: 0, limit: 100, returned: 0,
+                    totalAfterFilter: 0, hasMore: false, nextOffset: null,
+                },
+                monitor: {
+                    enabled: true, patched: true, maxEvents: 5000,
+                    urlFilter: '/stream', sourceCount: 2,
+                },
+                events: [],
+            });
+            const body = parseJson(await handler.handleSseGetEvents({}));
+            expect(body.monitor.enabled).toBe(true);
+            expect(body.monitor.patched).toBe(true);
+            expect(body.monitor.maxEvents).toBe(5000);
+            expect(body.monitor.urlFilter).toBe('/stream');
+            expect(body.monitor.sourceCount).toBe(2);
+        });
+    });
+});

package/dist/tests/server/domains/streaming/streaming-sse-handlers.test.d.ts

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

package/dist/tests/server/domains/streaming/streaming-sse-handlers.test.js

@@ -0,0 +1,203 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('@server/domains/shared/modules', () => ({
+    CodeCollector: vi.fn(),
+    CodeAnalyzer: vi.fn(),
+    CamoufoxBrowserManager: vi.fn(),
+    AICaptchaDetector: vi.fn(),
+    DOMInspector: vi.fn(),
+    PageController: vi.fn(),
+    CryptoDetector: vi.fn(),
+    ASTOptimizer: vi.fn(),
+    AdvancedDeobfuscator: vi.fn(),
+    Deobfuscator: vi.fn(),
+    ObfuscationDetector: vi.fn(),
+    DebuggerManager: vi.fn(),
+    RuntimeInspector: vi.fn(),
+    ScriptManager: vi.fn(),
+    BlackboxManager: vi.fn(),
+    ExternalToolRunner: vi.fn(),
+    ToolRegistry: vi.fn(),
+    AIHookGenerator: vi.fn(),
+    HookManager: vi.fn(),
+    ConsoleMonitor: vi.fn(),
+    PerformanceMonitor: vi.fn(),
+    MemoryManager: vi.fn(),
+    UnifiedProcessManager: vi.fn(),
+    StealthScripts: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+}));
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('StreamingToolHandlersSse', () => {
+    let StreamingToolHandlersSse;
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        const mod = await import('../../../../src/server/domains/streaming/handlers.impl.streaming-sse.js');
+        StreamingToolHandlersSse = mod.StreamingToolHandlersSse;
+    });
+    function createHandler(pageOverrides = {}) {
+        const mockPage = {
+            evaluate: vi.fn().mockResolvedValue({
+                success: true,
+                message: 'SSE monitor enabled',
+                patched: true,
+                urlFilter: undefined,
+                maxEvents: 2000,
+                existingEvents: 0,
+            }),
+            ...pageOverrides,
+        };
+        const collector = {
+            getActivePage: vi.fn().mockResolvedValue(mockPage),
+        };
+        return { handler: new StreamingToolHandlersSse(collector), mockPage, collector };
+    }
+    describe('handleSseMonitorEnable', () => {
+        it('enables SSE monitor with default args', async () => {
+            const { handler } = createHandler();
+            const result = await handler.handleSseMonitorEnable({});
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.config.maxEvents).toBe(2000);
+            expect(body.config.urlFilter).toBeNull();
+        });
+        it('enables with custom maxEvents', async () => {
+            const { handler } = createHandler();
+            const result = await handler.handleSseMonitorEnable({ maxEvents: 500 });
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.config.maxEvents).toBe(500);
+        });
+        it('enables with urlFilter', async () => {
+            const { handler } = createHandler();
+            const result = await handler.handleSseMonitorEnable({ urlFilter: 'api\\.example\\.com' });
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.config.urlFilter).toBe('api\\.example\\.com');
+        });
+        it('rejects invalid urlFilter regex', async () => {
+            const { handler } = createHandler();
+            const result = await handler.handleSseMonitorEnable({ urlFilter: '[invalid' });
+            const body = parseJson(result);
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('Invalid urlFilter regex');
+        });
+        it('handles enableSseInterceptor failure', async () => {
+            const { handler } = createHandler({
+                evaluate: vi.fn().mockResolvedValue({
+                    success: false,
+                    error: 'EventSource is not available in current page context',
+                }),
+            });
+            const result = await handler.handleSseMonitorEnable({});
+            const body = parseJson(result);
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('EventSource');
+        });
+        it('clamps maxEvents to min=1', async () => {
+            const { handler, mockPage } = createHandler();
+            await handler.handleSseMonitorEnable({ maxEvents: -10 });
+            expect(mockPage.evaluate).toHaveBeenCalled();
+        });
+        it('clamps maxEvents to max=50000', async () => {
+            const { handler, mockPage } = createHandler();
+            await handler.handleSseMonitorEnable({ maxEvents: 100000 });
+            expect(mockPage.evaluate).toHaveBeenCalled();
+        });
+    });
+    describe('handleSseGetEvents', () => {
+        it('retrieves events with default args', async () => {
+            const { handler } = createHandler({
+                evaluate: vi.fn().mockResolvedValue({
+                    success: true,
+                    filters: { sourceUrl: null, eventType: null },
+                    page: { offset: 0, limit: 100, returned: 2, totalAfterFilter: 2, hasMore: false, nextOffset: null },
+                    monitor: { enabled: true, patched: true, maxEvents: 2000, urlFilter: null, sourceCount: 1 },
+                    events: [
+                        { sourceUrl: 'http://api.test/stream', eventType: 'message', dataPreview: 'hello', dataLength: 5, lastEventId: null, timestamp: 1000 },
+                        { sourceUrl: 'http://api.test/stream', eventType: 'message', dataPreview: 'world', dataLength: 5, lastEventId: '1', timestamp: 1001 },
+                    ],
+                }),
+            });
+            const result = await handler.handleSseGetEvents({});
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.events).toHaveLength(2);
+            expect(body.page.returned).toBe(2);
+        });
+        it('filters by sourceUrl', async () => {
+            const { handler } = createHandler({
+                evaluate: vi.fn().mockResolvedValue({
+                    success: true,
+                    filters: { sourceUrl: 'http://api.test', eventType: null },
+                    page: { offset: 0, limit: 100, returned: 1, totalAfterFilter: 1, hasMore: false, nextOffset: null },
+                    monitor: { enabled: true, patched: true, maxEvents: 2000, urlFilter: null, sourceCount: 1 },
+                    events: [{ sourceUrl: 'http://api.test', eventType: 'message', dataPreview: 'data', dataLength: 4, lastEventId: null, timestamp: 1000 }],
+                }),
+            });
+            const result = await handler.handleSseGetEvents({ sourceUrl: 'http://api.test' });
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.filters.sourceUrl).toBe('http://api.test');
+        });
+        it('filters by eventType', async () => {
+            const { handler } = createHandler({
+                evaluate: vi.fn().mockResolvedValue({
+                    success: true,
+                    filters: { sourceUrl: null, eventType: 'error' },
+                    page: { offset: 0, limit: 100, returned: 0, totalAfterFilter: 0, hasMore: false, nextOffset: null },
+                    monitor: { enabled: true, patched: true, maxEvents: 2000, urlFilter: null, sourceCount: 0 },
+                    events: [],
+                }),
+            });
+            const result = await handler.handleSseGetEvents({ eventType: 'error' });
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.filters.eventType).toBe('error');
+        });
+        it('supports pagination with limit and offset', async () => {
+            const { handler } = createHandler({
+                evaluate: vi.fn().mockResolvedValue({
+                    success: true,
+                    filters: { sourceUrl: null, eventType: null },
+                    page: { offset: 10, limit: 5, returned: 5, totalAfterFilter: 20, hasMore: true, nextOffset: 15 },
+                    monitor: { enabled: true, patched: true, maxEvents: 2000, urlFilter: null, sourceCount: 1 },
+                    events: [],
+                }),
+            });
+            const result = await handler.handleSseGetEvents({ limit: 5, offset: 10 });
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.page.offset).toBe(10);
+            expect(body.page.limit).toBe(5);
+            expect(body.page.hasMore).toBe(true);
+        });
+        it('handles monitor not enabled', async () => {
+            const { handler } = createHandler({
+                evaluate: vi.fn().mockResolvedValue({
+                    success: false,
+                    message: 'SSE monitor is not enabled. Call sse_monitor_enable first.',
+                }),
+            });
+            const result = await handler.handleSseGetEvents({});
+            const body = parseJson(result);
+            expect(body.success).toBe(false);
+            expect(body.message).toContain('not enabled');
+        });
+    });
+    describe('enableSseInterceptor (protected)', () => {
+        it('passes maxEvents and urlFilter to page.evaluate', async () => {
+            const { handler, mockPage } = createHandler();
+            await handler.enableSseInterceptor(500, 'test-filter');
+            expect(mockPage.evaluate).toHaveBeenCalledWith(expect.any(Function), { maxEvents: 500, urlFilterRaw: 'test-filter' });
+        });
+        it('passes undefined urlFilter when not specified', async () => {
+            const { handler, mockPage } = createHandler();
+            await handler.enableSseInterceptor(1000);
+            expect(mockPage.evaluate).toHaveBeenCalledWith(expect.any(Function), { maxEvents: 1000, urlFilterRaw: undefined });
+        });
+    });
+});

package/dist/tests/server/domains/streaming/streaming-sse.test.d.ts

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