@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/modules/debugger/EventBreakpointManager.d.ts

@@ -1,29 +0,0 @@
-import type { CDPSession } from 'rebrowser-puppeteer-core';
-export interface EventBreakpoint {
-    id: string;
-    eventName: string;
-    targetName?: string;
-    enabled: boolean;
-    hitCount: number;
-    createdAt: number;
-}
-export declare class EventBreakpointManager {
-    private cdpSession;
-    private eventBreakpoints;
-    private breakpointCounter;
-    static readonly MOUSE_EVENTS: string[];
-    static readonly KEYBOARD_EVENTS: string[];
-    static readonly TIMER_EVENTS: string[];
-    static readonly WEBSOCKET_EVENTS: string[];
-    constructor(cdpSession: CDPSession);
-    setEventListenerBreakpoint(eventName: string, targetName?: string): Promise<string>;
-    removeEventListenerBreakpoint(breakpointId: string): Promise<boolean>;
-    setMouseEventBreakpoints(): Promise<string[]>;
-    setKeyboardEventBreakpoints(): Promise<string[]>;
-    setTimerEventBreakpoints(): Promise<string[]>;
-    setWebSocketEventBreakpoints(): Promise<string[]>;
-    getAllEventBreakpoints(): EventBreakpoint[];
-    getEventBreakpoint(breakpointId: string): EventBreakpoint | undefined;
-    clearAllEventBreakpoints(): Promise<void>;
-    close(): Promise<void>;
-}

package/dist/src/modules/debugger/EventBreakpointManager.js

@@ -1,132 +0,0 @@
-import { logger } from '../../utils/logger.js';
-export class EventBreakpointManager {
-    cdpSession;
-    eventBreakpoints = new Map();
-    breakpointCounter = 0;
-    static MOUSE_EVENTS = [
-        'click',
-        'dblclick',
-        'mousedown',
-        'mouseup',
-        'mousemove',
-        'mouseenter',
-        'mouseleave',
-    ];
-    static KEYBOARD_EVENTS = ['keydown', 'keyup', 'keypress'];
-    static TIMER_EVENTS = ['setTimeout', 'setInterval', 'requestAnimationFrame'];
-    static WEBSOCKET_EVENTS = ['message', 'open', 'close', 'error'];
-    constructor(cdpSession) {
-        this.cdpSession = cdpSession;
-        logger.info('EventBreakpointManager initialized with shared CDP session');
-    }
-    async setEventListenerBreakpoint(eventName, targetName) {
-        try {
-            await this.cdpSession.send('DOMDebugger.setEventListenerBreakpoint', {
-                eventName,
-                targetName,
-            });
-            const breakpointId = `event_${++this.breakpointCounter}`;
-            this.eventBreakpoints.set(breakpointId, {
-                id: breakpointId,
-                eventName,
-                targetName,
-                enabled: true,
-                hitCount: 0,
-                createdAt: Date.now(),
-            });
-            logger.info(`Event listener breakpoint set: ${eventName}`, { breakpointId, targetName });
-            return breakpointId;
-        }
-        catch (error) {
-            logger.error('Failed to set event listener breakpoint:', error);
-            throw error;
-        }
-    }
-    async removeEventListenerBreakpoint(breakpointId) {
-        const breakpoint = this.eventBreakpoints.get(breakpointId);
-        if (!breakpoint) {
-            return false;
-        }
-        try {
-            await this.cdpSession.send('DOMDebugger.removeEventListenerBreakpoint', {
-                eventName: breakpoint.eventName,
-                targetName: breakpoint.targetName,
-            });
-            this.eventBreakpoints.delete(breakpointId);
-            logger.info(`Event listener breakpoint removed: ${breakpointId}`);
-            return true;
-        }
-        catch (error) {
-            logger.error('Failed to remove event listener breakpoint:', error);
-            throw error;
-        }
-    }
-    async setMouseEventBreakpoints() {
-        const breakpointIds = [];
-        for (const event of EventBreakpointManager.MOUSE_EVENTS) {
-            const id = await this.setEventListenerBreakpoint(event);
-            breakpointIds.push(id);
-        }
-        logger.info(`Set ${breakpointIds.length} mouse event breakpoints`);
-        return breakpointIds;
-    }
-    async setKeyboardEventBreakpoints() {
-        const breakpointIds = [];
-        for (const event of EventBreakpointManager.KEYBOARD_EVENTS) {
-            const id = await this.setEventListenerBreakpoint(event);
-            breakpointIds.push(id);
-        }
-        logger.info(`Set ${breakpointIds.length} keyboard event breakpoints`);
-        return breakpointIds;
-    }
-    async setTimerEventBreakpoints() {
-        const breakpointIds = [];
-        for (const event of EventBreakpointManager.TIMER_EVENTS) {
-            const id = await this.setEventListenerBreakpoint(event);
-            breakpointIds.push(id);
-        }
-        logger.info(`Set ${breakpointIds.length} timer event breakpoints`);
-        return breakpointIds;
-    }
-    async setWebSocketEventBreakpoints() {
-        const breakpointIds = [];
-        for (const event of EventBreakpointManager.WEBSOCKET_EVENTS) {
-            const id = await this.setEventListenerBreakpoint(event, 'WebSocket');
-            breakpointIds.push(id);
-        }
-        logger.info(`Set ${breakpointIds.length} WebSocket event breakpoints`);
-        return breakpointIds;
-    }
-    getAllEventBreakpoints() {
-        return Array.from(this.eventBreakpoints.values());
-    }
-    getEventBreakpoint(breakpointId) {
-        return this.eventBreakpoints.get(breakpointId);
-    }
-    async clearAllEventBreakpoints() {
-        const breakpoints = Array.from(this.eventBreakpoints.values());
-        for (const bp of breakpoints) {
-            try {
-                await this.cdpSession.send('DOMDebugger.removeEventListenerBreakpoint', {
-                    eventName: bp.eventName,
-                    targetName: bp.targetName,
-                });
-            }
-            catch (error) {
-                logger.warn(`Failed to remove event breakpoint ${bp.id}:`, error);
-            }
-        }
-        this.eventBreakpoints.clear();
-        logger.info('All event breakpoints cleared');
-    }
-    async close() {
-        try {
-            await this.clearAllEventBreakpoints();
-            logger.info('EventBreakpointManager closed');
-        }
-        catch (error) {
-            logger.error('Failed to close EventBreakpointManager:', error);
-            throw error;
-        }
-    }
-}

package/dist/src/modules/debugger/RuntimeInspector.d.ts

@@ -1,55 +0,0 @@
-import type { CodeCollector } from '../collector/CodeCollector.js';
-import type { DebuggerManager } from '../debugger/DebuggerManager.js';
-export interface VariableInfo {
-    name: string;
-    value: unknown;
-    type: string;
-    objectId?: string;
-    className?: string;
-    description?: string;
-}
-export interface ScopeVariables {
-    scopeType: string;
-    scopeName?: string;
-    variables: VariableInfo[];
-}
-export interface CallStackInfo {
-    callFrames: Array<{
-        callFrameId: string;
-        functionName: string;
-        location: {
-            scriptId: string;
-            url: string;
-            lineNumber: number;
-            columnNumber: number;
-        };
-        scopeChain: Array<{
-            type: string;
-            name?: string;
-        }>;
-    }>;
-    reason: string;
-    timestamp: number;
-}
-export declare class RuntimeInspector {
-    private collector;
-    private debuggerManager;
-    private cdpSession;
-    private enabled;
-    private initPromise?;
-    constructor(collector: CodeCollector, debuggerManager: DebuggerManager);
-    init(): Promise<void>;
-    private doInit;
-    enable(): Promise<void>;
-    enableAsyncStackTraces(maxDepth?: number): Promise<void>;
-    disableAsyncStackTraces(): Promise<void>;
-    disable(): Promise<void>;
-    getCallStack(): Promise<CallStackInfo | null>;
-    getScopeVariables(callFrameId: string): Promise<ScopeVariables[]>;
-    getCurrentScopeVariables(): Promise<ScopeVariables[]>;
-    getObjectProperties(objectId: string): Promise<VariableInfo[]>;
-    evaluate(expression: string, callFrameId?: string): Promise<unknown>;
-    evaluateGlobal(expression: string): Promise<unknown>;
-    private formatValue;
-    close(): Promise<void>;
-}

package/dist/src/modules/debugger/RuntimeInspector.js

@@ -1,296 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
-export class RuntimeInspector {
-    collector;
-    debuggerManager;
-    cdpSession = null;
-    enabled = false;
-    initPromise;
-    constructor(collector, debuggerManager) {
-        this.collector = collector;
-        this.debuggerManager = debuggerManager;
-    }
-    async init() {
-        if (this.enabled) {
-            return;
-        }
-        if (this.initPromise) {
-            return this.initPromise;
-        }
-        this.initPromise = this.doInit();
-        try {
-            return await this.initPromise;
-        }
-        finally {
-            this.initPromise = undefined;
-        }
-    }
-    async doInit() {
-        try {
-            const page = await this.collector.getActivePage();
-            this.cdpSession = await page.createCDPSession();
-            await this.cdpSession.send('Runtime.enable');
-            this.enabled = true;
-            logger.info('Runtime inspector enabled');
-        }
-        catch (error) {
-            logger.error('Failed to enable runtime inspector:', error);
-            throw error;
-        }
-    }
-    async enable() {
-        return this.init();
-    }
-    async enableAsyncStackTraces(maxDepth = 32) {
-        if (!this.enabled || !this.cdpSession) {
-            throw new PrerequisiteError('Runtime inspector not enabled. Call init() or enable() first.');
-        }
-        try {
-            await this.cdpSession.send('Debugger.setAsyncCallStackDepth', {
-                maxDepth,
-            });
-            logger.info(`Async stack traces enabled with max depth: ${maxDepth}`);
-        }
-        catch (error) {
-            logger.error('Failed to enable async stack traces:', error);
-            throw error;
-        }
-    }
-    async disableAsyncStackTraces() {
-        if (!this.enabled || !this.cdpSession) {
-            throw new PrerequisiteError('Runtime inspector not enabled');
-        }
-        try {
-            await this.cdpSession.send('Debugger.setAsyncCallStackDepth', {
-                maxDepth: 0,
-            });
-            logger.info('Async stack traces disabled');
-        }
-        catch (error) {
-            logger.error('Failed to disable async stack traces:', error);
-            throw error;
-        }
-    }
-    async disable() {
-        if (!this.enabled || !this.cdpSession) {
-            return;
-        }
-        try {
-            await this.cdpSession.send('Runtime.disable');
-            this.enabled = false;
-            await this.cdpSession.detach();
-            this.cdpSession = null;
-            logger.info('Runtime inspector disabled and cleaned up');
-        }
-        catch (error) {
-            logger.error('Failed to disable runtime inspector:', error);
-            throw error;
-        }
-        finally {
-            this.initPromise = undefined;
-        }
-    }
-    async getCallStack() {
-        const pausedState = this.debuggerManager.getPausedState();
-        if (!pausedState) {
-            logger.warn('Not in paused state, cannot get call stack');
-            return null;
-        }
-        try {
-            const callStackInfo = {
-                callFrames: pausedState.callFrames.map((frame) => ({
-                    callFrameId: frame.callFrameId,
-                    functionName: frame.functionName || '(anonymous)',
-                    location: {
-                        scriptId: frame.location.scriptId,
-                        url: frame.url,
-                        lineNumber: frame.location.lineNumber,
-                        columnNumber: frame.location.columnNumber,
-                    },
-                    scopeChain: frame.scopeChain.map((scope) => ({
-                        type: scope.type,
-                        name: scope.name,
-                    })),
-                })),
-                reason: pausedState.reason,
-                timestamp: pausedState.timestamp,
-            };
-            logger.info('Call stack retrieved', {
-                frameCount: callStackInfo.callFrames.length,
-                topFrame: callStackInfo.callFrames[0]?.functionName,
-            });
-            return callStackInfo;
-        }
-        catch (error) {
-            logger.error('Failed to get call stack:', error);
-            throw error;
-        }
-    }
-    async getScopeVariables(callFrameId) {
-        if (!this.enabled || !this.cdpSession) {
-            throw new PrerequisiteError('Runtime inspector is not enabled. Call init() or enable() first.');
-        }
-        if (!callFrameId) {
-            throw new Error('callFrameId parameter is required');
-        }
-        const pausedState = this.debuggerManager.getPausedState();
-        if (!pausedState) {
-            throw new PrerequisiteError('Not in paused state. Debugger must be paused to get scope variables.');
-        }
-        const callFrame = pausedState.callFrames.find((frame) => frame.callFrameId === callFrameId);
-        if (!callFrame) {
-            throw new Error(`Call frame not found: ${callFrameId}. Use getCallStack() to see available frames.`);
-        }
-        try {
-            const scopeVariablesList = [];
-            for (const scope of callFrame.scopeChain) {
-                if (!scope.object.objectId) {
-                    continue;
-                }
-                const properties = await this.getObjectProperties(scope.object.objectId);
-                scopeVariablesList.push({
-                    scopeType: scope.type,
-                    scopeName: scope.name,
-                    variables: properties,
-                });
-            }
-            logger.info(`Scope variables retrieved for call frame ${callFrameId}`, {
-                scopeCount: scopeVariablesList.length,
-            });
-            return scopeVariablesList;
-        }
-        catch (error) {
-            logger.error('Failed to get scope variables:', error);
-            throw error;
-        }
-    }
-    async getCurrentScopeVariables() {
-        const pausedState = this.debuggerManager.getPausedState();
-        if (!pausedState || pausedState.callFrames.length === 0) {
-            throw new PrerequisiteError('Not in paused state or no call frames');
-        }
-        const topFrame = pausedState.callFrames[0];
-        if (!topFrame) {
-            throw new PrerequisiteError('No top frame available');
-        }
-        return await this.getScopeVariables(topFrame.callFrameId);
-    }
-    async getObjectProperties(objectId) {
-        if (!this.enabled || !this.cdpSession) {
-            throw new PrerequisiteError('Runtime inspector is not enabled. Call init() or enable() first.');
-        }
-        if (!objectId) {
-            throw new Error('objectId parameter is required');
-        }
-        try {
-            const result = (await this.cdpSession.send('Runtime.getProperties', {
-                objectId,
-                ownProperties: true,
-                accessorPropertiesOnly: false,
-                generatePreview: true,
-            }));
-            const variables = [];
-            for (const prop of result.result) {
-                if (!prop.value) {
-                    continue;
-                }
-                variables.push({
-                    name: prop.name,
-                    value: this.formatValue(prop.value),
-                    type: prop.value.type || 'unknown',
-                    objectId: prop.value.objectId,
-                    className: prop.value.className,
-                    description: prop.value.description,
-                });
-            }
-            logger.info(`Object properties retrieved: ${objectId}`, {
-                propertyCount: variables.length,
-            });
-            return variables;
-        }
-        catch (error) {
-            logger.error('Failed to get object properties:', error);
-            throw error;
-        }
-    }
-    async evaluate(expression, callFrameId) {
-        if (!expression || expression.trim() === '') {
-            throw new Error('expression parameter is required and cannot be empty');
-        }
-        const pausedState = this.debuggerManager.getPausedState();
-        if (!pausedState) {
-            throw new PrerequisiteError('Not in paused state. Use evaluateGlobal() for global context evaluation.');
-        }
-        const targetCallFrameId = callFrameId || pausedState.callFrames[0]?.callFrameId;
-        if (!targetCallFrameId) {
-            throw new PrerequisiteError('No call frame available for evaluation');
-        }
-        try {
-            const result = await this.debuggerManager.evaluateOnCallFrame({
-                callFrameId: targetCallFrameId,
-                expression,
-                returnByValue: true,
-            });
-            logger.info(`Expression evaluated: ${expression}`, {
-                result: result.value,
-            });
-            return this.formatValue(result);
-        }
-        catch (error) {
-            logger.error('Failed to evaluate expression:', error);
-            throw error;
-        }
-    }
-    async evaluateGlobal(expression) {
-        if (!this.enabled || !this.cdpSession) {
-            throw new PrerequisiteError('Runtime inspector is not enabled. Call init() or enable() first.');
-        }
-        if (!expression || expression.trim() === '') {
-            throw new Error('expression parameter is required and cannot be empty');
-        }
-        try {
-            const result = (await this.cdpSession.send('Runtime.evaluate', {
-                expression,
-                returnByValue: true,
-            }));
-            logger.info(`Global expression evaluated: ${expression}`, {
-                result: result.result.value,
-            });
-            return this.formatValue(result.result);
-        }
-        catch (error) {
-            logger.error('Failed to evaluate global expression:', error);
-            throw error;
-        }
-    }
-    formatValue(remoteObject) {
-        if (!remoteObject || typeof remoteObject !== 'object') {
-            return remoteObject;
-        }
-        const candidate = remoteObject;
-        if (candidate.type === 'undefined') {
-            return undefined;
-        }
-        if (candidate.type === 'object' && candidate.subtype === 'null') {
-            return null;
-        }
-        if (candidate.value !== undefined) {
-            return candidate.value;
-        }
-        if (candidate.description) {
-            return candidate.description;
-        }
-        return `[${candidate.type || 'unknown'}]`;
-    }
-    async close() {
-        this.initPromise = undefined;
-        if (this.enabled) {
-            await this.disable();
-        }
-        if (this.cdpSession) {
-            await this.cdpSession.detach();
-            this.cdpSession = null;
-        }
-        logger.info('Runtime inspector closed');
-    }
-}

package/dist/src/modules/debugger/ScriptManager.d.ts

@@ -1,2 +0,0 @@
-export { ScriptManager } from '../debugger/ScriptManager.impl.js';
-export type { ScriptInfo } from '../debugger/ScriptManager.impl.js';

package/dist/src/modules/debugger/ScriptManager.impl.class.d.ts

@@ -1,86 +0,0 @@
-import type { CodeCollector } from '../collector/CodeCollector.js';
-import { type ExtractFunctionTreeResult } from '../debugger/ScriptManager.impl.extract-function-tree.js';
-export interface ScriptInfo {
-    scriptId: string;
-    url: string;
-    startLine: number;
-    startColumn: number;
-    endLine: number;
-    endColumn: number;
-    sourceLength?: number;
-    source?: string;
-}
-export declare class ScriptManager {
-    private collector;
-    private static readonly SOURCE_LOAD_BATCH_SIZE;
-    private static readonly SEARCH_LINE_YIELD_INTERVAL;
-    private static readonly SEARCH_SCRIPT_YIELD_INTERVAL;
-    private cdpSession;
-    private scripts;
-    private scriptsByUrl;
-    private initialized;
-    private initPromise?;
-    private keywordIndex;
-    private scriptChunks;
-    private readonly CHUNK_SIZE;
-    constructor(collector: CodeCollector);
-    init(): Promise<void>;
-    private doInit;
-    private loadScriptSourceInternal;
-    enable(): Promise<void>;
-    getAllScripts(includeSource?: boolean, maxScripts?: number): Promise<ScriptInfo[]>;
-    getScriptSource(scriptId?: string, url?: string): Promise<ScriptInfo | null>;
-    findScriptsByUrl(urlPattern: string): Promise<ScriptInfo[]>;
-    clearCache(): void;
-    searchInScripts(keyword: string, options?: {
-        isRegex?: boolean;
-        caseSensitive?: boolean;
-        contextLines?: number;
-        maxMatches?: number;
-    }): Promise<{
-        keyword: string;
-        totalMatches: number;
-        matches: Array<{
-            scriptId: string;
-            url: string;
-            line: number;
-            column: number;
-            matchText: string;
-            context: string;
-        }>;
-    }>;
-    extractFunctionTree(scriptId: string, functionName: string, options?: {
-        maxDepth?: number;
-        maxSize?: number;
-        includeComments?: boolean;
-    }): Promise<ExtractFunctionTreeResult>;
-    clear(): void;
-    close(): Promise<void>;
-    getStats(): {
-        totalScripts: number;
-        totalUrls: number;
-        indexedKeywords: number;
-        totalChunks: number;
-    };
-    private buildKeywordIndex;
-    private chunkScript;
-    getScriptChunk(scriptId: string, chunkIndex: number): string | null;
-    searchInScriptsEnhanced(keyword: string, options?: {
-        isRegex?: boolean;
-        caseSensitive?: boolean;
-        contextLines?: number;
-        maxMatches?: number;
-    }): Promise<{
-        keyword: string;
-        totalMatches: number;
-        matches: Array<{
-            scriptId: string;
-            url: string;
-            line: number;
-            column: number;
-            matchText: string;
-            context: string;
-        }>;
-        searchMethod: 'indexed' | 'regex';
-    }>;
-}