@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/modules/monitor/ConsoleMonitor.impl.core.class.js

@@ -1,499 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { NetworkMonitor } from '../monitor/NetworkMonitor.js';
-import { PlaywrightNetworkMonitor } from '../monitor/PlaywrightNetworkMonitor.js';
-import { FetchInterceptor } from '../monitor/FetchInterceptor.js';
-import { clearExceptionsCore, clearLogsCore, getExceptionsCore, getLogsCore, getStatsCore, } from '../monitor/ConsoleMonitor.impl.core.logs.js';
-import { clearInjectedBuffersCore, clearNetworkRecordsCore, getAllJavaScriptResponsesCore, getFetchRequestsCore, getNetworkActivityCore, getNetworkRequestsCore, getNetworkResponsesCore, getNetworkStatsCore, getNetworkStatusCore, getResponseBodyCore, getXHRRequestsCore, injectFetchInterceptorCore, injectXHRInterceptorCore, isNetworkEnabledCore, resetInjectedInterceptorsCore, } from '../monitor/ConsoleMonitor.impl.core.network.js';
-import { clearObjectCacheCore, inspectObjectCore, } from '../monitor/ConsoleMonitor.impl.core.object-cache.js';
-import { clearDynamicScriptBufferCore, enableDynamicScriptMonitoringCore, getDynamicScriptsCore, injectFunctionTracerCore, injectPropertyWatcherCore, resetDynamicScriptMonitoringCore, } from '../monitor/ConsoleMonitor.impl.core.dynamic.js';
-export class ConsoleMonitor {
-    collector;
-    cdpSession = null;
-    networkMonitor = null;
-    fetchInterceptor = null;
-    playwrightNetworkMonitor = null;
-    playwrightPage = null;
-    playwrightConsoleHandler = null;
-    playwrightErrorHandler = null;
-    messages = [];
-    MAX_MESSAGES = 1000;
-    exceptions = [];
-    MAX_EXCEPTIONS = 500;
-    MAX_INJECTED_DYNAMIC_SCRIPTS = 500;
-    MAX_OBJECT_CACHE_SIZE = 1000;
-    objectCache = new Map();
-    initPromise;
-    lastEnableOptions = {};
-    constructor(collector) {
-        this.collector = collector;
-        this.touchSplitMembersForTypeCheck();
-    }
-    touchSplitMembersForTypeCheck() {
-        void this.MAX_INJECTED_DYNAMIC_SCRIPTS;
-        void this.MAX_OBJECT_CACHE_SIZE;
-        void this.clearDynamicScriptBuffer;
-        void this.resetDynamicScriptMonitoring;
-    }
-    setPlaywrightPage(page) {
-        this.playwrightPage = page;
-        this.playwrightNetworkMonitor?.setPage(page);
-    }
-    clearPlaywrightPage() {
-        this.playwrightPage = null;
-        this.playwrightConsoleHandler = null;
-        this.playwrightErrorHandler = null;
-        this.playwrightNetworkMonitor?.setPage(null);
-        this.playwrightNetworkMonitor = null;
-    }
-    async enable(options) {
-        if (this.initPromise) {
-            await this.initPromise;
-            await this.applyPostEnableOptions(options);
-            return;
-        }
-        this.initPromise = this.doEnable(options);
-        try {
-            await this.initPromise;
-        }
-        finally {
-            this.initPromise = undefined;
-        }
-    }
-    async doEnable(options) {
-        if (this.playwrightPage) {
-            this.lastEnableOptions = { ...options };
-            return this.enablePlaywright(options);
-        }
-        if (this.cdpSession) {
-            if (options?.enableNetwork && !this.networkMonitor) {
-                this.networkMonitor = new NetworkMonitor(this.cdpSession);
-                await this.networkMonitor.enable();
-                logger.info('Network monitoring added to existing ConsoleMonitor session');
-            }
-            return;
-        }
-        const page = await this.collector.getActivePage();
-        this.cdpSession = await Promise.race([
-            page.createCDPSession(),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('cdp_session_timeout')), 500)),
-        ]);
-        this.lastEnableOptions = { ...options };
-        this.cdpSession.on('disconnected', () => {
-            logger.warn('ConsoleMonitor CDP session disconnected');
-            this.cdpSession = null;
-            this.networkMonitor = null;
-            this.fetchInterceptor = null;
-        });
-        await cdpSendWithTimeout(this.cdpSession, 'Runtime.enable', {}, 5000);
-        await cdpSendWithTimeout(this.cdpSession, 'Console.enable', {}, 5000);
-        this.cdpSession.on('Runtime.consoleAPICalled', (params) => {
-            const stackTrace = params.stackTrace?.callFrames?.map((frame) => ({
-                functionName: frame.functionName || '(anonymous)',
-                url: frame.url,
-                lineNumber: frame.lineNumber,
-                columnNumber: frame.columnNumber,
-            })) || [];
-            const message = {
-                type: params.type,
-                text: params.args.map((arg) => this.formatRemoteObject(arg)).join(' '),
-                args: params.args.map((arg) => this.extractValue(arg)),
-                timestamp: params.timestamp,
-                stackTrace,
-                url: stackTrace[0]?.url,
-                lineNumber: stackTrace[0]?.lineNumber,
-                columnNumber: stackTrace[0]?.columnNumber,
-            };
-            this.messages.push(message);
-            if (this.messages.length > this.MAX_MESSAGES) {
-                this.messages = this.messages.slice(-Math.floor(this.MAX_MESSAGES / 2));
-            }
-            logger.debug(`Console ${params.type}: ${message.text}`);
-        });
-        this.cdpSession.on('Console.messageAdded', (params) => {
-            const msg = params.message;
-            const message = {
-                type: msg.level || 'log',
-                text: msg.text,
-                timestamp: Date.now(),
-                url: msg.url,
-                lineNumber: msg.line,
-                columnNumber: msg.column,
-            };
-            this.messages.push(message);
-            if (this.messages.length > this.MAX_MESSAGES) {
-                this.messages = this.messages.slice(-Math.floor(this.MAX_MESSAGES / 2));
-            }
-        });
-        if (options?.enableExceptions !== false) {
-            this.cdpSession.on('Runtime.exceptionThrown', (params) => {
-                const exception = params.exceptionDetails;
-                const stackTrace = exception.stackTrace?.callFrames?.map((frame) => ({
-                    functionName: frame.functionName || '(anonymous)',
-                    url: frame.url,
-                    lineNumber: frame.lineNumber,
-                    columnNumber: frame.columnNumber,
-                })) || [];
-                const exceptionInfo = {
-                    text: exception.exception?.description || exception.text,
-                    exceptionId: exception.exceptionId,
-                    timestamp: Date.now(),
-                    stackTrace,
-                    url: exception.url,
-                    lineNumber: exception.lineNumber,
-                    columnNumber: exception.columnNumber,
-                    scriptId: exception.scriptId,
-                };
-                this.exceptions.push(exceptionInfo);
-                if (this.exceptions.length > this.MAX_EXCEPTIONS) {
-                    this.exceptions = this.exceptions.slice(-Math.floor(this.MAX_EXCEPTIONS / 2));
-                }
-                logger.error(`Exception thrown: ${exceptionInfo.text}`, {
-                    url: exceptionInfo.url,
-                    line: exceptionInfo.lineNumber,
-                });
-            });
-        }
-        if (options?.enableNetwork) {
-            this.networkMonitor = new NetworkMonitor(this.cdpSession);
-            await this.networkMonitor.enable();
-        }
-        logger.info('ConsoleMonitor enabled', {
-            network: options?.enableNetwork || false,
-            exceptions: options?.enableExceptions !== false,
-        });
-    }
-    async applyPostEnableOptions(options) {
-        if (!options?.enableNetwork) {
-            return;
-        }
-        this.lastEnableOptions = { ...this.lastEnableOptions, ...options };
-        if (this.playwrightPage && this.playwrightConsoleHandler && !this.playwrightNetworkMonitor) {
-            this.playwrightNetworkMonitor = new PlaywrightNetworkMonitor(this.playwrightPage);
-            await this.playwrightNetworkMonitor.enable();
-            logger.info('Network monitoring added to existing ConsoleMonitor Playwright session');
-            return;
-        }
-        if (this.cdpSession && !this.networkMonitor) {
-            this.networkMonitor = new NetworkMonitor(this.cdpSession);
-            await this.networkMonitor.enable();
-            logger.info('Network monitoring added to existing ConsoleMonitor session');
-        }
-    }
-    async enablePlaywright(options) {
-        if (this.playwrightConsoleHandler) {
-            if (options?.enableNetwork && !this.playwrightNetworkMonitor) {
-                this.playwrightNetworkMonitor = new PlaywrightNetworkMonitor(this.playwrightPage);
-                await this.playwrightNetworkMonitor.enable();
-                logger.info('Network monitoring added to existing ConsoleMonitor Playwright session');
-            }
-            return;
-        }
-        const page = this.playwrightPage;
-        this.playwrightConsoleHandler = (msg) => {
-            const message = {
-                type: msg.type() || 'log',
-                text: msg.text(),
-                timestamp: Date.now(),
-            };
-            this.messages.push(message);
-            if (this.messages.length > this.MAX_MESSAGES) {
-                this.messages = this.messages.slice(-Math.floor(this.MAX_MESSAGES / 2));
-            }
-        };
-        page.on('console', this.playwrightConsoleHandler);
-        if (options?.enableExceptions !== false) {
-            this.playwrightErrorHandler = (error) => {
-                const exceptionInfo = {
-                    text: error.message,
-                    exceptionId: Date.now(),
-                    timestamp: Date.now(),
-                };
-                this.exceptions.push(exceptionInfo);
-                if (this.exceptions.length > this.MAX_EXCEPTIONS) {
-                    this.exceptions = this.exceptions.slice(-Math.floor(this.MAX_EXCEPTIONS / 2));
-                }
-            };
-            page.on('pageerror', this.playwrightErrorHandler);
-        }
-        if (options?.enableNetwork) {
-            this.playwrightNetworkMonitor = new PlaywrightNetworkMonitor(this.playwrightPage);
-            await this.playwrightNetworkMonitor.enable();
-        }
-        logger.info('ConsoleMonitor enabled (Playwright/camoufox mode)', {
-            network: options?.enableNetwork || false,
-        });
-    }
-    async disable() {
-        try {
-            if (this.playwrightPage) {
-                const page = this.playwrightPage;
-                if (this.playwrightConsoleHandler) {
-                    try {
-                        page.off('console', this.playwrightConsoleHandler);
-                    }
-                    catch {
-                    }
-                    this.playwrightConsoleHandler = null;
-                }
-                if (this.playwrightErrorHandler) {
-                    try {
-                        page.off('pageerror', this.playwrightErrorHandler);
-                    }
-                    catch {
-                    }
-                    this.playwrightErrorHandler = null;
-                }
-            }
-            if (this.playwrightNetworkMonitor) {
-                await this.playwrightNetworkMonitor.disable();
-                this.playwrightNetworkMonitor = null;
-            }
-            if (this.cdpSession) {
-                if (this.fetchInterceptor) {
-                    await this.fetchInterceptor.disable();
-                    this.fetchInterceptor = null;
-                }
-                if (this.networkMonitor) {
-                    await this.networkMonitor.disable();
-                    this.networkMonitor = null;
-                }
-                try {
-                    await this.cdpSession.send('Console.disable');
-                }
-                catch (error) {
-                    logger.warn('Failed to disable Console domain:', error);
-                }
-                try {
-                    await this.cdpSession.send('Runtime.disable');
-                }
-                catch (error) {
-                    logger.warn('Failed to disable Runtime domain:', error);
-                }
-                try {
-                    await this.cdpSession.detach();
-                }
-                catch (error) {
-                    logger.warn('Failed to detach ConsoleMonitor CDP session:', error);
-                }
-                this.cdpSession = null;
-                logger.info('ConsoleMonitor disabled');
-            }
-        }
-        finally {
-            this.initPromise = undefined;
-            this.objectCache.clear();
-        }
-    }
-    async ensureSession() {
-        if (!this.cdpSession && !this.playwrightPage) {
-            logger.info('ConsoleMonitor CDP session lost, reinitializing...');
-            await this.enable(this.lastEnableOptions);
-            return;
-        }
-        if (this.cdpSession) {
-            try {
-                await Promise.race([
-                    this.cdpSession.send('Runtime.evaluate', { expression: '1', returnByValue: true }),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error('session_unreachable')), 3000)),
-                ]);
-                return;
-            }
-            catch {
-                logger.warn('ConsoleMonitor CDP session unresponsive (zombie), reinitializing...');
-                this.cdpSession = null;
-                this.networkMonitor = null;
-                this.fetchInterceptor = null;
-                await this.enable(this.lastEnableOptions);
-            }
-        }
-    }
-    isSessionActive() {
-        return this.cdpSession !== null || this.playwrightPage !== null;
-    }
-    getLogs(filter) {
-        return getLogsCore(this, filter);
-    }
-    async execute(expression) {
-        await this.ensureSession();
-        try {
-            const result = (await cdpSendWithTimeout(this.cdpSession, 'Runtime.evaluate', {
-                expression,
-                returnByValue: true,
-            }));
-            if (result.exceptionDetails) {
-                logger.error('Console execute error:', result.exceptionDetails);
-                throw new Error(result.exceptionDetails.text);
-            }
-            logger.info('Console expression executed');
-            return result.result.value;
-        }
-        catch (error) {
-            logger.error('Console execute failed:', error);
-            throw error;
-        }
-    }
-    clearLogs() {
-        clearLogsCore(this);
-    }
-    getStats() {
-        return getStatsCore(this);
-    }
-    async close() {
-        try {
-            await this.disable();
-        }
-        finally {
-            this.initPromise = undefined;
-            this.objectCache.clear();
-        }
-    }
-    isNetworkEnabled() {
-        return isNetworkEnabledCore(this);
-    }
-    getNetworkStatus() {
-        return getNetworkStatusCore(this);
-    }
-    getNetworkRequests(filter) {
-        return getNetworkRequestsCore(this, filter);
-    }
-    getNetworkResponses(filter) {
-        return getNetworkResponsesCore(this, filter);
-    }
-    getNetworkActivity(requestId) {
-        return getNetworkActivityCore(this, requestId);
-    }
-    async getResponseBody(requestId) {
-        return getResponseBodyCore(this, requestId);
-    }
-    async getAllJavaScriptResponses() {
-        return getAllJavaScriptResponsesCore(this);
-    }
-    clearNetworkRecords() {
-        clearNetworkRecordsCore(this);
-    }
-    async clearInjectedBuffers() {
-        return clearInjectedBuffersCore(this);
-    }
-    async resetInjectedInterceptors() {
-        return resetInjectedInterceptorsCore(this);
-    }
-    getNetworkStats() {
-        return getNetworkStatsCore(this);
-    }
-    async injectXHRInterceptor(options) {
-        return injectXHRInterceptorCore(this, options);
-    }
-    async injectFetchInterceptor(options) {
-        return injectFetchInterceptorCore(this, options);
-    }
-    async getXHRRequests() {
-        return getXHRRequestsCore(this);
-    }
-    async getFetchRequests() {
-        return getFetchRequestsCore(this);
-    }
-    getExceptions(filter) {
-        return getExceptionsCore(this, filter);
-    }
-    clearExceptions() {
-        clearExceptionsCore(this);
-    }
-    async inspectObject(objectId) {
-        return inspectObjectCore(this, objectId);
-    }
-    clearObjectCache() {
-        clearObjectCacheCore(this);
-    }
-    async enableDynamicScriptMonitoring(options) {
-        return enableDynamicScriptMonitoringCore(this, options);
-    }
-    async clearDynamicScriptBuffer() {
-        return clearDynamicScriptBufferCore(this);
-    }
-    async resetDynamicScriptMonitoring() {
-        return resetDynamicScriptMonitoringCore(this);
-    }
-    async getDynamicScripts() {
-        return getDynamicScriptsCore(this);
-    }
-    async injectFunctionTracer(functionName, options) {
-        return injectFunctionTracerCore(this, functionName, options);
-    }
-    async injectPropertyWatcher(objectPath, propertyName, options) {
-        return injectPropertyWatcherCore(this, objectPath, propertyName, options);
-    }
-    async enableFetchIntercept(rules) {
-        await this.ensureSession();
-        if (!this.cdpSession) {
-            throw new Error('No CDP session available for Fetch interception');
-        }
-        if (!this.fetchInterceptor) {
-            this.fetchInterceptor = new FetchInterceptor(this.cdpSession);
-        }
-        return this.fetchInterceptor.enable(rules);
-    }
-    async disableFetchIntercept() {
-        if (!this.fetchInterceptor) {
-            return { removedRules: 0 };
-        }
-        const result = await this.fetchInterceptor.disable();
-        this.fetchInterceptor = null;
-        return result;
-    }
-    async removeFetchInterceptRule(ruleId) {
-        if (!this.fetchInterceptor) {
-            return false;
-        }
-        const removed = await this.fetchInterceptor.removeRule(ruleId);
-        if (!this.fetchInterceptor.isEnabled()) {
-            this.fetchInterceptor = null;
-        }
-        return removed;
-    }
-    getFetchInterceptStatus() {
-        if (!this.fetchInterceptor) {
-            return { enabled: false, rules: [], totalHits: 0 };
-        }
-        return this.fetchInterceptor.listRules();
-    }
-    formatRemoteObject(obj) {
-        if (obj.value !== undefined) {
-            return String(obj.value);
-        }
-        if (obj.description) {
-            return obj.description;
-        }
-        if (obj.type === 'undefined') {
-            return 'undefined';
-        }
-        if (obj.type === 'object' && obj.subtype === 'null') {
-            return 'null';
-        }
-        return `[${obj.type}]`;
-    }
-    extractValue(obj) {
-        if (obj.value !== undefined) {
-            return obj.value;
-        }
-        if (obj.type === 'undefined') {
-            return undefined;
-        }
-        if (obj.type === 'object' && obj.subtype === 'null') {
-            return null;
-        }
-        if (obj.objectId) {
-            return {
-                __objectId: obj.objectId,
-                __type: obj.type,
-                __description: obj.description,
-            };
-        }
-        return obj.description || `[${obj.type}]`;
-    }
-}
-async function cdpSendWithTimeout(session, method, params, timeoutMs = 30000) {
-    return Promise.race([
-        session.send(method, params),
-        new Promise((_, reject) => setTimeout(() => reject(new Error(`CDP ${method} timed out after ${timeoutMs}ms`)), timeoutMs)),
-    ]);
-}

package/dist/src/modules/monitor/ConsoleMonitor.impl.core.d.ts

@@ -1,3 +0,0 @@
-export type { NetworkRequest, NetworkResponse } from '../monitor/NetworkMonitor.js';
-export type { ConsoleMessage, ExceptionInfo, StackFrame, } from '../monitor/ConsoleMonitor.impl.core.class.js';
-export { ConsoleMonitor } from '../monitor/ConsoleMonitor.impl.core.class.js';

package/dist/src/modules/monitor/ConsoleMonitor.impl.core.dynamic.d.ts

@@ -1,26 +0,0 @@
-interface DynamicScriptRecord {
-    type?: string;
-    src?: string | null;
-    content?: string | null;
-    timestamp?: number;
-    async?: boolean;
-    defer?: boolean;
-    [key: string]: unknown;
-}
-export declare function enableDynamicScriptMonitoringCore(ctx: unknown, options?: {
-    persistent?: boolean;
-}): Promise<void>;
-export declare function clearDynamicScriptBufferCore(ctx: unknown): Promise<{
-    dynamicScriptsCleared: number;
-}>;
-export declare function resetDynamicScriptMonitoringCore(ctx: unknown): Promise<{
-    scriptMonitorReset: boolean;
-}>;
-export declare function getDynamicScriptsCore(ctx: unknown): Promise<DynamicScriptRecord[]>;
-export declare function injectFunctionTracerCore(ctx: unknown, functionName: string, options?: {
-    persistent?: boolean;
-}): Promise<void>;
-export declare function injectPropertyWatcherCore(ctx: unknown, objectPath: string, propertyName: string, options?: {
-    persistent?: boolean;
-}): Promise<void>;
-export {};