@jshookmcp/jshook 0.1.9 → 0.2.1

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

@@ -0,0 +1,66 @@
+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('@utils/logger', () => ({
+    logger: loggerState,
+}));
+import { NetworkMonitor } from '../../../src/modules/monitor/NetworkMonitor.impl.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 impl', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('captures request and response activity through the internal implementation path', async () => {
+        const { session, emit } = createMockSession();
+        const monitor = new NetworkMonitor(session);
+        await monitor.enable();
+        emit('Network.requestWillBeSent', {
+            requestId: 'req-1',
+            request: { url: 'https://example.com/api', method: 'GET', headers: {} },
+            timestamp: 1,
+            type: 'XHR',
+            initiator: {},
+        });
+        emit('Network.responseReceived', {
+            requestId: 'req-1',
+            response: {
+                url: 'https://example.com/api',
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                mimeType: 'application/json',
+                fromDiskCache: false,
+                fromServiceWorker: false,
+                timing: {},
+            },
+            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);
+    });
+});

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

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

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

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { buildFetchInterceptorCode, buildXHRInterceptorCode, CLEAR_INJECTED_BUFFERS_EXPRESSION, RESET_INJECTED_INTERCEPTORS_EXPRESSION, } from '../../../src/modules/monitor/NetworkMonitor.interceptors.js';
+describe('NetworkMonitor interceptors', () => {
+    it('builds XHR interceptor code with buffer limits and request capture hooks', () => {
+        const code = buildXHRInterceptorCode(25);
+        expect(code).toContain('window.__xhrInterceptorInstalled');
+        expect(code).toContain('window.XMLHttpRequest = function()');
+        expect(code).toContain('xhrRequests.length > 25');
+        expect(code).toContain('window.__getXHRRequests = function()');
+    });
+    it('builds fetch interceptor code with localStorage persistence and limit enforcement', () => {
+        const code = buildFetchInterceptorCode(10);
+        expect(code).toContain('window.__fetchInterceptorInstalled');
+        expect(code).toContain('fetchRequests.length > 10');
+        expect(code).toContain("localStorage.setItem('__capturedAPIs'");
+        expect(code).toContain('window.__getFetchRequests = function()');
+    });
+    it('exports expressions for clearing buffers and restoring original interceptors', () => {
+        expect(CLEAR_INJECTED_BUFFERS_EXPRESSION).toContain('xhrCleared');
+        expect(CLEAR_INJECTED_BUFFERS_EXPRESSION).toContain('fetchCleared');
+        expect(RESET_INJECTED_INTERCEPTORS_EXPRESSION).toContain('window.XMLHttpRequest = window.__originalXMLHttpRequestForHook');
+        expect(RESET_INJECTED_INTERCEPTORS_EXPRESSION).toContain('window.fetch = window.__originalFetchForHook');
+    });
+});

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

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

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

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+describe('NetworkMonitor.types.ts', () => {
+    it('defines NetworkRequest with required fields', () => {
+        const request = {
+            requestId: 'req-1',
+            url: 'https://example.com/api',
+            method: 'GET',
+            headers: { 'content-type': 'application/json' },
+            timestamp: Date.now(),
+        };
+        expect(request.requestId).toBe('req-1');
+        expect(request.url).toBe('https://example.com/api');
+        expect(request.method).toBe('GET');
+        expect(request.headers).toEqual({ 'content-type': 'application/json' });
+        expect(typeof request.timestamp).toBe('number');
+    });
+    it('defines NetworkRequest with optional fields', () => {
+        const request = {
+            requestId: 'req-2',
+            url: 'https://example.com/submit',
+            method: 'POST',
+            headers: {},
+            postData: '{"key":"value"}',
+            timestamp: 1000,
+            type: 'XHR',
+            initiator: { type: 'script' },
+        };
+        expect(request.postData).toBe('{"key":"value"}');
+        expect(request.type).toBe('XHR');
+        expect(request.initiator).toEqual({ type: 'script' });
+    });
+    it('defines NetworkResponse with required fields', () => {
+        const response = {
+            requestId: 'req-1',
+            url: 'https://example.com/api',
+            status: 200,
+            statusText: 'OK',
+            headers: { 'content-type': 'application/json' },
+            mimeType: 'application/json',
+            timestamp: Date.now(),
+        };
+        expect(response.requestId).toBe('req-1');
+        expect(response.status).toBe(200);
+        expect(response.statusText).toBe('OK');
+        expect(response.mimeType).toBe('application/json');
+        expect(typeof response.timestamp).toBe('number');
+    });
+    it('defines NetworkResponse with optional fields', () => {
+        const response = {
+            requestId: 'req-3',
+            url: 'https://example.com/cached',
+            status: 304,
+            statusText: 'Not Modified',
+            headers: {},
+            mimeType: 'text/html',
+            timestamp: 2000,
+            fromCache: true,
+            timing: { requestTime: 100 },
+        };
+        expect(response.fromCache).toBe(true);
+        expect(response.timing).toEqual({ requestTime: 100 });
+    });
+    it('treats NetworkInitiator and NetworkTiming as opaque unknown types', () => {
+        const initiator = { type: 'parser', url: 'https://example.com' };
+        const timing = { requestTime: 1, proxyStart: -1 };
+        expect(initiator).toBeDefined();
+        expect(timing).toBeDefined();
+    });
+});

package/dist/tests/modules/process/ProcessManager.chromium.test.d.ts

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

package/dist/tests/modules/process/ProcessManager.chromium.test.js

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { findChromiumProcessesWithConfig, } from '../../../src/modules/process/ProcessManager.chromium.js';
+function makeDeps(overrides) {
+    return {
+        findProcesses: vi.fn().mockResolvedValue([]),
+        getProcessCommandLine: vi.fn().mockResolvedValue({}),
+        getProcessWindows: vi.fn().mockResolvedValue([]),
+        logInfo: vi.fn(),
+        logError: vi.fn(),
+        ...overrides,
+    };
+}
+function makeProcess(override) {
+    return { pid: 100, name: 'chromium', ...override };
+}
+function makeWindow(override) {
+    return {
+        handle: '0x1',
+        title: 'Test Window',
+        className: 'Chrome_WidgetWin',
+        processId: 100,
+        threadId: 1,
+        ...override,
+    };
+}
+describe('ProcessManager.chromium', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('findChromiumProcessesWithConfig', () => {
+        it('returns empty result when no processes are found', async () => {
+            const deps = makeDeps();
+            const config = { processNamePattern: 'chromium' };
+            const result = await findChromiumProcessesWithConfig(config, deps);
+            expect(result.rendererProcesses).toEqual([]);
+            expect(result.utilityProcesses).toEqual([]);
+            expect(result.mainProcess).toBeUndefined();
+            expect(result.gpuProcess).toBeUndefined();
+            expect(result.targetWindow).toBeUndefined();
+        });
+        it('classifies processes by command line --type flag', async () => {
+            const procs = [
+                makeProcess({ pid: 1, name: 'chromium' }),
+                makeProcess({ pid: 2, name: 'chromium' }),
+                makeProcess({ pid: 3, name: 'chromium' }),
+                makeProcess({ pid: 4, name: 'chromium' }),
+            ];
+            const deps = makeDeps({
+                findProcesses: vi.fn().mockResolvedValue(procs),
+                getProcessCommandLine: vi.fn()
+                    .mockResolvedValueOnce({ commandLine: 'chromium --no-sandbox' })
+                    .mockResolvedValueOnce({ commandLine: 'chromium --type=renderer --pid=2' })
+                    .mockResolvedValueOnce({ commandLine: 'chromium --type=gpu-process' })
+                    .mockResolvedValueOnce({ commandLine: 'chromium --type=utility' }),
+            });
+            const result = await findChromiumProcessesWithConfig({ processNamePattern: 'chromium' }, deps);
+            expect(result.mainProcess).toMatchObject({ pid: 1 });
+            expect(result.rendererProcesses).toHaveLength(1);
+            expect(result.rendererProcesses[0]).toMatchObject({ pid: 2 });
+            expect(result.gpuProcess).toMatchObject({ pid: 3 });
+            expect(result.utilityProcesses).toHaveLength(1);
+            expect(result.utilityProcesses[0]).toMatchObject({ pid: 4 });
+        });
+        it('assigns mainProcess when commandLine is missing', async () => {
+            const deps = makeDeps({
+                findProcesses: vi.fn().mockResolvedValue([makeProcess({ pid: 10 })]),
+                getProcessCommandLine: vi.fn().mockResolvedValue({}),
+            });
+            const result = await findChromiumProcessesWithConfig({ processNamePattern: 'chromium' }, deps);
+            expect(result.mainProcess).toMatchObject({ pid: 10 });
+        });
+        it('uses regex filtering when processNamePattern is a RegExp', async () => {
+            const allProcs = [
+                makeProcess({ pid: 1, name: 'chrome' }),
+                makeProcess({ pid: 2, name: 'node' }),
+                makeProcess({ pid: 3, name: 'msedge' }),
+            ];
+            const deps = makeDeps({
+                findProcesses: vi.fn().mockResolvedValue(allProcs),
+                getProcessCommandLine: vi.fn().mockResolvedValue({ commandLine: 'chrome --no-sandbox' }),
+            });
+            const config = {
+                processNamePattern: /^(chrome|msedge)$/i,
+            };
+            const result = await findChromiumProcessesWithConfig(config, deps);
+            expect(deps.findProcesses).toHaveBeenCalledWith('');
+            expect(result.mainProcess).toBeDefined();
+        });
+        it('defaults processNamePattern to "chromium" when not provided', async () => {
+            const deps = makeDeps();
+            const config = {};
+            await findChromiumProcessesWithConfig(config, deps);
+            expect(deps.findProcesses).toHaveBeenCalledWith('chromium');
+        });
+        it('matches target window by title pattern', async () => {
+            const deps = makeDeps({
+                findProcesses: vi.fn().mockResolvedValue([makeProcess({ pid: 5 })]),
+                getProcessCommandLine: vi.fn().mockResolvedValue({ commandLine: 'chromium' }),
+                getProcessWindows: vi.fn().mockResolvedValue([
+                    makeWindow({ title: 'Google - Chrome', processId: 5 }),
+                ]),
+            });
+            const config = {
+                processNamePattern: 'chromium',
+                windowTitlePattern: 'Google',
+            };
+            const result = await findChromiumProcessesWithConfig(config, deps);
+            expect(result.targetWindow).toBeDefined();
+            expect(result.targetWindow.title).toBe('Google - Chrome');
+        });
+        it('matches target window by className pattern', async () => {
+            const deps = makeDeps({
+                findProcesses: vi.fn().mockResolvedValue([makeProcess({ pid: 7 })]),
+                getProcessCommandLine: vi.fn().mockResolvedValue({ commandLine: 'chromium' }),
+                getProcessWindows: vi.fn().mockResolvedValue([
+                    makeWindow({ className: 'Chrome_WidgetWin_1', title: 'No Match Title' }),
+                ]),
+            });
+            const config = {
+                processNamePattern: 'chromium',
+                windowClassPattern: 'Chrome_WidgetWin',
+            };
+            const result = await findChromiumProcessesWithConfig(config, deps);
+            expect(result.targetWindow).toBeDefined();
+        });
+        it('matches target window with regex patterns', async () => {
+            const deps = makeDeps({
+                findProcesses: vi.fn().mockResolvedValue([makeProcess({ pid: 8 })]),
+                getProcessCommandLine: vi.fn().mockResolvedValue({ commandLine: 'chromium' }),
+                getProcessWindows: vi.fn().mockResolvedValue([
+                    makeWindow({ title: 'My App v2.0', className: 'Electron' }),
+                ]),
+            });
+            const config = {
+                processNamePattern: 'chromium',
+                windowTitlePattern: /My App v\d+\.\d+/,
+            };
+            const result = await findChromiumProcessesWithConfig(config, deps);
+            expect(result.targetWindow).toBeDefined();
+            expect(result.targetWindow.title).toBe('My App v2.0');
+        });
+        it('returns empty result and logs error when findProcesses throws', async () => {
+            const logError = vi.fn();
+            const deps = makeDeps({
+                findProcesses: vi.fn().mockRejectedValue(new Error('access denied')),
+                logError,
+            });
+            const result = await findChromiumProcessesWithConfig({ processNamePattern: 'chromium' }, deps);
+            expect(result.rendererProcesses).toEqual([]);
+            expect(result.utilityProcesses).toEqual([]);
+            expect(logError).toHaveBeenCalledWith('Failed to find Chromium processes:', expect.any(Error));
+        });
+        it('does not overwrite mainProcess with a second process lacking commandLine', async () => {
+            const deps = makeDeps({
+                findProcesses: vi.fn().mockResolvedValue([
+                    makeProcess({ pid: 1 }),
+                    makeProcess({ pid: 2 }),
+                ]),
+                getProcessCommandLine: vi.fn()
+                    .mockResolvedValueOnce({ commandLine: 'chromium --main' })
+                    .mockResolvedValueOnce({}),
+            });
+            const result = await findChromiumProcessesWithConfig({ processNamePattern: 'chromium' }, deps);
+            expect(result.mainProcess).toMatchObject({ pid: 1 });
+        });
+        it('scans renderer PIDs for windows as well', async () => {
+            const getProcessWindows = vi.fn()
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce([makeWindow({ title: 'Target Tab', processId: 20 })]);
+            const deps = makeDeps({
+                findProcesses: vi.fn().mockResolvedValue([
+                    makeProcess({ pid: 10 }),
+                    makeProcess({ pid: 20 }),
+                ]),
+                getProcessCommandLine: vi.fn()
+                    .mockResolvedValueOnce({ commandLine: 'chromium' })
+                    .mockResolvedValueOnce({ commandLine: 'chromium --type=renderer' }),
+                getProcessWindows,
+            });
+            const config = {
+                processNamePattern: 'chromium',
+                windowTitlePattern: 'Target',
+            };
+            const result = await findChromiumProcessesWithConfig(config, deps);
+            expect(result.targetWindow).toBeDefined();
+            expect(result.targetWindow.title).toBe('Target Tab');
+            expect(getProcessWindows).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/dist/tests/modules/process/ProcessManager.edge-cases.test.d.ts

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