@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/modules/monitor/PerformanceMonitor.js

@@ -1,439 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { setImmediate as waitForImmediate } from 'node:timers/promises';
-import { logger } from '../../utils/logger.js';
-import { evaluateWithTimeout, coverageStartJSWithTimeout, coverageStartCSSWithTimeout, coverageStopJSWithTimeout, coverageStopCSSWithTimeout, } from '../collector/PageController.js';
-import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
-import { cdpLimit } from '../../utils/concurrency.js';
-import { resolveArtifactPath } from '../../utils/artifacts.js';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function isCDPHeapSnapshotChunkPayload(value) {
-    return isRecord(value) && typeof value.chunk === 'string';
-}
-function isCDPHeapSamplingNode(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    const { callFrame, selfSize, children } = value;
-    if (callFrame !== undefined) {
-        if (!isRecord(callFrame)) {
-            return false;
-        }
-        if (callFrame.functionName !== undefined && typeof callFrame.functionName !== 'string') {
-            return false;
-        }
-        if (callFrame.url !== undefined && typeof callFrame.url !== 'string') {
-            return false;
-        }
-    }
-    if (selfSize !== undefined && typeof selfSize !== 'number') {
-        return false;
-    }
-    if (children !== undefined && !Array.isArray(children)) {
-        return false;
-    }
-    return true;
-}
-function isCDPHeapSamplingPayload(value) {
-    return isRecord(value) && isRecord(value.profile) && isCDPHeapSamplingNode(value.profile.head);
-}
-async function yieldToEventLoop() {
-    await waitForImmediate();
-}
-function countTraceEvents(traceData) {
-    const eventPattern = /"ph"\s*:/g;
-    let count = 0;
-    while (eventPattern.exec(traceData) !== null) {
-        count++;
-    }
-    return count;
-}
-function insertTopAllocation(topAllocations, candidate, topN) {
-    if (topN <= 0) {
-        return;
-    }
-    if (topAllocations.length === topN &&
-        candidate.selfSize <= topAllocations[topAllocations.length - 1].selfSize) {
-        return;
-    }
-    let insertIndex = topAllocations.findIndex((entry) => candidate.selfSize > entry.selfSize);
-    if (insertIndex === -1) {
-        insertIndex = topAllocations.length;
-    }
-    topAllocations.splice(insertIndex, 0, candidate);
-    if (topAllocations.length > topN) {
-        topAllocations.length = topN;
-    }
-}
-function collectTopHeapAllocations(root, topN) {
-    const stack = [root];
-    const topAllocations = [];
-    let sampleCount = 0;
-    while (stack.length > 0) {
-        const node = stack.pop();
-        if (!node) {
-            continue;
-        }
-        if (node.callFrame) {
-            sampleCount++;
-            insertTopAllocation(topAllocations, {
-                functionName: node.callFrame.functionName || '(anonymous)',
-                url: node.callFrame.url || '',
-                selfSize: node.selfSize || 0,
-            }, topN);
-        }
-        if (Array.isArray(node.children)) {
-            for (let i = node.children.length - 1; i >= 0; i--) {
-                const child = node.children[i];
-                if (child) {
-                    stack.push(child);
-                }
-            }
-        }
-    }
-    return { sampleCount, topAllocations };
-}
-async function PING(cdp) {
-    await Promise.race([
-        cdp.send('Runtime.evaluate', { expression: '1', returnByValue: true }),
-        new Promise((_, reject) => setTimeout(() => reject(new Error('cdp_unreachable')), 500)),
-    ]);
-}
-export class PerformanceMonitor {
-    collector;
-    cdpSession = null;
-    coverageEnabled = false;
-    profilerEnabled = false;
-    tracingEnabled = false;
-    heapSamplingEnabled = false;
-    coveragePage = null;
-    tracingPage = null;
-    constructor(collector) {
-        this.collector = collector;
-    }
-    async ensureCDPSession() {
-        if (!this.cdpSession) {
-            const page = await this.collector.getActivePage();
-            this.cdpSession = await Promise.race([
-                page.createCDPSession(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('cdp_session_timeout')), 500)),
-            ]);
-            return this.cdpSession;
-        }
-        try {
-            await PING(this.cdpSession);
-            return this.cdpSession;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (msg !== 'cdp_unreachable')
-                throw err;
-            logger.warn('PerformanceMonitor CDP session unresponsive, recreating...');
-            try {
-                await this.cdpSession.detach();
-            }
-            catch {
-            }
-            this.cdpSession = null;
-            const page = await this.collector.getActivePage();
-            this.cdpSession = await Promise.race([
-                page.createCDPSession(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('cdp_session_timeout')), 500)),
-            ]);
-            return this.cdpSession;
-        }
-    }
-    async getPerformanceMetrics() {
-        const page = await this.collector.getActivePage();
-        const metrics = (await evaluateWithTimeout(page, () => {
-            const result = {};
-            const navTiming = performance.getEntriesByType('navigation')[0];
-            if (navTiming) {
-                result.domContentLoaded = navTiming.domContentLoadedEventEnd - navTiming.fetchStart;
-                result.loadComplete = navTiming.loadEventEnd - navTiming.fetchStart;
-                result.ttfb = navTiming.responseStart - navTiming.requestStart;
-            }
-            const paintEntries = performance.getEntriesByType('paint');
-            const fcpEntry = paintEntries.find((entry) => entry.name === 'first-contentful-paint');
-            if (fcpEntry) {
-                result.fcp = fcpEntry.startTime;
-            }
-            const lcpEntries = performance.getEntriesByType('largest-contentful-paint');
-            const lastLCP = lcpEntries.at(-1);
-            if (lastLCP) {
-                result.lcp = lastLCP.renderTime || lastLCP.loadTime;
-            }
-            let clsValue = 0;
-            const layoutShiftEntries = performance.getEntriesByType('layout-shift');
-            for (const entry of layoutShiftEntries) {
-                if (!entry.hadRecentInput) {
-                    clsValue += entry.value ?? 0;
-                }
-            }
-            result.cls = clsValue;
-            const performanceWithMemory = performance;
-            if (performanceWithMemory.memory) {
-                const memory = performanceWithMemory.memory;
-                result.jsHeapSizeLimit = memory.jsHeapSizeLimit;
-                result.totalJSHeapSize = memory.totalJSHeapSize;
-                result.usedJSHeapSize = memory.usedJSHeapSize;
-            }
-            return result;
-        }));
-        logger.info('Performance metrics collected', {
-            fcp: metrics.fcp,
-            lcp: metrics.lcp,
-            cls: metrics.cls,
-        });
-        return metrics;
-    }
-    async getPerformanceTimeline() {
-        const page = await this.collector.getActivePage();
-        const timeline = await evaluateWithTimeout(page, () => {
-            return performance.getEntries().map((entry) => ({
-                name: entry.name,
-                entryType: entry.entryType,
-                startTime: entry.startTime,
-                duration: entry.duration,
-            }));
-        });
-        logger.info(`Performance timeline collected: ${timeline.length} entries`);
-        return timeline;
-    }
-    async startCoverage(options) {
-        const page = await this.collector.getActivePage();
-        await Promise.all([
-            coverageStartJSWithTimeout(page, {
-                resetOnNavigation: options?.resetOnNavigation,
-                reportAnonymousScripts: options?.reportAnonymousScripts,
-            }),
-            coverageStartCSSWithTimeout(page, {
-                resetOnNavigation: options?.resetOnNavigation,
-            }),
-        ]);
-        this.coverageEnabled = true;
-        this.coveragePage = page;
-        logger.info('Code coverage collection started');
-    }
-    async stopCoverage() {
-        if (!this.coverageEnabled) {
-            throw new PrerequisiteError('Coverage not enabled. Call startCoverage() first.');
-        }
-        const page = this.coveragePage ?? (await this.collector.getActivePage());
-        const [jsCoverageResult, cssCoverageResult] = await Promise.all([
-            coverageStopJSWithTimeout(page),
-            coverageStopCSSWithTimeout(page),
-        ]);
-        const jsCoverage = jsCoverageResult;
-        const cssCoverage = cssCoverageResult;
-        this.coverageEnabled = false;
-        this.coveragePage = null;
-        const coverageEntries = [...jsCoverage, ...cssCoverage];
-        const coverageInfo = coverageEntries.map((entry) => {
-            const totalBytes = entry.text.length;
-            const usedBytes = entry.ranges.reduce((sum, range) => sum + (range.end - range.start), 0);
-            return {
-                url: entry.url,
-                text: entry.text,
-                ranges: entry.ranges.map((range) => ({
-                    start: range.start,
-                    end: range.end,
-                    count: 1,
-                })),
-                totalBytes,
-                usedBytes,
-                coveragePercentage: totalBytes > 0 ? (usedBytes / totalBytes) * 100 : 0,
-            };
-        });
-        logger.success(`Code coverage collected: ${coverageInfo.length} scripts`, {
-            totalScripts: coverageInfo.length,
-            avgCoverage: coverageInfo.reduce((sum, info) => sum + info.coveragePercentage, 0) / coverageInfo.length,
-        });
-        return coverageInfo;
-    }
-    async startCPUProfiling() {
-        const cdp = await this.ensureCDPSession();
-        await cdp.send('Profiler.enable');
-        await cdp.send('Profiler.start');
-        this.profilerEnabled = true;
-        logger.info('CPU profiling started');
-    }
-    async stopCPUProfiling() {
-        if (!this.profilerEnabled) {
-            throw new PrerequisiteError('CPU profiling not enabled. Call startCPUProfiling() first.');
-        }
-        const cdp = await this.ensureCDPSession();
-        const { profile } = await cdp.send('Profiler.stop');
-        await cdp.send('Profiler.disable');
-        this.profilerEnabled = false;
-        logger.success('CPU profiling stopped', {
-            nodes: profile.nodes.length,
-            samples: profile.samples?.length || 0,
-        });
-        return profile;
-    }
-    async takeHeapSnapshot() {
-        const cdp = await this.ensureCDPSession();
-        await cdp.send('HeapProfiler.enable');
-        let snapshotData = '';
-        const chunkHandler = (params) => {
-            if (!isCDPHeapSnapshotChunkPayload(params)) {
-                return;
-            }
-            snapshotData += params.chunk;
-        };
-        cdp.on('HeapProfiler.addHeapSnapshotChunk', chunkHandler);
-        try {
-            await cdp.send('HeapProfiler.takeHeapSnapshot', {
-                reportProgress: false,
-                treatGlobalObjectsAsRoots: true,
-            });
-        }
-        finally {
-            cdp.off('HeapProfiler.addHeapSnapshotChunk', chunkHandler);
-            await cdp.send('HeapProfiler.disable').catch(() => { });
-        }
-        logger.success('Heap snapshot taken', {
-            size: snapshotData.length,
-        });
-        return snapshotData;
-    }
-    async startTracing(options) {
-        return cdpLimit(async () => {
-            if (this.tracingEnabled) {
-                throw new Error('Tracing already in progress. Call stopTracing() first.');
-            }
-            const page = await this.collector.getActivePage();
-            const categories = options?.categories ?? [
-                '-*',
-                'devtools.timeline',
-                'v8.execute',
-                'disabled-by-default-devtools.timeline',
-                'disabled-by-default-devtools.timeline.frame',
-                'toplevel',
-                'blink.console',
-                'blink.user_timing',
-                'latencyInfo',
-                ...(options?.screenshots ? ['disabled-by-default-devtools.screenshot'] : []),
-            ];
-            await page.tracing.start({
-                categories,
-                screenshots: options?.screenshots,
-            });
-            this.tracingEnabled = true;
-            this.tracingPage = page;
-            logger.info('Performance tracing started', { categories: categories.length });
-        });
-    }
-    async stopTracing(options) {
-        return cdpLimit(async () => {
-            if (!this.tracingEnabled) {
-                throw new PrerequisiteError('Tracing not in progress. Call startTracing() first.');
-            }
-            const page = this.tracingPage ?? (await this.collector.getActivePage());
-            const traceBuffer = await page.tracing.stop();
-            const traceData = traceBuffer ? Buffer.from(traceBuffer).toString('utf-8') : '';
-            this.tracingEnabled = false;
-            this.tracingPage = null;
-            const eventCount = countTraceEvents(traceData);
-            let savedPath;
-            if (options?.artifactPath) {
-                await writeFile(options.artifactPath, traceData, 'utf-8');
-                savedPath = options.artifactPath;
-            }
-            else {
-                const { absolutePath, displayPath } = await resolveArtifactPath({
-                    category: 'traces',
-                    toolName: 'performance-trace',
-                    ext: 'json',
-                });
-                await writeFile(absolutePath, traceData, 'utf-8');
-                savedPath = displayPath;
-            }
-            logger.success('Performance trace saved', {
-                eventCount,
-                sizeBytes: traceData.length,
-                path: savedPath,
-            });
-            return {
-                artifactPath: savedPath,
-                eventCount,
-                sizeBytes: traceData.length,
-            };
-        });
-    }
-    async startHeapSampling(options) {
-        return cdpLimit(async () => {
-            if (this.heapSamplingEnabled) {
-                throw new Error('Heap sampling already in progress. Call stopHeapSampling() first.');
-            }
-            const cdp = await this.ensureCDPSession();
-            await cdp.send('HeapProfiler.enable');
-            await cdp.send('HeapProfiler.startSampling', {
-                samplingInterval: options?.samplingInterval ?? 32768,
-            });
-            this.heapSamplingEnabled = true;
-            logger.info('Heap sampling profiler started');
-        });
-    }
-    async stopHeapSampling(options) {
-        return cdpLimit(async () => {
-            if (!this.heapSamplingEnabled) {
-                throw new PrerequisiteError('Heap sampling not in progress. Call startHeapSampling() first.');
-            }
-            const cdp = await this.ensureCDPSession();
-            const samplingPayload = (await cdp.send('HeapProfiler.stopSampling'));
-            if (!isCDPHeapSamplingPayload(samplingPayload)) {
-                throw new Error('Unexpected HeapProfiler.stopSampling payload shape');
-            }
-            const { profile } = samplingPayload;
-            await cdp.send('HeapProfiler.disable');
-            this.heapSamplingEnabled = false;
-            const topN = options?.topN ?? 20;
-            await yieldToEventLoop();
-            const { sampleCount, topAllocations } = collectTopHeapAllocations(profile.head, topN);
-            await yieldToEventLoop();
-            const profileJson = JSON.stringify(profile);
-            let savedPath;
-            if (options?.artifactPath) {
-                await writeFile(options.artifactPath, profileJson, 'utf-8');
-                savedPath = options.artifactPath;
-            }
-            else {
-                const { absolutePath, displayPath } = await resolveArtifactPath({
-                    category: 'profiles',
-                    toolName: 'heap-sampling',
-                    ext: 'json',
-                });
-                await writeFile(absolutePath, profileJson, 'utf-8');
-                savedPath = displayPath;
-            }
-            logger.success('Heap sampling profile saved', { sampleCount, path: savedPath });
-            return {
-                artifactPath: savedPath,
-                sampleCount,
-                topAllocations,
-            };
-        });
-    }
-    async close() {
-        if (this.cdpSession) {
-            if (this.coverageEnabled) {
-                await this.stopCoverage().catch(() => { });
-            }
-            if (this.profilerEnabled) {
-                await this.stopCPUProfiling().catch(() => { });
-            }
-            if (this.tracingEnabled) {
-                await this.stopTracing().catch(() => { });
-            }
-            if (this.heapSamplingEnabled) {
-                await this.stopHeapSampling().catch(() => { });
-            }
-            await this.cdpSession.detach();
-            this.cdpSession = null;
-        }
-        logger.info('PerformanceMonitor closed');
-    }
-}

package/dist/src/modules/monitor/PlaywrightNetworkMonitor.d.ts

@@ -1,86 +0,0 @@
-import type { NetworkRequest, NetworkResponse } from '../monitor/NetworkMonitor.js';
-interface PlaywrightLikePage {
-    on(event: string, listener: (...args: unknown[]) => void): void;
-    off(event: string, listener: (...args: unknown[]) => void): void;
-    evaluate?<T>(pageFunction: string | (() => T | Promise<T>)): Promise<T>;
-    evaluateOnNewDocument?<T>(pageFunction: string | (() => T | Promise<T>)): Promise<T>;
-}
-export declare class PlaywrightNetworkMonitor {
-    private page;
-    private networkEnabled;
-    private requests;
-    private responses;
-    private readonly MAX_NETWORK_RECORDS;
-    private readonly MAX_INJECTED_RECORDS;
-    private requestCounter;
-    private responseBodyCache;
-    private readonly MAX_BODY_CACHE_ENTRIES;
-    private requestIdMap;
-    private boundOnRequest;
-    private boundOnResponse;
-    constructor(page: PlaywrightLikePage | null);
-    setPage(page: PlaywrightLikePage | null): void;
-    private getPageOrThrow;
-    private evaluateInPage;
-    private evaluateOnNewDocumentInPage;
-    private isUnknownArray;
-    private isClearedBuffersResult;
-    private isResetInterceptorsResult;
-    private isPlaywrightLikeRequest;
-    private isPlaywrightLikeResponse;
-    enable(): Promise<void>;
-    disable(): Promise<void>;
-    isEnabled(): boolean;
-    getRequests(filter?: {
-        url?: string;
-        method?: string;
-        limit?: number;
-    }): NetworkRequest[];
-    getResponses(filter?: {
-        url?: string;
-        status?: number;
-        limit?: number;
-    }): NetworkResponse[];
-    getStatus(): {
-        enabled: boolean;
-        requestCount: number;
-        responseCount: number;
-        listenerCount: number;
-        cdpSessionActive: boolean;
-    };
-    getActivity(requestId: string): {
-        request: NetworkRequest | undefined;
-        response: NetworkResponse | undefined;
-    };
-    clearRecords(): void;
-    getStats(): {
-        totalRequests: number;
-        totalResponses: number;
-        byMethod: Record<string, number>;
-        byStatus: Record<string, number>;
-        byType: Record<string, number>;
-    };
-    getResponseBody(requestId: string): Promise<{
-        body: string;
-        base64Encoded: boolean;
-    } | null>;
-    injectScript(script: string): Promise<void>;
-    injectXHRInterceptor(options?: {
-        persistent?: boolean;
-    }): Promise<void>;
-    injectFetchInterceptor(options?: {
-        persistent?: boolean;
-    }): Promise<void>;
-    getXHRRequests(): Promise<unknown[]>;
-    getFetchRequests(): Promise<unknown[]>;
-    clearInjectedBuffers(): Promise<{
-        xhrCleared: number;
-        fetchCleared: number;
-    }>;
-    resetInjectedInterceptors(): Promise<{
-        xhrReset: boolean;
-        fetchReset: boolean;
-    }>;
-    getAllJavaScriptResponses(): Promise<NetworkResponse[]>;
-}
-export {};