@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/modules/hook/HookManager.js

@@ -1,229 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { generateHookScript, getInjectionInstructions, generateAntiDebugBypass, generateHookTemplate, generateHookChain, } from '../hook/HookGenerator.js';
-export class HookManager {
-    hooks = new Map();
-    hookScripts = new Map();
-    hookMetadata = new Map();
-    hookConditions = new Map();
-    MAX_HOOK_RECORDS = 1000;
-    MAX_TOTAL_RECORDS = 10000;
-    async createHook(options) {
-        logger.info(`Creating hook for ${options.target} (type: ${options.type})...`);
-        try {
-            const { target, type, action = 'log', condition, performance = false } = options;
-            const hookScript = generateHookScript(target, type, action, options.customCode, condition, performance);
-            const hookId = `${target}-${type}-${Date.now()}`;
-            this.hookScripts.set(hookId, hookScript);
-            if (condition) {
-                this.hookConditions.set(hookId, condition);
-            }
-            this.hookMetadata.set(hookId, {
-                id: hookId,
-                enabled: true,
-                createdAt: Date.now(),
-                callCount: 0,
-                totalExecutionTime: 0,
-            });
-            logger.success(`Hook created: ${hookId}`);
-            return {
-                hookId,
-                script: hookScript,
-                instructions: getInjectionInstructions(type),
-            };
-        }
-        catch (error) {
-            logger.error('Failed to create hook', error);
-            throw error;
-        }
-    }
-    recordHookEvent(hookId, context) {
-        const record = {
-            hookId,
-            timestamp: Date.now(),
-            context,
-        };
-        const records = this.hooks.get(hookId) || [];
-        records.push(record);
-        this.hooks.set(hookId, records);
-        logger.debug(`Hook event recorded: ${hookId}`);
-    }
-    getHookRecords(hookId) {
-        return this.hooks.get(hookId) || [];
-    }
-    clearHookRecords(hookId) {
-        if (hookId) {
-            this.hooks.delete(hookId);
-            logger.info(`Cleared records for hook: ${hookId}`);
-        }
-        else {
-            this.hooks.clear();
-            logger.info('Cleared all hook records');
-        }
-    }
-    enableHook(hookId) {
-        const metadata = this.hookMetadata.get(hookId);
-        if (metadata) {
-            metadata.enabled = true;
-            logger.info(`Hook enabled: ${hookId}`);
-        }
-        else {
-            logger.warn(`Hook not found: ${hookId}`);
-        }
-    }
-    disableHook(hookId) {
-        const metadata = this.hookMetadata.get(hookId);
-        if (metadata) {
-            metadata.enabled = false;
-            logger.info(`Hook disabled: ${hookId}`);
-        }
-        else {
-            logger.warn(`Hook not found: ${hookId}`);
-        }
-    }
-    getHookMetadata(hookId) {
-        return this.hookMetadata.get(hookId);
-    }
-    getAllHookMetadata() {
-        return Array.from(this.hookMetadata.values());
-    }
-    exportHookData(hookId) {
-        if (hookId) {
-            const metadata = this.hookMetadata.get(hookId);
-            const records = this.hooks.get(hookId) || [];
-            const script = this.hookScripts.get(hookId) || '';
-            return {
-                metadata: metadata ? [metadata] : [],
-                records: { [hookId]: records },
-                scripts: { [hookId]: script },
-            };
-        }
-        const metadata = Array.from(this.hookMetadata.values());
-        const records = {};
-        const scripts = {};
-        this.hooks.forEach((value, key) => {
-            records[key] = value;
-        });
-        this.hookScripts.forEach((value, key) => {
-            scripts[key] = value;
-        });
-        return { metadata, records, scripts };
-    }
-    getHookStats(hookId) {
-        const metadata = this.hookMetadata.get(hookId);
-        if (!metadata) {
-            return null;
-        }
-        return {
-            callCount: metadata.callCount,
-            avgExecutionTime: metadata.callCount > 0 ? metadata.totalExecutionTime / metadata.callCount : 0,
-            totalExecutionTime: metadata.totalExecutionTime,
-            enabled: metadata.enabled,
-        };
-    }
-    deleteHook(hookId) {
-        this.hookScripts.delete(hookId);
-        this.hookMetadata.delete(hookId);
-        this.hookConditions.delete(hookId);
-        this.hooks.delete(hookId);
-        logger.info(`Hook deleted: ${hookId}`);
-    }
-    getAllHooks() {
-        return Array.from(this.hookScripts.keys());
-    }
-    recordHookCall(hookId, record) {
-        if (!this.hooks.has(hookId)) {
-            this.hooks.set(hookId, []);
-        }
-        const records = this.hooks.get(hookId);
-        if (records.length >= this.MAX_HOOK_RECORDS) {
-            records.shift();
-            logger.debug(`Hook ${hookId} reached max records, removed oldest`);
-        }
-        records.push(record);
-        const totalRecords = Array.from(this.hooks.values()).reduce((sum, arr) => sum + arr.length, 0);
-        if (totalRecords > this.MAX_TOTAL_RECORDS) {
-            this.cleanupOldestRecords();
-        }
-        const metadata = this.hookMetadata.get(hookId);
-        if (metadata) {
-            metadata.callCount++;
-            metadata.lastCalled = Date.now();
-        }
-    }
-    cleanupOldestRecords() {
-        let oldestHookId = null;
-        let oldestTimestamp = Infinity;
-        for (const [hookId, records] of this.hooks.entries()) {
-            if (records.length > 0) {
-                const firstRecord = records[0];
-                if (firstRecord && firstRecord.timestamp < oldestTimestamp) {
-                    oldestTimestamp = firstRecord.timestamp;
-                    oldestHookId = hookId;
-                }
-            }
-        }
-        if (oldestHookId) {
-            const records = this.hooks.get(oldestHookId);
-            const removeCount = Math.floor(records.length / 2);
-            records.splice(0, removeCount);
-            logger.warn(`Cleaned up ${removeCount} old records from ${oldestHookId} (total records exceeded limit)`);
-        }
-    }
-    getHookRecordsStats() {
-        let totalRecords = 0;
-        let oldestRecord = null;
-        let newestRecord = null;
-        const recordsByHook = {};
-        for (const [hookId, records] of this.hooks.entries()) {
-            recordsByHook[hookId] = records.length;
-            totalRecords += records.length;
-            if (records.length > 0) {
-                const firstRecord = records[0];
-                const lastRecord = records[records.length - 1];
-                if (firstRecord) {
-                    const firstTimestamp = firstRecord.timestamp;
-                    if (oldestRecord === null || firstTimestamp < oldestRecord) {
-                        oldestRecord = firstTimestamp;
-                    }
-                }
-                if (lastRecord) {
-                    const lastTimestamp = lastRecord.timestamp;
-                    if (newestRecord === null || lastTimestamp > newestRecord) {
-                        newestRecord = lastTimestamp;
-                    }
-                }
-            }
-        }
-        return {
-            totalHooks: this.hooks.size,
-            totalRecords,
-            recordsByHook,
-            oldestRecord,
-            newestRecord,
-        };
-    }
-    async createBatchHooks(targets) {
-        logger.info(`Creating ${targets.length} hooks...`);
-        const results = [];
-        for (const { target, type, action = 'log' } of targets) {
-            try {
-                const result = await this.createHook({ target, type, action });
-                results.push(result);
-            }
-            catch (error) {
-                logger.error(`Failed to create hook for ${target}:`, error);
-            }
-        }
-        logger.success(`Created ${results.length}/${targets.length} hooks`);
-        return results;
-    }
-    generateAntiDebugBypass() {
-        return generateAntiDebugBypass();
-    }
-    generateHookTemplate(targetName, targetType) {
-        return generateHookTemplate(targetName, targetType);
-    }
-    generateHookChain(hooks) {
-        return generateHookChain(hooks);
-    }
-}

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

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

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

@@ -1,158 +0,0 @@
-import type { CodeCollector } from '../collector/CodeCollector.js';
-import type { FetchInterceptRule, FetchInterceptRuleInput } from '../monitor/FetchInterceptor.js';
-import type { InspectedObjectProperties } from '../monitor/ConsoleMonitor.impl.core.object-cache.js';
-export type { NetworkRequest, NetworkResponse } from '../monitor/NetworkMonitor.js';
-export type { FetchInterceptRule, FetchInterceptRuleInput, } from '../monitor/FetchInterceptor.js';
-type ConsoleMessageType = 'log' | 'warn' | 'error' | 'info' | 'debug' | 'trace' | 'dir' | 'table';
-export interface ConsoleMessage {
-    type: ConsoleMessageType | string;
-    text: string;
-    args?: unknown[];
-    timestamp: number;
-    stackTrace?: StackFrame[];
-    url?: string;
-    lineNumber?: number;
-    columnNumber?: number;
-}
-export interface StackFrame {
-    functionName: string;
-    url: string;
-    lineNumber: number;
-    columnNumber: number;
-}
-export interface ExceptionInfo {
-    text: string;
-    exceptionId: number;
-    timestamp: number;
-    stackTrace?: StackFrame[];
-    url?: string;
-    lineNumber?: number;
-    columnNumber?: number;
-    scriptId?: string;
-}
-export declare class ConsoleMonitor {
-    private collector;
-    private cdpSession;
-    private networkMonitor;
-    private fetchInterceptor;
-    private playwrightNetworkMonitor;
-    private playwrightPage;
-    private playwrightConsoleHandler;
-    private playwrightErrorHandler;
-    private messages;
-    private readonly MAX_MESSAGES;
-    private exceptions;
-    private readonly MAX_EXCEPTIONS;
-    private readonly MAX_INJECTED_DYNAMIC_SCRIPTS;
-    private readonly MAX_OBJECT_CACHE_SIZE;
-    private objectCache;
-    private initPromise?;
-    private lastEnableOptions;
-    constructor(collector: CodeCollector);
-    private touchSplitMembersForTypeCheck;
-    setPlaywrightPage(page: unknown): void;
-    clearPlaywrightPage(): void;
-    enable(options?: {
-        enableNetwork?: boolean;
-        enableExceptions?: boolean;
-    }): Promise<void>;
-    private doEnable;
-    private applyPostEnableOptions;
-    private enablePlaywright;
-    disable(): Promise<void>;
-    ensureSession(): Promise<void>;
-    isSessionActive(): boolean;
-    getLogs(filter?: {
-        type?: 'log' | 'warn' | 'error' | 'info' | 'debug';
-        limit?: number;
-        since?: number;
-    }): ConsoleMessage[];
-    execute(expression: string): Promise<unknown>;
-    clearLogs(): void;
-    getStats(): {
-        totalMessages: number;
-        byType: Record<string, number>;
-    };
-    close(): Promise<void>;
-    isNetworkEnabled(): boolean;
-    getNetworkStatus(): {
-        enabled: boolean;
-        requestCount: number;
-        responseCount: number;
-        listenerCount: number;
-        cdpSessionActive: boolean;
-    };
-    getNetworkRequests(filter?: {
-        url?: string;
-        method?: string;
-        limit?: number;
-    }): import("../monitor/NetworkMonitor.js").NetworkRequest[];
-    getNetworkResponses(filter?: {
-        url?: string;
-        status?: number;
-        limit?: number;
-    }): import("../monitor/NetworkMonitor.js").NetworkResponse[];
-    getNetworkActivity(requestId: string): {
-        request?: import("../monitor/NetworkMonitor.js").NetworkRequest;
-        response?: import("../monitor/NetworkMonitor.js").NetworkResponse;
-    };
-    getResponseBody(requestId: string): Promise<{
-        body: string;
-        base64Encoded: boolean;
-    } | null>;
-    getAllJavaScriptResponses(): Promise<{
-        [x: string]: unknown;
-    }[]>;
-    clearNetworkRecords(): void;
-    clearInjectedBuffers(): Promise<{
-        xhrCleared: number;
-        fetchCleared: number;
-        dynamicScriptsCleared: number;
-    }>;
-    resetInjectedInterceptors(): Promise<{
-        xhrReset: boolean;
-        fetchReset: boolean;
-        scriptMonitorReset: boolean;
-    }>;
-    getNetworkStats(): import("../monitor/ConsoleMonitor.impl.core.network.js").NetworkStats;
-    injectXHRInterceptor(options?: {
-        persistent?: boolean;
-    }): Promise<void>;
-    injectFetchInterceptor(options?: {
-        persistent?: boolean;
-    }): Promise<void>;
-    getXHRRequests(): Promise<unknown[]>;
-    getFetchRequests(): Promise<unknown[]>;
-    getExceptions(filter?: {
-        url?: string;
-        limit?: number;
-        since?: number;
-    }): ExceptionInfo[];
-    clearExceptions(): void;
-    inspectObject(objectId: string): Promise<InspectedObjectProperties>;
-    clearObjectCache(): void;
-    enableDynamicScriptMonitoring(options?: {
-        persistent?: boolean;
-    }): Promise<void>;
-    private clearDynamicScriptBuffer;
-    private resetDynamicScriptMonitoring;
-    getDynamicScripts(): Promise<unknown[]>;
-    injectFunctionTracer(functionName: string, options?: {
-        persistent?: boolean;
-    }): Promise<void>;
-    injectPropertyWatcher(objectPath: string, propertyName: string, options?: {
-        persistent?: boolean;
-    }): Promise<void>;
-    enableFetchIntercept(rules: FetchInterceptRuleInput[]): Promise<FetchInterceptRule[]>;
-    disableFetchIntercept(): Promise<{
-        removedRules: number;
-    }>;
-    removeFetchInterceptRule(ruleId: string): Promise<boolean>;
-    getFetchInterceptStatus(): {
-        enabled: boolean;
-        rules: FetchInterceptRule[];
-        totalHits: number;
-    };
-    private formatRemoteObject;
-    private extractValue;
-}