@jshookmcp/jshook 0.2.6 → 0.2.7

package/dist/src/modules/monitor/NetworkMonitor.impl.js

@@ -1,506 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { buildFetchInterceptorCode, buildXHRInterceptorCode, CLEAR_INJECTED_BUFFERS_EXPRESSION, RESET_INJECTED_INTERCEPTORS_EXPRESSION, } from '../monitor/NetworkMonitor.interceptors.js';
-const isObjectRecord = (value) => typeof value === 'object' && value !== null;
-const isRequestWillBeSentPayload = (value) => {
-    if (!isObjectRecord(value) || typeof value.requestId !== 'string') {
-        return false;
-    }
-    if (!isObjectRecord(value.request)) {
-        return false;
-    }
-    if (typeof value.request.url !== 'string' || typeof value.request.method !== 'string') {
-        return false;
-    }
-    if (value.request.postData !== undefined && typeof value.request.postData !== 'string') {
-        return false;
-    }
-    return typeof value.timestamp === 'number';
-};
-const isResponseReceivedPayload = (value) => {
-    if (!isObjectRecord(value) || typeof value.requestId !== 'string') {
-        return false;
-    }
-    if (!isObjectRecord(value.response)) {
-        return false;
-    }
-    if (typeof value.response.url !== 'string' ||
-        typeof value.response.status !== 'number' ||
-        typeof value.response.statusText !== 'string' ||
-        typeof value.response.mimeType !== 'string') {
-        return false;
-    }
-    return typeof value.timestamp === 'number';
-};
-const isLoadingFinishedPayload = (value) => isObjectRecord(value) && typeof value.requestId === 'string';
-const isResponseBodyPayload = (value) => isObjectRecord(value) &&
-    typeof value.body === 'string' &&
-    typeof value.base64Encoded === 'boolean';
-const asStringRecord = (value) => isObjectRecord(value) ? value : {};
-const toRuntimeEvaluateValue = (value) => {
-    if (!isObjectRecord(value)) {
-        return undefined;
-    }
-    const runtimeResult = value.result;
-    if (!isObjectRecord(runtimeResult)) {
-        return undefined;
-    }
-    return runtimeResult.value;
-};
-const toFiniteNumber = (value, fallback = 0) => typeof value === 'number' && Number.isFinite(value) ? value : fallback;
-const toBoolean = (value, fallback) => typeof value === 'boolean' ? value : fallback;
-export class NetworkMonitor {
-    cdpSession;
-    networkEnabled = false;
-    requests = new Map();
-    responses = new Map();
-    MAX_NETWORK_RECORDS = 500;
-    MAX_INJECTED_RECORDS = 500;
-    JS_RESPONSE_CONCURRENCY = 6;
-    responseBodyCache = new Map();
-    MAX_BODY_CACHE_ENTRIES = 200;
-    networkListeners = {};
-    constructor(cdpSession) {
-        this.cdpSession = cdpSession;
-        this.cdpSession.on('disconnected', () => {
-            logger.warn('NetworkMonitor: CDP session disconnected');
-            this.networkEnabled = false;
-            this.networkListeners = {};
-        });
-    }
-    async enable() {
-        if (!this.cdpSession) {
-            throw new Error('CDP session not initialized');
-        }
-        if (this.networkEnabled) {
-            logger.warn('Network monitoring already enabled');
-            return;
-        }
-        try {
-            await this.cdpSession.send('Network.enable', {
-                maxTotalBufferSize: 10000000,
-                maxResourceBufferSize: 5000000,
-                maxPostDataSize: 65536,
-            });
-            logger.info('Network domain enabled');
-            this.networkListeners.requestWillBeSent = (params) => {
-                if (!isRequestWillBeSentPayload(params)) {
-                    logger.debug('Skipping malformed Network.requestWillBeSent payload');
-                    return;
-                }
-                const request = {
-                    requestId: params.requestId,
-                    url: params.request.url,
-                    method: params.request.method,
-                    headers: asStringRecord(params.request.headers),
-                    postData: params.request.postData,
-                    timestamp: params.timestamp,
-                    type: params.type,
-                    initiator: params.initiator,
-                };
-                this.requests.set(params.requestId, request);
-                if (this.requests.size > this.MAX_NETWORK_RECORDS) {
-                    const firstKey = this.requests.keys().next().value;
-                    if (firstKey) {
-                        this.requests.delete(firstKey);
-                    }
-                }
-                logger.debug(`Network request captured: ${params.request.method} ${params.request.url}`);
-            };
-            this.networkListeners.responseReceived = (params) => {
-                if (!isResponseReceivedPayload(params)) {
-                    logger.debug('Skipping malformed Network.responseReceived payload');
-                    return;
-                }
-                const response = {
-                    requestId: params.requestId,
-                    url: params.response.url,
-                    status: params.response.status,
-                    statusText: params.response.statusText,
-                    headers: asStringRecord(params.response.headers),
-                    mimeType: params.response.mimeType,
-                    timestamp: params.timestamp,
-                    fromCache: params.response.fromDiskCache || params.response.fromServiceWorker,
-                    timing: params.response.timing,
-                };
-                this.responses.set(params.requestId, response);
-                if (this.responses.size > this.MAX_NETWORK_RECORDS) {
-                    const firstKey = this.responses.keys().next().value;
-                    if (firstKey) {
-                        this.responses.delete(firstKey);
-                    }
-                }
-                logger.debug(`Network response captured: ${params.response.status} ${params.response.url}`);
-            };
-            this.networkListeners.loadingFinished = (params) => {
-                if (!isLoadingFinishedPayload(params)) {
-                    logger.debug('Skipping malformed Network.loadingFinished payload');
-                    return;
-                }
-                logger.debug(`Network loading finished: ${params.requestId}`);
-                this.captureResponseBody(params.requestId).catch((err) => {
-                    logger.debug(`[BodyCache] Auto-capture failed for ${params.requestId}: ${err instanceof Error ? err.message : String(err)}`);
-                });
-            };
-            this.cdpSession.on('Network.requestWillBeSent', this.networkListeners.requestWillBeSent);
-            this.cdpSession.on('Network.responseReceived', this.networkListeners.responseReceived);
-            this.cdpSession.on('Network.loadingFinished', this.networkListeners.loadingFinished);
-            this.networkEnabled = true;
-            logger.info(' Network monitoring enabled successfully', {
-                requestListeners: !!this.networkListeners.requestWillBeSent,
-                responseListeners: !!this.networkListeners.responseReceived,
-                loadingListeners: !!this.networkListeners.loadingFinished,
-            });
-        }
-        catch (error) {
-            logger.error(' Failed to enable network monitoring:', error);
-            this.networkEnabled = false;
-            throw error;
-        }
-    }
-    async captureResponseBody(requestId) {
-        if (this.responseBodyCache.has(requestId))
-            return;
-        const response = this.responses.get(requestId);
-        if (!response)
-            return;
-        if (response.fromCache)
-            return;
-        try {
-            const rawResult = (await this.cdpSession.send('Network.getResponseBody', {
-                requestId,
-            }));
-            if (!isResponseBodyPayload(rawResult))
-                return;
-            if (rawResult.body.length > 1_048_576) {
-                logger.debug(`[BodyCache] Skipping oversized body for ${requestId} (${rawResult.body.length} chars)`);
-                return;
-            }
-            if (this.responseBodyCache.size >= this.MAX_BODY_CACHE_ENTRIES) {
-                const oldestKey = this.responseBodyCache.keys().next().value;
-                if (oldestKey) {
-                    this.responseBodyCache.delete(oldestKey);
-                }
-            }
-            this.responseBodyCache.set(requestId, {
-                body: rawResult.body,
-                base64Encoded: rawResult.base64Encoded,
-            });
-            logger.debug(`[BodyCache] Cached body for ${requestId} (${rawResult.body.length} chars, url=${response.url})`);
-        }
-        catch (err) {
-            logger.debug(`[BodyCache] Could not capture body for ${requestId}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    async disable() {
-        if (!this.networkEnabled) {
-            return;
-        }
-        if (this.networkListeners.requestWillBeSent) {
-            this.cdpSession.off('Network.requestWillBeSent', this.networkListeners.requestWillBeSent);
-        }
-        if (this.networkListeners.responseReceived) {
-            this.cdpSession.off('Network.responseReceived', this.networkListeners.responseReceived);
-        }
-        if (this.networkListeners.loadingFinished) {
-            this.cdpSession.off('Network.loadingFinished', this.networkListeners.loadingFinished);
-        }
-        try {
-            await this.cdpSession.send('Network.disable');
-        }
-        catch (error) {
-            logger.warn('Failed to disable Network domain:', error);
-        }
-        this.networkListeners = {};
-        this.networkEnabled = false;
-        logger.info('Network monitoring disabled');
-    }
-    isEnabled() {
-        return this.networkEnabled;
-    }
-    getStatus() {
-        return {
-            enabled: this.networkEnabled,
-            requestCount: this.requests.size,
-            responseCount: this.responses.size,
-            listenerCount: Object.keys(this.networkListeners).filter((key) => this.networkListeners[key] !== undefined).length,
-            cdpSessionActive: true,
-        };
-    }
-    getRequests(filter) {
-        let requests = Array.from(this.requests.values());
-        if (filter?.url) {
-            requests = requests.filter((req) => req.url.includes(filter.url));
-        }
-        if (filter?.method) {
-            requests = requests.filter((req) => req.method === filter.method);
-        }
-        if (filter?.limit) {
-            requests = requests.slice(-filter.limit);
-        }
-        return requests;
-    }
-    getResponses(filter) {
-        let responses = Array.from(this.responses.values());
-        if (filter?.url) {
-            responses = responses.filter((res) => res.url.includes(filter.url));
-        }
-        if (filter?.status) {
-            responses = responses.filter((res) => res.status === filter.status);
-        }
-        if (filter?.limit) {
-            responses = responses.slice(-filter.limit);
-        }
-        return responses;
-    }
-    getActivity(requestId) {
-        return {
-            request: this.requests.get(requestId),
-            response: this.responses.get(requestId),
-        };
-    }
-    async getResponseBody(requestId) {
-        if (!this.cdpSession) {
-            throw new Error('CDP session not initialized');
-        }
-        if (!this.networkEnabled) {
-            logger.error('Network monitoring is not enabled. Call enable() with enableNetwork: true first.');
-            return null;
-        }
-        const cached = this.responseBodyCache.get(requestId);
-        if (cached) {
-            this.responseBodyCache.delete(requestId);
-            this.responseBodyCache.set(requestId, cached);
-            logger.debug(`[BodyCache] Cache hit for ${requestId}`);
-            return cached;
-        }
-        const request = this.requests.get(requestId);
-        const response = this.responses.get(requestId);
-        if (!request) {
-            logger.error(`Request not found: ${requestId}. Make sure network monitoring was enabled before the request.`);
-            return null;
-        }
-        if (!response) {
-            logger.warn(`Response not yet received for request: ${requestId}. The request may still be pending.`);
-            return null;
-        }
-        try {
-            const rawResult = (await this.cdpSession.send('Network.getResponseBody', {
-                requestId,
-            }));
-            if (!isResponseBodyPayload(rawResult)) {
-                logger.error(`Unexpected response body payload for ${requestId}`);
-                return null;
-            }
-            logger.info(`Response body retrieved for request: ${requestId}`, {
-                url: response.url,
-                status: response.status,
-                size: rawResult.body.length,
-                base64: rawResult.base64Encoded,
-            });
-            return {
-                body: rawResult.body,
-                base64Encoded: rawResult.base64Encoded,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error(`Failed to get response body for ${requestId}:`, {
-                url: response.url,
-                status: response.status,
-                error: errorMessage,
-                hint: 'The response body may not be available for this request type (e.g., cached, redirected, or failed requests)',
-            });
-            return null;
-        }
-    }
-    async getAllJavaScriptResponses() {
-        const candidates = Array.from(this.responses.entries()).filter(([, response]) => {
-            return (response.mimeType.includes('javascript') ||
-                response.url.endsWith('.js') ||
-                response.url.includes('.js?'));
-        });
-        const jsResponses = [];
-        for (let i = 0; i < candidates.length; i += this.JS_RESPONSE_CONCURRENCY) {
-            const batch = candidates.slice(i, i + this.JS_RESPONSE_CONCURRENCY);
-            const batchResults = await Promise.all(batch.map(async ([requestId, response]) => {
-                const bodyResult = await this.getResponseBody(requestId);
-                if (!bodyResult) {
-                    return null;
-                }
-                const content = bodyResult.base64Encoded
-                    ? Buffer.from(bodyResult.body, 'base64').toString('utf-8')
-                    : bodyResult.body;
-                return {
-                    url: response.url,
-                    content,
-                    size: content.length,
-                    requestId,
-                };
-            }));
-            jsResponses.push(...batchResults.filter((value) => value !== null));
-        }
-        logger.info(`Collected ${jsResponses.length} JavaScript responses`);
-        return jsResponses;
-    }
-    clearRecords() {
-        this.requests.clear();
-        this.responses.clear();
-        this.responseBodyCache.clear();
-        logger.info('Network records cleared');
-    }
-    getStats() {
-        const byMethod = {};
-        const byStatus = {};
-        const byType = {};
-        for (const request of this.requests.values()) {
-            byMethod[request.method] = (byMethod[request.method] || 0) + 1;
-            if (request.type) {
-                byType[request.type] = (byType[request.type] || 0) + 1;
-            }
-        }
-        for (const response of this.responses.values()) {
-            byStatus[response.status] = (byStatus[response.status] || 0) + 1;
-        }
-        return {
-            totalRequests: this.requests.size,
-            totalResponses: this.responses.size,
-            byMethod,
-            byStatus,
-            byType,
-        };
-    }
-    async injectXHRInterceptor(options) {
-        if (!this.cdpSession) {
-            throw new Error('CDP session not initialized');
-        }
-        const interceptorCode = buildXHRInterceptorCode(this.MAX_INJECTED_RECORDS);
-        if (options?.persistent) {
-            await this.cdpSession.send('Page.addScriptToEvaluateOnNewDocument', {
-                source: interceptorCode,
-            });
-            logger.info('XHR interceptor injected (persistent)');
-        }
-        else {
-            await this.cdpSession.send('Runtime.evaluate', {
-                expression: interceptorCode,
-            });
-            logger.info('XHR interceptor injected');
-        }
-    }
-    async injectFetchInterceptor(options) {
-        if (!this.cdpSession) {
-            throw new Error('CDP session not initialized');
-        }
-        const interceptorCode = buildFetchInterceptorCode(this.MAX_INJECTED_RECORDS);
-        if (options?.persistent) {
-            await this.cdpSession.send('Page.addScriptToEvaluateOnNewDocument', {
-                source: interceptorCode,
-            });
-            logger.info('Fetch interceptor injected (persistent)');
-        }
-        else {
-            await this.cdpSession.send('Runtime.evaluate', {
-                expression: interceptorCode,
-            });
-            logger.info('Fetch interceptor injected');
-        }
-    }
-    async getXHRRequests() {
-        if (!this.cdpSession) {
-            throw new Error('CDP session not initialized');
-        }
-        try {
-            const rawResult = (await this.cdpSession.send('Runtime.evaluate', {
-                expression: 'window.__getXHRRequests ? window.__getXHRRequests() : []',
-                returnByValue: true,
-            }));
-            const value = toRuntimeEvaluateValue(rawResult);
-            if (!Array.isArray(value)) {
-                return [];
-            }
-            return value.filter((entry) => isObjectRecord(entry));
-        }
-        catch (error) {
-            logger.error('Failed to get XHR requests:', error);
-            return [];
-        }
-    }
-    async getFetchRequests() {
-        if (!this.cdpSession) {
-            throw new Error('CDP session not initialized');
-        }
-        try {
-            const rawResult = (await this.cdpSession.send('Runtime.evaluate', {
-                expression: 'window.__getFetchRequests ? window.__getFetchRequests() : []',
-                returnByValue: true,
-            }));
-            const value = toRuntimeEvaluateValue(rawResult);
-            if (!Array.isArray(value)) {
-                return [];
-            }
-            return value.filter((entry) => isObjectRecord(entry));
-        }
-        catch (error) {
-            logger.error('Failed to get Fetch requests:', error);
-            return [];
-        }
-    }
-    async clearInjectedBuffers() {
-        if (!this.cdpSession) {
-            throw new Error('CDP session not initialized');
-        }
-        try {
-            const rawResult = (await this.cdpSession.send('Runtime.evaluate', {
-                expression: CLEAR_INJECTED_BUFFERS_EXPRESSION,
-                returnByValue: true,
-            }));
-            const value = toRuntimeEvaluateValue(rawResult);
-            if (!isObjectRecord(value)) {
-                return {
-                    xhrCleared: 0,
-                    fetchCleared: 0,
-                };
-            }
-            return {
-                xhrCleared: toFiniteNumber(value.xhrCleared),
-                fetchCleared: toFiniteNumber(value.fetchCleared),
-            };
-        }
-        catch (error) {
-            logger.error('Failed to clear injected network buffers:', error);
-            return {
-                xhrCleared: 0,
-                fetchCleared: 0,
-            };
-        }
-    }
-    async resetInjectedInterceptors() {
-        if (!this.cdpSession) {
-            throw new Error('CDP session not initialized');
-        }
-        try {
-            const rawResult = (await this.cdpSession.send('Runtime.evaluate', {
-                expression: RESET_INJECTED_INTERCEPTORS_EXPRESSION,
-                returnByValue: true,
-            }));
-            const value = toRuntimeEvaluateValue(rawResult);
-            if (!isObjectRecord(value)) {
-                return {
-                    xhrReset: false,
-                    fetchReset: false,
-                };
-            }
-            return {
-                xhrReset: toBoolean(value.xhrReset, false),
-                fetchReset: toBoolean(value.fetchReset, false),
-            };
-        }
-        catch (error) {
-            logger.error('Failed to reset injected network interceptors:', error);
-            return {
-                xhrReset: false,
-                fetchReset: false,
-            };
-        }
-    }
-}

package/dist/src/modules/monitor/NetworkMonitor.interceptors.d.ts

@@ -1,4 +0,0 @@
-export declare function buildXHRInterceptorCode(maxRecords: number): string;
-export declare function buildFetchInterceptorCode(maxRecords: number): string;
-export declare const CLEAR_INJECTED_BUFFERS_EXPRESSION = "\n          (() => {\n            const xhrStore = Array.isArray(window.__xhrRequests)\n              ? window.__xhrRequests\n              : (typeof window.__getXHRRequests === 'function' ? window.__getXHRRequests() : null);\n            const fetchStore = Array.isArray(window.__fetchRequests)\n              ? window.__fetchRequests\n              : (typeof window.__getFetchRequests === 'function' ? window.__getFetchRequests() : null);\n\n            const xhrCleared = Array.isArray(xhrStore) ? xhrStore.length : 0;\n            const fetchCleared = Array.isArray(fetchStore) ? fetchStore.length : 0;\n\n            if (Array.isArray(xhrStore)) xhrStore.length = 0;\n            if (Array.isArray(fetchStore)) fetchStore.length = 0;\n\n            return { xhrCleared, fetchCleared };\n          })()\n        ";
-export declare const RESET_INJECTED_INTERCEPTORS_EXPRESSION = "\n          (() => {\n            let xhrReset = false;\n            let fetchReset = false;\n\n            if (window.__originalXMLHttpRequestForHook) {\n              window.XMLHttpRequest = window.__originalXMLHttpRequestForHook;\n              xhrReset = true;\n            }\n\n            if (window.__originalFetchForHook) {\n              window.fetch = window.__originalFetchForHook;\n              fetchReset = true;\n            }\n\n            if (Array.isArray(window.__xhrRequests)) window.__xhrRequests.length = 0;\n            if (Array.isArray(window.__fetchRequests)) window.__fetchRequests.length = 0;\n\n            window.__xhrInterceptorInstalled = false;\n            window.__fetchInterceptorInstalled = false;\n            delete window.__getXHRRequests;\n            delete window.__getFetchRequests;\n\n            return { xhrReset, fetchReset };\n          })()\n        ";