@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/modules/debugger/DebuggerManager.impl.core.class.d.ts

@@ -1,163 +0,0 @@
-import type { CDPSession } from 'rebrowser-puppeteer-core';
-import type { CodeCollector } from '../collector/CodeCollector.js';
-import type { ScopeVariable, BreakpointHitCallback, DebuggerSession, GetScopeVariablesOptions, GetScopeVariablesResult } from '../../types/index.js';
-import { WatchExpressionManager } from '../debugger/WatchExpressionManager.js';
-import { XHRBreakpointManager } from '../debugger/XHRBreakpointManager.js';
-import { EventBreakpointManager } from '../debugger/EventBreakpointManager.js';
-import { BlackboxManager } from '../debugger/BlackboxManager.js';
-import { type EvaluateOnCallFrameValue } from '../debugger/DebuggerManager.impl.core.execution.js';
-export interface BreakpointInfo {
-    breakpointId: string;
-    location: {
-        scriptId?: string;
-        url?: string;
-        lineNumber: number;
-        columnNumber?: number;
-    };
-    condition?: string;
-    enabled: boolean;
-    hitCount: number;
-    createdAt: number;
-}
-export interface PausedState {
-    callFrames: CallFrame[];
-    reason: string;
-    data?: unknown;
-    hitBreakpoints?: string[];
-    timestamp: number;
-}
-export interface CallFrame {
-    callFrameId: string;
-    functionName: string;
-    location: {
-        scriptId: string;
-        lineNumber: number;
-        columnNumber: number;
-    };
-    url: string;
-    scopeChain: Scope[];
-    this: unknown;
-}
-export interface Scope {
-    type: 'global' | 'local' | 'with' | 'closure' | 'catch' | 'block' | 'script' | 'eval' | 'module';
-    object: {
-        type: string;
-        objectId?: string;
-        className?: string;
-        description?: string;
-    };
-    name?: string;
-    startLocation?: {
-        scriptId: string;
-        lineNumber: number;
-        columnNumber: number;
-    };
-    endLocation?: {
-        scriptId: string;
-        lineNumber: number;
-        columnNumber: number;
-    };
-}
-export interface ObjectPropertyInfo {
-    name: string;
-    value: unknown;
-    type: string;
-    objectId?: string;
-    className?: string;
-    description?: string;
-}
-export declare class DebuggerManager {
-    private collector;
-    private cdpSession;
-    private enabled;
-    private initPromise?;
-    private breakpoints;
-    private pausedState;
-    private pausedResolvers;
-    private breakpointHitCallbacks;
-    private pauseOnExceptionsState;
-    private _watchManager;
-    private _xhrManager;
-    private _eventManager;
-    private _blackboxManager;
-    private advancedFeatureSession;
-    private pausedListener;
-    private resumedListener;
-    private breakpointResolvedListener;
-    private sessionManager;
-    constructor(collector: CodeCollector);
-    private touchInternalStateForTypeCheck;
-    getBreakpoints(): ReadonlyMap<string, BreakpointInfo>;
-    getCDPSession(): CDPSession;
-    getWatchManager(): WatchExpressionManager;
-    getXHRManager(): XHRBreakpointManager;
-    getEventManager(): EventBreakpointManager;
-    getBlackboxManager(): BlackboxManager;
-    init(): Promise<void>;
-    private doInit;
-    ensureSession(): Promise<void>;
-    isSessionConnected(): boolean;
-    enable(): Promise<void>;
-    initAdvancedFeatures(runtimeInspector?: ConstructorParameters<typeof WatchExpressionManager>[0]): Promise<void>;
-    ensureAdvancedFeatures(): Promise<void>;
-    disable(): Promise<void>;
-    isEnabled(): boolean;
-    setBreakpointByUrl(params: {
-        url: string;
-        lineNumber: number;
-        columnNumber?: number;
-        condition?: string;
-    }): Promise<BreakpointInfo>;
-    setBreakpoint(params: {
-        scriptId: string;
-        lineNumber: number;
-        columnNumber?: number;
-        condition?: string;
-    }): Promise<BreakpointInfo>;
-    removeBreakpoint(breakpointId: string): Promise<void>;
-    listBreakpoints(): BreakpointInfo[];
-    getBreakpoint(breakpointId: string): BreakpointInfo | undefined;
-    clearAllBreakpoints(): Promise<void>;
-    setPauseOnExceptions(state: 'none' | 'uncaught' | 'all'): Promise<void>;
-    getPauseOnExceptionsState(): 'none' | 'uncaught' | 'all';
-    pause(): Promise<void>;
-    resume(): Promise<void>;
-    stepInto(): Promise<void>;
-    stepOver(): Promise<void>;
-    stepOut(): Promise<void>;
-    getPausedState(): PausedState | null;
-    isPaused(): boolean;
-    waitForPaused(timeout?: number): Promise<PausedState>;
-    evaluateOnCallFrame(params: {
-        callFrameId: string;
-        expression: string;
-        returnByValue?: boolean;
-    }): Promise<EvaluateOnCallFrameValue>;
-    getScopeVariables(options?: GetScopeVariablesOptions): Promise<GetScopeVariablesResult>;
-    getObjectPropertiesById(objectId: string): Promise<ObjectPropertyInfo[]>;
-    getObjectProperties(objectId: string, maxDepth: number): Promise<ScopeVariable[]>;
-    onBreakpointHit(callback: BreakpointHitCallback): void;
-    offBreakpointHit(callback: BreakpointHitCallback): void;
-    clearBreakpointHitCallbacks(): void;
-    getBreakpointHitCallbackCount(): number;
-    private handlePaused;
-    private handleResumed;
-    private handleBreakpointResolved;
-    exportSession(metadata?: DebuggerSession['metadata']): DebuggerSession;
-    saveSession(filePath?: string, metadata?: DebuggerSession['metadata']): Promise<string>;
-    loadSessionFromFile(filePath: string): Promise<void>;
-    importSession(sessionData: DebuggerSession | string): Promise<void>;
-    listSavedSessions(): Promise<Array<{
-        path: string;
-        timestamp: number;
-        metadata?: unknown;
-    }>>;
-    close(): Promise<void>;
-    private normalizePausedEventParams;
-    private normalizeBreakpointResolvedParams;
-    private normalizeCallFrame;
-    private normalizeScope;
-    private normalizeScriptLocation;
-    private normalizeScopeType;
-    private asRecord;
-}

package/dist/src/modules/debugger/DebuggerManager.impl.core.class.js

@@ -1,416 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { DEBUGGER_WAIT_FOR_PAUSED_TIMEOUT_MS } from '../../constants.js';
-import { WatchExpressionManager } from '../debugger/WatchExpressionManager.js';
-import { XHRBreakpointManager } from '../debugger/XHRBreakpointManager.js';
-import { EventBreakpointManager } from '../debugger/EventBreakpointManager.js';
-import { BlackboxManager } from '../debugger/BlackboxManager.js';
-import { DebuggerSessionManager } from '../debugger/DebuggerSessionManager.js';
-import { clearAllBreakpointsCore, getBreakpointCore, listBreakpointsCore, removeBreakpointCore, setBreakpointByUrlCore, setBreakpointCore, } from '../debugger/DebuggerManager.impl.core.breakpoints.js';
-import { evaluateOnCallFrameCore, getPauseOnExceptionsStateCore, getPausedStateCore, isPausedCore, pauseCore, resumeCore, setPauseOnExceptionsCore, stepIntoCore, stepOutCore, stepOverCore, waitForPausedCore, } from '../debugger/DebuggerManager.impl.core.execution.js';
-import { getObjectPropertiesByIdCore, getObjectPropertiesCore, getScopeVariablesCore, } from '../debugger/DebuggerManager.impl.core.scope.js';
-import { clearBreakpointHitCallbacksCore, getBreakpointHitCallbackCountCore, handleBreakpointResolvedCore, handlePausedCore, handleResumedCore, offBreakpointHitCore, onBreakpointHitCore, } from '../debugger/DebuggerManager.impl.core.events.js';
-export class DebuggerManager {
-    collector;
-    cdpSession = null;
-    enabled = false;
-    initPromise;
-    breakpoints = new Map();
-    pausedState = null;
-    pausedResolvers = [];
-    breakpointHitCallbacks = new Set();
-    pauseOnExceptionsState = 'none';
-    _watchManager = null;
-    _xhrManager = null;
-    _eventManager = null;
-    _blackboxManager = null;
-    advancedFeatureSession = null;
-    pausedListener = null;
-    resumedListener = null;
-    breakpointResolvedListener = null;
-    sessionManager;
-    constructor(collector) {
-        this.collector = collector;
-        this.sessionManager = new DebuggerSessionManager(this);
-        this.touchInternalStateForTypeCheck();
-    }
-    touchInternalStateForTypeCheck() {
-        void this.pausedState;
-        void this.pausedResolvers;
-        void this.breakpointHitCallbacks;
-        void this.pauseOnExceptionsState;
-    }
-    getBreakpoints() {
-        return this.breakpoints;
-    }
-    getCDPSession() {
-        if (!this.cdpSession || !this.enabled) {
-            throw new Error('Debugger not enabled. Call init() or enable() first to get CDP session.');
-        }
-        return this.cdpSession;
-    }
-    getWatchManager() {
-        if (!this._watchManager) {
-            throw new Error('WatchExpressionManager not initialized. Call initAdvancedFeatures() first.');
-        }
-        return this._watchManager;
-    }
-    getXHRManager() {
-        if (!this._xhrManager) {
-            throw new Error('XHRBreakpointManager not initialized. Call initAdvancedFeatures() first.');
-        }
-        return this._xhrManager;
-    }
-    getEventManager() {
-        if (!this._eventManager) {
-            throw new Error('EventBreakpointManager not initialized. Call initAdvancedFeatures() first.');
-        }
-        return this._eventManager;
-    }
-    getBlackboxManager() {
-        if (!this._blackboxManager) {
-            throw new Error('BlackboxManager not initialized. Call initAdvancedFeatures() first.');
-        }
-        return this._blackboxManager;
-    }
-    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();
-            this.cdpSession.on('disconnected', () => {
-                logger.warn('CDP session disconnected, marking as disabled');
-                this.enabled = false;
-                this.cdpSession = null;
-                this.advancedFeatureSession = null;
-                this._xhrManager = null;
-                this._eventManager = null;
-                this._blackboxManager = null;
-            });
-            await this.cdpSession.send('Debugger.enable');
-            this.enabled = true;
-            this.pausedListener = (params) => this.handlePaused(params);
-            this.resumedListener = () => this.handleResumed();
-            this.breakpointResolvedListener = (params) => this.handleBreakpointResolved(params);
-            this.cdpSession.on('Debugger.paused', this.pausedListener);
-            this.cdpSession.on('Debugger.resumed', this.resumedListener);
-            this.cdpSession.on('Debugger.breakpointResolved', this.breakpointResolvedListener);
-            logger.info('Debugger enabled successfully');
-        }
-        catch (error) {
-            logger.error('Failed to enable debugger:', error);
-            throw error;
-        }
-    }
-    async ensureSession() {
-        if (!this.enabled || !this.cdpSession) {
-            logger.info('CDP session not active, reinitializing...');
-            await this.init();
-        }
-    }
-    isSessionConnected() {
-        return this.enabled && this.cdpSession !== null;
-    }
-    async enable() {
-        return this.init();
-    }
-    async initAdvancedFeatures(runtimeInspector) {
-        if (!this.enabled || !this.cdpSession) {
-            throw new Error('Debugger must be enabled before initializing advanced features. Call init() first.');
-        }
-        try {
-            if (runtimeInspector) {
-                this._watchManager = new WatchExpressionManager(runtimeInspector);
-                logger.info('WatchExpressionManager initialized');
-            }
-            this._xhrManager = new XHRBreakpointManager(this.cdpSession);
-            logger.info('XHRBreakpointManager initialized');
-            this._eventManager = new EventBreakpointManager(this.cdpSession);
-            logger.info('EventBreakpointManager initialized');
-            this._blackboxManager = new BlackboxManager(this.cdpSession);
-            logger.info('BlackboxManager initialized');
-            this.advancedFeatureSession = this.cdpSession;
-            logger.info('All advanced debugging features initialized');
-        }
-        catch (error) {
-            logger.error('Failed to initialize advanced features:', error);
-            throw error;
-        }
-    }
-    async ensureAdvancedFeatures() {
-        await this.ensureSession();
-        if (!this.cdpSession) {
-            throw new Error('CDP session unavailable after reconnect.');
-        }
-        const needsReinit = this.advancedFeatureSession !== this.cdpSession ||
-            !this._xhrManager ||
-            !this._eventManager ||
-            !this._blackboxManager;
-        if (needsReinit) {
-            await this.initAdvancedFeatures();
-        }
-    }
-    async disable() {
-        if (!this.enabled || !this.cdpSession) {
-            logger.warn('Debugger not enabled');
-            return;
-        }
-        try {
-            if (this._xhrManager) {
-                await this._xhrManager.close();
-                this._xhrManager = null;
-            }
-            if (this._eventManager) {
-                await this._eventManager.close();
-                this._eventManager = null;
-            }
-            if (this._blackboxManager) {
-                await this._blackboxManager.close();
-                this._blackboxManager = null;
-            }
-            if (this._watchManager) {
-                this._watchManager.clearAll();
-                this._watchManager = null;
-            }
-            if (this.pausedListener) {
-                this.cdpSession.off('Debugger.paused', this.pausedListener);
-                this.pausedListener = null;
-            }
-            if (this.resumedListener) {
-                this.cdpSession.off('Debugger.resumed', this.resumedListener);
-                this.resumedListener = null;
-            }
-            if (this.breakpointResolvedListener) {
-                this.cdpSession.off('Debugger.breakpointResolved', this.breakpointResolvedListener);
-                this.breakpointResolvedListener = null;
-            }
-            await this.cdpSession.send('Debugger.disable');
-        }
-        catch (error) {
-            logger.error('Failed to disable debugger:', error);
-        }
-        finally {
-            this.initPromise = undefined;
-            this.enabled = false;
-            this.breakpoints.clear();
-            this.pausedState = null;
-            this.pausedResolvers = [];
-            this.advancedFeatureSession = null;
-            if (this.cdpSession) {
-                try {
-                    await this.cdpSession.detach();
-                }
-                catch (e) {
-                    logger.warn('Failed to detach CDP session:', e);
-                }
-                this.cdpSession = null;
-            }
-            logger.info('Debugger disabled and cleaned up');
-        }
-    }
-    isEnabled() {
-        return this.enabled;
-    }
-    async setBreakpointByUrl(params) {
-        return setBreakpointByUrlCore(this, params);
-    }
-    async setBreakpoint(params) {
-        return setBreakpointCore(this, params);
-    }
-    async removeBreakpoint(breakpointId) {
-        return removeBreakpointCore(this, breakpointId);
-    }
-    listBreakpoints() {
-        return listBreakpointsCore(this);
-    }
-    getBreakpoint(breakpointId) {
-        return getBreakpointCore(this, breakpointId);
-    }
-    async clearAllBreakpoints() {
-        return clearAllBreakpointsCore(this);
-    }
-    async setPauseOnExceptions(state) {
-        return setPauseOnExceptionsCore(this, state);
-    }
-    getPauseOnExceptionsState() {
-        return getPauseOnExceptionsStateCore(this);
-    }
-    async pause() {
-        return pauseCore(this);
-    }
-    async resume() {
-        return resumeCore(this);
-    }
-    async stepInto() {
-        return stepIntoCore(this);
-    }
-    async stepOver() {
-        return stepOverCore(this);
-    }
-    async stepOut() {
-        return stepOutCore(this);
-    }
-    getPausedState() {
-        return getPausedStateCore(this);
-    }
-    isPaused() {
-        return isPausedCore(this);
-    }
-    async waitForPaused(timeout = DEBUGGER_WAIT_FOR_PAUSED_TIMEOUT_MS) {
-        return waitForPausedCore(this, timeout);
-    }
-    async evaluateOnCallFrame(params) {
-        return evaluateOnCallFrameCore(this, params);
-    }
-    async getScopeVariables(options = {}) {
-        return getScopeVariablesCore(this, options);
-    }
-    async getObjectPropertiesById(objectId) {
-        return getObjectPropertiesByIdCore(this, objectId);
-    }
-    async getObjectProperties(objectId, maxDepth) {
-        return getObjectPropertiesCore(this, objectId, maxDepth);
-    }
-    onBreakpointHit(callback) {
-        onBreakpointHitCore(this, callback);
-    }
-    offBreakpointHit(callback) {
-        offBreakpointHitCore(this, callback);
-    }
-    clearBreakpointHitCallbacks() {
-        clearBreakpointHitCallbacksCore(this);
-    }
-    getBreakpointHitCallbackCount() {
-        return getBreakpointHitCallbackCountCore(this);
-    }
-    async handlePaused(params) {
-        return handlePausedCore(this, this.normalizePausedEventParams(params));
-    }
-    handleResumed() {
-        handleResumedCore(this);
-    }
-    handleBreakpointResolved(params) {
-        handleBreakpointResolvedCore(this, this.normalizeBreakpointResolvedParams(params));
-    }
-    exportSession(metadata) {
-        return this.sessionManager.exportSession(metadata);
-    }
-    async saveSession(filePath, metadata) {
-        return this.sessionManager.saveSession(filePath, metadata);
-    }
-    async loadSessionFromFile(filePath) {
-        return this.sessionManager.loadSessionFromFile(filePath);
-    }
-    async importSession(sessionData) {
-        return this.sessionManager.importSession(sessionData);
-    }
-    async listSavedSessions() {
-        return this.sessionManager.listSavedSessions();
-    }
-    async close() {
-        this.initPromise = undefined;
-        if (this.enabled) {
-            await this.disable();
-        }
-        if (this.cdpSession) {
-            await this.cdpSession.detach();
-            this.cdpSession = null;
-        }
-        logger.info('Debugger manager closed');
-    }
-    normalizePausedEventParams(params) {
-        const event = this.asRecord(params);
-        const callFrames = Array.isArray(event.callFrames) ? event.callFrames : [];
-        return {
-            callFrames: callFrames.map((frame) => this.normalizeCallFrame(frame)),
-            reason: typeof event.reason === 'string' ? event.reason : 'unknown',
-            data: event.data,
-            hitBreakpoints: Array.isArray(event.hitBreakpoints)
-                ? event.hitBreakpoints.filter((bp) => typeof bp === 'string')
-                : undefined,
-        };
-    }
-    normalizeBreakpointResolvedParams(params) {
-        const event = this.asRecord(params);
-        return {
-            breakpointId: typeof event.breakpointId === 'string' ? event.breakpointId : '',
-            location: event.location,
-        };
-    }
-    normalizeCallFrame(frame) {
-        const callFrame = this.asRecord(frame);
-        const location = this.asRecord(callFrame.location);
-        const scopeChain = Array.isArray(callFrame.scopeChain) ? callFrame.scopeChain : [];
-        return {
-            callFrameId: typeof callFrame.callFrameId === 'string' ? callFrame.callFrameId : '',
-            functionName: typeof callFrame.functionName === 'string' ? callFrame.functionName : '',
-            location: {
-                scriptId: typeof location.scriptId === 'string' ? location.scriptId : '',
-                lineNumber: typeof location.lineNumber === 'number' ? location.lineNumber : 0,
-                columnNumber: typeof location.columnNumber === 'number' ? location.columnNumber : 0,
-            },
-            url: typeof callFrame.url === 'string' ? callFrame.url : '',
-            scopeChain: scopeChain.map((scope) => this.normalizeScope(scope)),
-            this: callFrame.this,
-        };
-    }
-    normalizeScope(scope) {
-        const scopeObj = this.asRecord(scope);
-        const object = this.asRecord(scopeObj.object);
-        const startLocation = this.normalizeScriptLocation(scopeObj.startLocation);
-        const endLocation = this.normalizeScriptLocation(scopeObj.endLocation);
-        return {
-            type: this.normalizeScopeType(scopeObj.type),
-            object: {
-                type: typeof object.type === 'string' ? object.type : 'object',
-                objectId: typeof object.objectId === 'string' ? object.objectId : undefined,
-                className: typeof object.className === 'string' ? object.className : undefined,
-                description: typeof object.description === 'string' ? object.description : undefined,
-            },
-            name: typeof scopeObj.name === 'string' ? scopeObj.name : undefined,
-            startLocation,
-            endLocation,
-        };
-    }
-    normalizeScriptLocation(location) {
-        const locationObj = this.asRecord(location);
-        if (Object.keys(locationObj).length === 0) {
-            return undefined;
-        }
-        return {
-            scriptId: typeof locationObj.scriptId === 'string' ? locationObj.scriptId : '',
-            lineNumber: typeof locationObj.lineNumber === 'number' ? locationObj.lineNumber : 0,
-            columnNumber: typeof locationObj.columnNumber === 'number' ? locationObj.columnNumber : 0,
-        };
-    }
-    normalizeScopeType(value) {
-        if (value === 'global' ||
-            value === 'local' ||
-            value === 'with' ||
-            value === 'closure' ||
-            value === 'catch' ||
-            value === 'block' ||
-            value === 'script' ||
-            value === 'eval' ||
-            value === 'module') {
-            return value;
-        }
-        return 'local';
-    }
-    asRecord(value) {
-        return typeof value === 'object' && value !== null ? value : {};
-    }
-}

package/dist/src/modules/debugger/DebuggerManager.impl.core.d.ts

@@ -1,2 +0,0 @@
-export type { BreakpointInfo, CallFrame, ObjectPropertyInfo, PausedState, Scope, } from '../debugger/DebuggerManager.impl.core.class.js';
-export { DebuggerManager } from '../debugger/DebuggerManager.impl.core.class.js';

package/dist/src/modules/debugger/DebuggerManager.impl.core.events.d.ts

@@ -1,20 +0,0 @@
-import type { BreakpointHitCallback } from '../../types/index.js';
-import type { CallFrame } from '../debugger/DebuggerManager.impl.core.class.js';
-interface PausedEventParams {
-    callFrames: CallFrame[];
-    reason: string;
-    data?: unknown;
-    hitBreakpoints?: string[];
-}
-interface BreakpointResolvedParams {
-    breakpointId: string;
-    location?: unknown;
-}
-export declare function onBreakpointHitCore(ctx: unknown, callback: BreakpointHitCallback): void;
-export declare function offBreakpointHitCore(ctx: unknown, callback: BreakpointHitCallback): void;
-export declare function clearBreakpointHitCallbacksCore(ctx: unknown): void;
-export declare function getBreakpointHitCallbackCountCore(ctx: unknown): number;
-export declare function handlePausedCore(ctx: unknown, params: PausedEventParams): Promise<void>;
-export declare function handleResumedCore(ctx: unknown): void;
-export declare function handleBreakpointResolvedCore(ctx: unknown, params: BreakpointResolvedParams): void;
-export {};