@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/domains/network/runtime-base.test.js

@@ -0,0 +1,300 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/DetailedDataManager', () => ({
+    DetailedDataManager: {
+        getInstance: () => ({
+            smartHandle: (payload) => payload,
+        }),
+    },
+}));
+vi.mock('@src/server/domains/shared/modules', () => ({
+    PerformanceMonitor: vi.fn(),
+    ConsoleMonitor: vi.fn(),
+    CodeCollector: vi.fn(),
+}));
+import { AdvancedHandlersBase } from '../../../../src/server/domains/network/handlers.base.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('AdvancedHandlersBase', () => {
+    const collector = {};
+    const consoleMonitor = {
+        isNetworkEnabled: vi.fn(),
+        enable: vi.fn(),
+        disable: vi.fn(),
+        getNetworkStatus: vi.fn(),
+    };
+    let handler;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handler = new AdvancedHandlersBase(collector, consoleMonitor);
+    });
+    describe('parseBooleanArg', () => {
+        it('returns the boolean value when given a boolean', () => {
+            expect(handler.parseBooleanArg(true, false)).toBe(true);
+            expect(handler.parseBooleanArg(false, true)).toBe(false);
+        });
+        it('returns true for number 1 and false for number 0', () => {
+            expect(handler.parseBooleanArg(1, false)).toBe(true);
+            expect(handler.parseBooleanArg(0, true)).toBe(false);
+        });
+        it('returns default for non-boolean numbers other than 0 and 1', () => {
+            expect(handler.parseBooleanArg(2, false)).toBe(false);
+            expect(handler.parseBooleanArg(-1, true)).toBe(true);
+            expect(handler.parseBooleanArg(0.5, false)).toBe(false);
+        });
+        it('parses truthy string values case-insensitively', () => {
+            expect(handler.parseBooleanArg('true', false)).toBe(true);
+            expect(handler.parseBooleanArg('TRUE', false)).toBe(true);
+            expect(handler.parseBooleanArg('1', false)).toBe(true);
+            expect(handler.parseBooleanArg('yes', false)).toBe(true);
+            expect(handler.parseBooleanArg('on', false)).toBe(true);
+            expect(handler.parseBooleanArg('  Yes  ', false)).toBe(true);
+        });
+        it('parses falsy string values case-insensitively', () => {
+            expect(handler.parseBooleanArg('false', true)).toBe(false);
+            expect(handler.parseBooleanArg('FALSE', true)).toBe(false);
+            expect(handler.parseBooleanArg('0', true)).toBe(false);
+            expect(handler.parseBooleanArg('no', true)).toBe(false);
+            expect(handler.parseBooleanArg('off', true)).toBe(false);
+            expect(handler.parseBooleanArg('  Off  ', true)).toBe(false);
+        });
+        it('returns default for unrecognized strings', () => {
+            expect(handler.parseBooleanArg('maybe', false)).toBe(false);
+            expect(handler.parseBooleanArg('maybe', true)).toBe(true);
+            expect(handler.parseBooleanArg('', false)).toBe(false);
+        });
+        it('returns default for null, undefined, objects', () => {
+            expect(handler.parseBooleanArg(null, true)).toBe(true);
+            expect(handler.parseBooleanArg(undefined, false)).toBe(false);
+            expect(handler.parseBooleanArg({}, true)).toBe(true);
+            expect(handler.parseBooleanArg([], false)).toBe(false);
+        });
+    });
+    describe('parseNumberArg', () => {
+        it('returns the number when given a finite number', () => {
+            expect(handler.parseNumberArg(42, { defaultValue: 0 })).toBe(42);
+        });
+        it('returns default for NaN and Infinity', () => {
+            expect(handler.parseNumberArg(NaN, { defaultValue: 10 })).toBe(10);
+            expect(handler.parseNumberArg(Infinity, { defaultValue: 10 })).toBe(10);
+            expect(handler.parseNumberArg(-Infinity, { defaultValue: 10 })).toBe(10);
+        });
+        it('parses numeric strings', () => {
+            expect(handler.parseNumberArg('42', { defaultValue: 0 })).toBe(42);
+            expect(handler.parseNumberArg('  3.14  ', { defaultValue: 0 })).toBe(3.14);
+        });
+        it('returns default for non-numeric strings', () => {
+            expect(handler.parseNumberArg('abc', { defaultValue: 5 })).toBe(5);
+            expect(handler.parseNumberArg('', { defaultValue: 5 })).toBe(5);
+        });
+        it('returns default for non-number/non-string types', () => {
+            expect(handler.parseNumberArg(null, { defaultValue: 7 })).toBe(7);
+            expect(handler.parseNumberArg(undefined, { defaultValue: 7 })).toBe(7);
+            expect(handler.parseNumberArg(true, { defaultValue: 7 })).toBe(7);
+        });
+        it('applies min constraint', () => {
+            expect(handler.parseNumberArg(3, { defaultValue: 0, min: 5 })).toBe(5);
+            expect(handler.parseNumberArg(10, { defaultValue: 0, min: 5 })).toBe(10);
+        });
+        it('applies max constraint', () => {
+            expect(handler.parseNumberArg(100, { defaultValue: 0, max: 50 })).toBe(50);
+            expect(handler.parseNumberArg(30, { defaultValue: 0, max: 50 })).toBe(30);
+        });
+        it('applies both min and max constraints', () => {
+            expect(handler.parseNumberArg(1, { defaultValue: 0, min: 5, max: 50 })).toBe(5);
+            expect(handler.parseNumberArg(100, { defaultValue: 0, min: 5, max: 50 })).toBe(50);
+            expect(handler.parseNumberArg(25, { defaultValue: 0, min: 5, max: 50 })).toBe(25);
+        });
+        it('truncates to integer when integer option is set', () => {
+            expect(handler.parseNumberArg(3.7, { defaultValue: 0, integer: true })).toBe(3);
+            expect(handler.parseNumberArg(-2.9, { defaultValue: 0, integer: true })).toBe(-2);
+        });
+        it('applies integer truncation before min/max clamping', () => {
+            expect(handler.parseNumberArg(4.9, { defaultValue: 0, integer: true, min: 5 })).toBe(5);
+        });
+    });
+    describe('sleep', () => {
+        it('resolves after the specified delay', async () => {
+            vi.useFakeTimers();
+            const sleepPromise = handler.sleep(100);
+            vi.advanceTimersByTime(100);
+            await sleepPromise;
+            vi.useRealTimers();
+        });
+    });
+    describe('getPerformanceMonitor', () => {
+        it('creates a PerformanceMonitor lazily on first call', () => {
+            const monitor1 = handler.getPerformanceMonitor();
+            expect(monitor1).toBeDefined();
+        });
+        it('returns the same instance on subsequent calls', () => {
+            const monitor1 = handler.getPerformanceMonitor();
+            const monitor2 = handler.getPerformanceMonitor();
+            expect(monitor1).toBe(monitor2);
+        });
+    });
+    describe('ensureNetworkEnabled', () => {
+        it('returns enabled=true if network is already enabled', async () => {
+            consoleMonitor.isNetworkEnabled.mockReturnValue(true);
+            const result = await handler.ensureNetworkEnabled({
+                autoEnable: true,
+                enableExceptions: true,
+            });
+            expect(result).toEqual({ enabled: true, autoEnabled: false });
+            expect(consoleMonitor.enable).not.toHaveBeenCalled();
+        });
+        it('returns enabled=false when not enabled and autoEnable is false', async () => {
+            consoleMonitor.isNetworkEnabled.mockReturnValue(false);
+            const result = await handler.ensureNetworkEnabled({
+                autoEnable: false,
+                enableExceptions: true,
+            });
+            expect(result).toEqual({ enabled: false, autoEnabled: false });
+        });
+        it('auto-enables when not enabled and autoEnable is true', async () => {
+            consoleMonitor.isNetworkEnabled
+                .mockReturnValueOnce(false)
+                .mockReturnValueOnce(true);
+            consoleMonitor.enable.mockResolvedValue(undefined);
+            const result = await handler.ensureNetworkEnabled({
+                autoEnable: true,
+                enableExceptions: true,
+            });
+            expect(result).toEqual({ enabled: true, autoEnabled: true });
+            expect(consoleMonitor.enable).toHaveBeenCalledWith({
+                enableNetwork: true,
+                enableExceptions: true,
+            });
+        });
+        it('returns error when auto-enable throws', async () => {
+            consoleMonitor.isNetworkEnabled.mockReturnValue(false);
+            consoleMonitor.enable.mockRejectedValue(new Error('CDP session closed'));
+            const result = await handler.ensureNetworkEnabled({
+                autoEnable: true,
+                enableExceptions: false,
+            });
+            expect(result).toEqual({
+                enabled: false,
+                autoEnabled: false,
+                error: 'CDP session closed',
+            });
+        });
+        it('stringifies non-Error throws in error field', async () => {
+            consoleMonitor.isNetworkEnabled.mockReturnValue(false);
+            consoleMonitor.enable.mockRejectedValue('string error');
+            const result = await handler.ensureNetworkEnabled({
+                autoEnable: true,
+                enableExceptions: true,
+            });
+            expect(result.error).toBe('string error');
+        });
+    });
+    describe('handleNetworkEnable', () => {
+        it('enables network monitoring and returns success', async () => {
+            consoleMonitor.getNetworkStatus.mockReturnValue({
+                enabled: true,
+                cdpSessionActive: true,
+                listenerCount: 2,
+            });
+            const body = parseJson(await handler.handleNetworkEnable({}));
+            expect(body.success).toBe(true);
+            expect(body.enabled).toBe(true);
+            expect(body.cdpSessionActive).toBe(true);
+            expect(body.listenerCount).toBe(2);
+            expect(body.usage).toBeDefined();
+            expect(consoleMonitor.enable).toHaveBeenCalledWith({
+                enableNetwork: true,
+                enableExceptions: true,
+            });
+        });
+        it('passes enableExceptions=false when arg is provided', async () => {
+            consoleMonitor.getNetworkStatus.mockReturnValue({
+                enabled: true,
+                cdpSessionActive: true,
+                listenerCount: 1,
+            });
+            await handler.handleNetworkEnable({ enableExceptions: false });
+            expect(consoleMonitor.enable).toHaveBeenCalledWith({
+                enableNetwork: true,
+                enableExceptions: false,
+            });
+        });
+        it('parses string enableExceptions args', async () => {
+            consoleMonitor.getNetworkStatus.mockReturnValue({
+                enabled: true,
+                cdpSessionActive: true,
+                listenerCount: 1,
+            });
+            await handler.handleNetworkEnable({ enableExceptions: '0' });
+            expect(consoleMonitor.enable).toHaveBeenCalledWith({
+                enableNetwork: true,
+                enableExceptions: false,
+            });
+        });
+    });
+    describe('handleNetworkDisable', () => {
+        it('disables monitoring and returns success', async () => {
+            consoleMonitor.disable.mockResolvedValue(undefined);
+            const body = parseJson(await handler.handleNetworkDisable({}));
+            expect(body.success).toBe(true);
+            expect(body.message).toContain('disabled');
+            expect(consoleMonitor.disable).toHaveBeenCalled();
+        });
+    });
+    describe('handleNetworkGetStatus', () => {
+        it('returns disabled status with next steps when monitoring is off', async () => {
+            consoleMonitor.getNetworkStatus.mockReturnValue({
+                enabled: false,
+                requestCount: 0,
+                responseCount: 0,
+                listenerCount: 0,
+                cdpSessionActive: false,
+            });
+            const body = parseJson(await handler.handleNetworkGetStatus({}));
+            expect(body.success).toBe(false);
+            expect(body.enabled).toBe(false);
+            expect(body.nextSteps).toBeDefined();
+            expect(body.example).toBeDefined();
+        });
+        it('returns enabled status with request count when monitoring is on', async () => {
+            consoleMonitor.getNetworkStatus.mockReturnValue({
+                enabled: true,
+                requestCount: 5,
+                responseCount: 3,
+                listenerCount: 2,
+                cdpSessionActive: true,
+            });
+            const body = parseJson(await handler.handleNetworkGetStatus({}));
+            expect(body.success).toBe(true);
+            expect(body.enabled).toBe(true);
+            expect(body.requestCount).toBe(5);
+            expect(body.responseCount).toBe(3);
+            expect(body.listenerCount).toBe(2);
+            expect(body.cdpSessionActive).toBe(true);
+        });
+        it('provides navigation hint when no requests captured yet', async () => {
+            consoleMonitor.getNetworkStatus.mockReturnValue({
+                enabled: true,
+                requestCount: 0,
+                responseCount: 0,
+                listenerCount: 1,
+                cdpSessionActive: true,
+            });
+            const body = parseJson(await handler.handleNetworkGetStatus({}));
+            expect(body.success).toBe(true);
+            expect(body.nextSteps.hint).toContain('No requests captured');
+        });
+        it('provides retrieval hint when requests are captured', async () => {
+            consoleMonitor.getNetworkStatus.mockReturnValue({
+                enabled: true,
+                requestCount: 10,
+                responseCount: 8,
+                listenerCount: 1,
+                cdpSessionActive: true,
+            });
+            const body = parseJson(await handler.handleNetworkGetStatus({}));
+            expect(body.nextSteps.hint).toContain('10 requests captured');
+            expect(body.nextSteps.action).toContain('network_get_requests');
+        });
+    });
+});

package/dist/tests/server/domains/network/runtime-console.test.d.ts

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

package/dist/tests/server/domains/network/runtime-console.test.js

@@ -0,0 +1,304 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const mocks = vi.hoisted(() => {
+    const consoleMonitorMock = {
+        getExceptions: vi.fn(),
+        enableDynamicScriptMonitoring: vi.fn(),
+        injectXHRInterceptor: vi.fn(),
+        injectFetchInterceptor: vi.fn(),
+        clearInjectedBuffers: vi.fn(),
+        resetInjectedInterceptors: vi.fn(),
+        injectFunctionTracer: vi.fn(),
+    };
+    const performanceMonitorMock = {
+        close: vi.fn(),
+    };
+    const collectorMock = {};
+    const loggerMock = {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    };
+    return { consoleMonitorMock, performanceMonitorMock, collectorMock, loggerMock };
+});
+vi.mock('@utils/logger', () => ({
+    logger: mocks.loggerMock,
+}));
+vi.mock('@server/domains/shared/modules', () => ({
+    PerformanceMonitor: vi.fn(),
+}));
+vi.mock('@utils/DetailedDataManager', () => ({
+    DetailedDataManager: {
+        getInstance: vi.fn().mockReturnValue({}),
+    },
+}));
+import { AdvancedHandlersBase } from '../../../../src/server/domains/network/handlers.base.js';
+class TestAdvancedHandlersBase extends AdvancedHandlersBase {
+    setPerformanceMonitorForTest(monitor) {
+        this.performanceMonitor = monitor;
+    }
+    getPerformanceMonitorForTest() {
+        return this.performanceMonitor;
+    }
+}
+function createHandler() {
+    return new TestAdvancedHandlersBase(mocks.collectorMock, mocks.consoleMonitorMock);
+}
+function getTextContent(result) {
+    const first = result.content[0];
+    expect(first).toBeDefined();
+    expect(first?.type).toBe('text');
+    if (!first || first.type !== 'text') {
+        throw new Error('Expected text tool response');
+    }
+    return first.text;
+}
+function parseContent(result) {
+    return JSON.parse(getTextContent(result));
+}
+describe('AdvancedHandlersBase (console)', () => {
+    let handler;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handler = createHandler();
+    });
+    describe('handleConsoleGetExceptions', () => {
+        it('returns all exceptions when no URL filter is provided', async () => {
+            const exceptions = [
+                { message: 'Error 1', url: 'https://a.com/script.js' },
+                { message: 'Error 2', url: 'https://b.com/app.js' },
+            ];
+            mocks.consoleMonitorMock.getExceptions.mockReturnValue(exceptions);
+            const result = await handler.handleConsoleGetExceptions({});
+            const parsed = parseContent(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.exceptions).toEqual(exceptions);
+            expect(parsed.total).toBe(2);
+        });
+        it('filters exceptions by URL substring', async () => {
+            const exceptions = [
+                { message: 'Error 1', url: 'https://a.com/script.js' },
+                { message: 'Error 2', url: 'https://b.com/app.js' },
+                { message: 'Error 3', url: 'https://a.com/other.js' },
+            ];
+            mocks.consoleMonitorMock.getExceptions.mockReturnValue(exceptions);
+            const result = await handler.handleConsoleGetExceptions({ url: 'a.com' });
+            const parsed = parseContent(result);
+            expect(parsed.total).toBe(2);
+            expect(parsed.exceptions.every((exception) => exception.url?.includes('a.com') === true)).toBe(true);
+        });
+        it('applies default limit of 50', async () => {
+            const exceptions = Array.from({ length: 60 }, (_, i) => ({
+                message: `Error ${i}`,
+                url: `https://example.com/${i}.js`,
+            }));
+            mocks.consoleMonitorMock.getExceptions.mockReturnValue(exceptions);
+            const result = await handler.handleConsoleGetExceptions({});
+            const parsed = parseContent(result);
+            expect(parsed.total).toBe(50);
+        });
+        it('applies custom limit', async () => {
+            const exceptions = Array.from({ length: 20 }, (_, i) => ({
+                message: `Error ${i}`,
+                url: `https://example.com/${i}.js`,
+            }));
+            mocks.consoleMonitorMock.getExceptions.mockReturnValue(exceptions);
+            const result = await handler.handleConsoleGetExceptions({ limit: 5 });
+            const parsed = parseContent(result);
+            expect(parsed.total).toBe(5);
+        });
+        it('applies URL filter before limit', async () => {
+            const exceptions = Array.from({ length: 10 }, (_, i) => ({
+                message: `Error ${i}`,
+                url: i < 3 ? 'https://target.com/script.js' : `https://other.com/${i}.js`,
+            }));
+            mocks.consoleMonitorMock.getExceptions.mockReturnValue(exceptions);
+            const result = await handler.handleConsoleGetExceptions({ url: 'target.com', limit: 2 });
+            const parsed = parseContent(result);
+            expect(parsed.total).toBe(2);
+        });
+        it('returns empty array when no exceptions exist', async () => {
+            mocks.consoleMonitorMock.getExceptions.mockReturnValue([]);
+            const result = await handler.handleConsoleGetExceptions({});
+            const parsed = parseContent(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.exceptions).toEqual([]);
+            expect(parsed.total).toBe(0);
+        });
+        it('handles exceptions with undefined url during filtering', async () => {
+            const exceptions = [
+                { message: 'Error 1', url: undefined },
+                { message: 'Error 2', url: 'https://a.com/script.js' },
+            ];
+            mocks.consoleMonitorMock.getExceptions.mockReturnValue(exceptions);
+            const result = await handler.handleConsoleGetExceptions({ url: 'a.com' });
+            const parsed = parseContent(result);
+            expect(parsed.total).toBe(1);
+        });
+        it('returns content with correct MCP text format', async () => {
+            mocks.consoleMonitorMock.getExceptions.mockReturnValue([]);
+            const result = await handler.handleConsoleGetExceptions({});
+            expect(result.content).toHaveLength(1);
+            expect(() => JSON.parse(getTextContent(result))).not.toThrow();
+        });
+    });
+    describe('handleConsoleInjectScriptMonitor', () => {
+        it('calls enableDynamicScriptMonitoring and returns success', async () => {
+            mocks.consoleMonitorMock.enableDynamicScriptMonitoring.mockResolvedValue(undefined);
+            const result = await handler.handleConsoleInjectScriptMonitor({});
+            const parsed = parseContent(result);
+            expect(mocks.consoleMonitorMock.enableDynamicScriptMonitoring).toHaveBeenCalledOnce();
+            expect(parsed.success).toBe(true);
+            expect(parsed.message).toBe('Dynamic script monitoring enabled');
+        });
+        it('propagates errors from enableDynamicScriptMonitoring', async () => {
+            mocks.consoleMonitorMock.enableDynamicScriptMonitoring.mockRejectedValue(new Error('CDP session closed'));
+            await expect(handler.handleConsoleInjectScriptMonitor({})).rejects.toThrow('CDP session closed');
+        });
+    });
+    describe('handleConsoleInjectXhrInterceptor', () => {
+        it('calls injectXHRInterceptor and returns success', async () => {
+            mocks.consoleMonitorMock.injectXHRInterceptor.mockResolvedValue(undefined);
+            const result = await handler.handleConsoleInjectXhrInterceptor({});
+            const parsed = parseContent(result);
+            expect(mocks.consoleMonitorMock.injectXHRInterceptor).toHaveBeenCalledOnce();
+            expect(parsed.success).toBe(true);
+            expect(parsed.message).toBe('XHR interceptor injected');
+        });
+        it('propagates errors from injectXHRInterceptor', async () => {
+            mocks.consoleMonitorMock.injectXHRInterceptor.mockRejectedValue(new Error('Injection failed'));
+            await expect(handler.handleConsoleInjectXhrInterceptor({})).rejects.toThrow('Injection failed');
+        });
+    });
+    describe('handleConsoleInjectFetchInterceptor', () => {
+        it('calls injectFetchInterceptor and returns success', async () => {
+            mocks.consoleMonitorMock.injectFetchInterceptor.mockResolvedValue(undefined);
+            const result = await handler.handleConsoleInjectFetchInterceptor({});
+            const parsed = parseContent(result);
+            expect(mocks.consoleMonitorMock.injectFetchInterceptor).toHaveBeenCalledOnce();
+            expect(parsed.success).toBe(true);
+            expect(parsed.message).toBe('Fetch interceptor injected');
+        });
+        it('propagates errors from injectFetchInterceptor', async () => {
+            mocks.consoleMonitorMock.injectFetchInterceptor.mockRejectedValue(new Error('Page not available'));
+            await expect(handler.handleConsoleInjectFetchInterceptor({})).rejects.toThrow('Page not available');
+        });
+    });
+    describe('handleConsoleClearInjectedBuffers', () => {
+        it('calls clearInjectedBuffers and returns merged result', async () => {
+            mocks.consoleMonitorMock.clearInjectedBuffers.mockResolvedValue({
+                buffersCleared: 3,
+                totalEntries: 150,
+            });
+            const result = await handler.handleConsoleClearInjectedBuffers({});
+            const parsed = parseContent(result);
+            expect(mocks.consoleMonitorMock.clearInjectedBuffers).toHaveBeenCalledOnce();
+            expect(parsed.success).toBe(true);
+            expect(parsed.message).toBe('Injected buffers cleared');
+            expect(parsed.buffersCleared).toBe(3);
+            expect(parsed.totalEntries).toBe(150);
+        });
+        it('returns success with empty result from clearInjectedBuffers', async () => {
+            mocks.consoleMonitorMock.clearInjectedBuffers.mockResolvedValue({});
+            const result = await handler.handleConsoleClearInjectedBuffers({});
+            const parsed = parseContent(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.message).toBe('Injected buffers cleared');
+        });
+        it('propagates errors from clearInjectedBuffers', async () => {
+            mocks.consoleMonitorMock.clearInjectedBuffers.mockRejectedValue(new Error('Clear failed'));
+            await expect(handler.handleConsoleClearInjectedBuffers({})).rejects.toThrow('Clear failed');
+        });
+    });
+    describe('handleConsoleResetInjectedInterceptors', () => {
+        it('calls resetInjectedInterceptors and returns merged result', async () => {
+            mocks.consoleMonitorMock.resetInjectedInterceptors.mockResolvedValue({
+                interceptorsReset: 2,
+            });
+            const result = await handler.handleConsoleResetInjectedInterceptors({});
+            const parsed = parseContent(result);
+            expect(mocks.consoleMonitorMock.resetInjectedInterceptors).toHaveBeenCalledOnce();
+            expect(parsed.success).toBe(true);
+            expect(parsed.message).toBe('Injected interceptors/monitors reset');
+            expect(parsed.interceptorsReset).toBe(2);
+        });
+        it('propagates errors from resetInjectedInterceptors', async () => {
+            mocks.consoleMonitorMock.resetInjectedInterceptors.mockRejectedValue(new Error('Reset failed'));
+            await expect(handler.handleConsoleResetInjectedInterceptors({})).rejects.toThrow('Reset failed');
+        });
+    });
+    describe('handleConsoleInjectFunctionTracer', () => {
+        it('injects function tracer for the given function name', async () => {
+            mocks.consoleMonitorMock.injectFunctionTracer.mockResolvedValue(undefined);
+            const result = await handler.handleConsoleInjectFunctionTracer({ functionName: 'myFunc' });
+            const parsed = parseContent(result);
+            expect(mocks.consoleMonitorMock.injectFunctionTracer).toHaveBeenCalledWith('myFunc');
+            expect(parsed.success).toBe(true);
+            expect(parsed.message).toBe('Function tracer injected for: myFunc');
+        });
+        it('throws when functionName is not provided', async () => {
+            await expect(handler.handleConsoleInjectFunctionTracer({})).rejects.toThrow('functionName is required');
+            expect(mocks.consoleMonitorMock.injectFunctionTracer).not.toHaveBeenCalled();
+        });
+        it('throws when functionName is empty string', async () => {
+            await expect(handler.handleConsoleInjectFunctionTracer({ functionName: '' })).rejects.toThrow('functionName is required');
+        });
+        it('handles dot-notation function names', async () => {
+            mocks.consoleMonitorMock.injectFunctionTracer.mockResolvedValue(undefined);
+            const result = await handler.handleConsoleInjectFunctionTracer({
+                functionName: 'window.crypto.getRandomValues',
+            });
+            const parsed = parseContent(result);
+            expect(mocks.consoleMonitorMock.injectFunctionTracer).toHaveBeenCalledWith('window.crypto.getRandomValues');
+            expect(parsed.message).toBe('Function tracer injected for: window.crypto.getRandomValues');
+        });
+        it('propagates errors from injectFunctionTracer', async () => {
+            mocks.consoleMonitorMock.injectFunctionTracer.mockRejectedValue(new Error('Function not found'));
+            await expect(handler.handleConsoleInjectFunctionTracer({ functionName: 'nonexistent' })).rejects.toThrow('Function not found');
+        });
+    });
+    describe('cleanup', () => {
+        it('closes performanceMonitor when it exists and nullifies it', async () => {
+            handler.setPerformanceMonitorForTest(mocks.performanceMonitorMock);
+            mocks.performanceMonitorMock.close.mockResolvedValue(undefined);
+            await handler.cleanup();
+            expect(mocks.performanceMonitorMock.close).toHaveBeenCalledOnce();
+            expect(handler.getPerformanceMonitorForTest()).toBeNull();
+        });
+        it('logs cleanup message', async () => {
+            await handler.cleanup();
+            expect(mocks.loggerMock.info).toHaveBeenCalledWith('AdvancedHandlersBase cleaned up');
+        });
+        it('does not throw when performanceMonitor is null', async () => {
+            handler.setPerformanceMonitorForTest(null);
+            await expect(handler.cleanup()).resolves.not.toThrow();
+            expect(mocks.performanceMonitorMock.close).not.toHaveBeenCalled();
+        });
+    });
+    describe('response format', () => {
+        it('all handlers return content array with single text entry', async () => {
+            mocks.consoleMonitorMock.getExceptions.mockReturnValue([]);
+            mocks.consoleMonitorMock.enableDynamicScriptMonitoring.mockResolvedValue(undefined);
+            mocks.consoleMonitorMock.injectXHRInterceptor.mockResolvedValue(undefined);
+            mocks.consoleMonitorMock.injectFetchInterceptor.mockResolvedValue(undefined);
+            mocks.consoleMonitorMock.clearInjectedBuffers.mockResolvedValue({});
+            mocks.consoleMonitorMock.resetInjectedInterceptors.mockResolvedValue({});
+            mocks.consoleMonitorMock.injectFunctionTracer.mockResolvedValue(undefined);
+            const methods = [
+                () => handler.handleConsoleGetExceptions({}),
+                () => handler.handleConsoleInjectScriptMonitor({}),
+                () => handler.handleConsoleInjectXhrInterceptor({}),
+                () => handler.handleConsoleInjectFetchInterceptor({}),
+                () => handler.handleConsoleClearInjectedBuffers({}),
+                () => handler.handleConsoleResetInjectedInterceptors({}),
+                () => handler.handleConsoleInjectFunctionTracer({ functionName: 'test' }),
+            ];
+            for (const method of methods) {
+                const result = await method();
+                expect(result.content).toHaveLength(1);
+                const parsed = JSON.parse(getTextContent(result));
+                expect(parsed.success).toBe(true);
+            }
+        });
+    });
+});

package/dist/tests/server/domains/network/runtime-performance.test.d.ts

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