@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.protobuf.js

@@ -1,204 +0,0 @@
-import { EncodingToolHandlersAnalysis } from '../../domains/encoding/handlers.impl.core.runtime.analysis.js';
-export class EncodingToolHandlersProtobuf extends EncodingToolHandlersAnalysis {
-    parseProtobufMessage(buffer, depth, maxDepth) {
-        const fields = [];
-        let offset = 0;
-        let fieldIndex = 0;
-        while (offset < buffer.length) {
-            const keyInfo = this.tryParseVarint(buffer, offset);
-            if (keyInfo.error) {
-                return {
-                    fields,
-                    bytesConsumed: offset,
-                    error: keyInfo.error,
-                };
-            }
-            const keyValue = keyInfo.value;
-            offset = keyInfo.offset;
-            const fieldNumber = Number(keyValue >> 3n);
-            const wireType = Number(keyValue & 0x07n);
-            if (fieldNumber <= 0) {
-                return {
-                    fields,
-                    bytesConsumed: offset,
-                    error: `Invalid field number ${fieldNumber} at offset ${offset}`,
-                };
-            }
-            if (wireType === 0) {
-                const varintInfo = this.tryParseVarint(buffer, offset);
-                if (varintInfo.error) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: varintInfo.error,
-                    };
-                }
-                offset = varintInfo.offset;
-                fields.push({
-                    index: fieldIndex,
-                    fieldNumber,
-                    wireType,
-                    wireTypeName: this.protobufWireTypeName(wireType),
-                    value: this.bigIntToSafeValue(varintInfo.value),
-                });
-            }
-            else if (wireType === 1) {
-                if (offset + 8 > buffer.length) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: `Unexpected EOF for fixed64 at offset ${offset}`,
-                    };
-                }
-                const raw = buffer.subarray(offset, offset + 8);
-                const fixed64 = raw.readBigUInt64LE(0);
-                offset += 8;
-                fields.push({
-                    index: fieldIndex,
-                    fieldNumber,
-                    wireType,
-                    wireTypeName: this.protobufWireTypeName(wireType),
-                    value: {
-                        uint64: this.bigIntToSafeValue(fixed64),
-                        hex: raw.toString('hex'),
-                    },
-                });
-            }
-            else if (wireType === 2) {
-                const lengthInfo = this.tryParseVarint(buffer, offset);
-                if (lengthInfo.error) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: lengthInfo.error,
-                    };
-                }
-                offset = lengthInfo.offset;
-                const lengthBigInt = lengthInfo.value;
-                if (lengthBigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: `Length-delimited field is too large at offset ${offset}`,
-                    };
-                }
-                const length = Number(lengthBigInt);
-                if (length < 0 || offset + length > buffer.length) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: `Invalid length-delimited field length=${length} at offset ${offset}`,
-                    };
-                }
-                const payload = buffer.subarray(offset, offset + length);
-                offset += length;
-                fields.push({
-                    index: fieldIndex,
-                    fieldNumber,
-                    wireType,
-                    wireTypeName: this.protobufWireTypeName(wireType),
-                    value: this.decodeLengthDelimited(payload, depth, maxDepth),
-                });
-            }
-            else if (wireType === 5) {
-                if (offset + 4 > buffer.length) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: `Unexpected EOF for fixed32 at offset ${offset}`,
-                    };
-                }
-                const raw = buffer.subarray(offset, offset + 4);
-                const fixed32 = raw.readUInt32LE(0);
-                offset += 4;
-                fields.push({
-                    index: fieldIndex,
-                    fieldNumber,
-                    wireType,
-                    wireTypeName: this.protobufWireTypeName(wireType),
-                    value: {
-                        uint32: fixed32,
-                        hex: raw.toString('hex'),
-                    },
-                });
-            }
-            else {
-                return {
-                    fields,
-                    bytesConsumed: offset,
-                    error: `Unsupported wire type ${wireType} at offset ${offset}`,
-                };
-            }
-            fieldIndex += 1;
-        }
-        return {
-            fields,
-            bytesConsumed: offset,
-        };
-    }
-    decodeLengthDelimited(payload, depth, maxDepth) {
-        if (payload.length === 0) {
-            return { kind: 'empty', length: 0 };
-        }
-        if (depth < maxDepth) {
-            const nested = this.parseProtobufMessage(payload, depth + 1, maxDepth);
-            if (!nested.error && nested.bytesConsumed === payload.length && nested.fields.length > 0) {
-                return {
-                    kind: 'message',
-                    fields: nested.fields,
-                };
-            }
-        }
-        const text = this.toSafeUtf8(payload);
-        if (text !== null && this.isMostlyPrintableText(text)) {
-            return {
-                kind: 'string',
-                value: text,
-            };
-        }
-        return {
-            kind: 'bytes',
-            length: payload.length,
-            hex: payload.toString('hex'),
-            base64: payload.toString('base64'),
-        };
-    }
-    tryParseVarint(buffer, startOffset) {
-        let result = 0n;
-        let shift = 0n;
-        let offset = startOffset;
-        for (let index = 0; index < 10; index += 1) {
-            const current = buffer[offset];
-            if (current === undefined) {
-                return { error: `Unexpected EOF while parsing varint at offset ${offset}` };
-            }
-            const byte = BigInt(current);
-            result |= (byte & 0x7fn) << shift;
-            offset += 1;
-            if ((byte & 0x80n) === 0n) {
-                return { value: result, offset };
-            }
-            shift += 7n;
-        }
-        return { error: `Varint exceeds 10 bytes at offset ${startOffset}` };
-    }
-    protobufWireTypeName(wireType) {
-        if (wireType === 0)
-            return 'varint';
-        if (wireType === 1)
-            return 'fixed64';
-        if (wireType === 2)
-            return 'length-delimited';
-        if (wireType === 5)
-            return 'fixed32';
-        return 'unknown';
-    }
-    bigIntToSafeValue(value) {
-        const max = BigInt(Number.MAX_SAFE_INTEGER);
-        const min = BigInt(Number.MIN_SAFE_INTEGER);
-        if (value <= max && value >= min) {
-            return Number(value);
-        }
-        return value.toString();
-    }
-}

package/dist/src/server/domains/encoding/handlers.impl.d.ts

@@ -1 +0,0 @@
-export { EncodingToolHandlers } from '../../domains/encoding/handlers.impl.core.js';

package/dist/src/server/domains/encoding/handlers.impl.js

@@ -1 +0,0 @@
-export { EncodingToolHandlers } from '../../domains/encoding/handlers.impl.core.js';

package/dist/src/server/domains/network/handlers.impl.core.runtime.base.d.ts

@@ -1,46 +0,0 @@
-import type { CodeCollector } from '../../domains/shared/modules.js';
-import type { ConsoleMonitor } from '../../domains/shared/modules.js';
-import { PerformanceMonitor } from '../../domains/shared/modules.js';
-import { DetailedDataManager } from '../../../utils/DetailedDataManager.js';
-export declare class AdvancedToolHandlersBase {
-    protected collector: CodeCollector;
-    protected consoleMonitor: ConsoleMonitor;
-    protected performanceMonitor: PerformanceMonitor | null;
-    protected detailedDataManager: DetailedDataManager;
-    constructor(collector: CodeCollector, consoleMonitor: ConsoleMonitor);
-    protected getPerformanceMonitor(): PerformanceMonitor;
-    protected parseBooleanArg(value: unknown, defaultValue: boolean): boolean;
-    protected parseNumberArg(value: unknown, options: {
-        defaultValue: number;
-        min?: number;
-        max?: number;
-        integer?: boolean;
-    }): number;
-    protected sleep(ms: number): Promise<void>;
-    protected ensureNetworkEnabled(options: {
-        autoEnable: boolean;
-        enableExceptions: boolean;
-    }): Promise<{
-        enabled: boolean;
-        autoEnabled: boolean;
-        error?: string;
-    }>;
-    handleNetworkEnable(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleNetworkDisable(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleNetworkGetStatus(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}

package/dist/src/server/domains/network/handlers.impl.core.runtime.base.js

@@ -1,186 +0,0 @@
-import { PerformanceMonitor } from '../../domains/shared/modules.js';
-import { DetailedDataManager } from '../../../utils/DetailedDataManager.js';
-export class AdvancedToolHandlersBase {
-    collector;
-    consoleMonitor;
-    performanceMonitor = null;
-    detailedDataManager;
-    constructor(collector, consoleMonitor) {
-        this.collector = collector;
-        this.consoleMonitor = consoleMonitor;
-        this.detailedDataManager = DetailedDataManager.getInstance();
-    }
-    getPerformanceMonitor() {
-        if (!this.performanceMonitor) {
-            this.performanceMonitor = new PerformanceMonitor(this.collector);
-        }
-        return this.performanceMonitor;
-    }
-    parseBooleanArg(value, defaultValue) {
-        if (typeof value === 'boolean') {
-            return value;
-        }
-        if (typeof value === 'number') {
-            if (value === 1)
-                return true;
-            if (value === 0)
-                return false;
-            return defaultValue;
-        }
-        if (typeof value === 'string') {
-            const normalized = value.trim().toLowerCase();
-            if (['true', '1', 'yes', 'on'].includes(normalized))
-                return true;
-            if (['false', '0', 'no', 'off'].includes(normalized))
-                return false;
-        }
-        return defaultValue;
-    }
-    parseNumberArg(value, options) {
-        let parsed;
-        if (typeof value === 'number' && Number.isFinite(value)) {
-            parsed = value;
-        }
-        else if (typeof value === 'string') {
-            const trimmed = value.trim();
-            if (trimmed.length > 0) {
-                const n = Number(trimmed);
-                if (Number.isFinite(n)) {
-                    parsed = n;
-                }
-            }
-        }
-        if (parsed === undefined) {
-            parsed = options.defaultValue;
-        }
-        if (options.integer) {
-            parsed = Math.trunc(parsed);
-        }
-        if (typeof options.min === 'number') {
-            parsed = Math.max(options.min, parsed);
-        }
-        if (typeof options.max === 'number') {
-            parsed = Math.min(options.max, parsed);
-        }
-        return parsed;
-    }
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    async ensureNetworkEnabled(options) {
-        if (this.consoleMonitor.isNetworkEnabled()) {
-            return { enabled: true, autoEnabled: false };
-        }
-        if (!options.autoEnable) {
-            return { enabled: false, autoEnabled: false };
-        }
-        try {
-            await this.consoleMonitor.enable({
-                enableNetwork: true,
-                enableExceptions: options.enableExceptions,
-            });
-            return {
-                enabled: this.consoleMonitor.isNetworkEnabled(),
-                autoEnabled: true,
-            };
-        }
-        catch (error) {
-            return {
-                enabled: false,
-                autoEnabled: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async handleNetworkEnable(args) {
-        const enableExceptions = this.parseBooleanArg(args.enableExceptions, true);
-        await this.consoleMonitor.enable({
-            enableNetwork: true,
-            enableExceptions,
-        });
-        const status = this.consoleMonitor.getNetworkStatus();
-        const result = {
-            success: true,
-            message: ' Network monitoring enabled successfully',
-            enabled: status.enabled,
-            cdpSessionActive: status.cdpSessionActive,
-            listenerCount: status.listenerCount,
-            usage: {
-                step1: 'Network monitoring is now active',
-                step2: 'Navigate to a page using page_navigate tool',
-                step3: 'Use network_get_requests to retrieve captured requests',
-                step4: 'Use network_get_response_body to get response content',
-            },
-            important: 'Network monitoring must be enabled BEFORE navigating to capture requests',
-        };
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2),
-                },
-            ],
-        };
-    }
-    async handleNetworkDisable(_args) {
-        await this.consoleMonitor.disable();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        message: 'Network monitoring disabled',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleNetworkGetStatus(_args) {
-        const status = this.consoleMonitor.getNetworkStatus();
-        let result;
-        if (!status.enabled) {
-            result = {
-                success: false,
-                enabled: false,
-                message: ' Network monitoring is NOT enabled',
-                requestCount: 0,
-                responseCount: 0,
-                nextSteps: {
-                    step1: 'Call network_enable tool to start monitoring',
-                    step2: 'Then navigate to a page using page_navigate',
-                    step3: 'Finally use network_get_requests to see captured requests',
-                },
-                example: 'network_enable -> page_navigate -> network_get_requests',
-            };
-        }
-        else {
-            result = {
-                success: true,
-                enabled: true,
-                message: ` Network monitoring is active. Captured ${status.requestCount} requests and ${status.responseCount} responses.`,
-                requestCount: status.requestCount,
-                responseCount: status.responseCount,
-                listenerCount: status.listenerCount,
-                cdpSessionActive: status.cdpSessionActive,
-                nextSteps: status.requestCount === 0
-                    ? {
-                        hint: 'No requests captured yet',
-                        action: 'Navigate to a page using page_navigate to capture network traffic',
-                    }
-                    : {
-                        hint: `${status.requestCount} requests captured`,
-                        action: 'Use network_get_requests to retrieve them',
-                    },
-            };
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2),
-                },
-            ],
-        };
-    }
-}

package/dist/src/server/domains/network/handlers.impl.core.runtime.console.d.ts

@@ -1,46 +0,0 @@
-import { AdvancedToolHandlersPerformance } from '../../domains/network/handlers.impl.core.runtime.performance.js';
-export declare class AdvancedToolHandlersConsole extends AdvancedToolHandlersPerformance {
-    handleConsoleGetExceptions(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleConsoleInjectScriptMonitor(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleConsoleInjectXhrInterceptor(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleConsoleInjectFetchInterceptor(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleConsoleClearInjectedBuffers(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleConsoleResetInjectedInterceptors(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleConsoleInjectFunctionTracer(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    cleanup(): Promise<void>;
-}

package/dist/src/server/domains/network/handlers.impl.core.runtime.console.js

@@ -1,122 +0,0 @@
-import { logger } from '../../../utils/logger.js';
-import { AdvancedToolHandlersPerformance } from '../../domains/network/handlers.impl.core.runtime.performance.js';
-export class AdvancedToolHandlersConsole extends AdvancedToolHandlersPerformance {
-    async handleConsoleGetExceptions(args) {
-        const url = args.url;
-        const limit = args.limit || 50;
-        let exceptions = this.consoleMonitor.getExceptions();
-        if (url) {
-            exceptions = exceptions.filter((ex) => ex.url?.includes(url));
-        }
-        exceptions = exceptions.slice(0, limit);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        exceptions,
-                        total: exceptions.length,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleConsoleInjectScriptMonitor(_args) {
-        await this.consoleMonitor.enableDynamicScriptMonitoring();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        message: 'Dynamic script monitoring enabled',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleConsoleInjectXhrInterceptor(_args) {
-        await this.consoleMonitor.injectXHRInterceptor();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        message: 'XHR interceptor injected',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleConsoleInjectFetchInterceptor(_args) {
-        await this.consoleMonitor.injectFetchInterceptor();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        message: 'Fetch interceptor injected',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleConsoleClearInjectedBuffers(_args) {
-        const result = await this.consoleMonitor.clearInjectedBuffers();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        message: 'Injected buffers cleared',
-                        ...result,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleConsoleResetInjectedInterceptors(_args) {
-        const result = await this.consoleMonitor.resetInjectedInterceptors();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        message: 'Injected interceptors/monitors reset',
-                        ...result,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleConsoleInjectFunctionTracer(args) {
-        const functionName = args.functionName;
-        if (!functionName) {
-            throw new Error('functionName is required');
-        }
-        await this.consoleMonitor.injectFunctionTracer(functionName);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        message: `Function tracer injected for: ${functionName}`,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async cleanup() {
-        if (this.performanceMonitor) {
-            await this.performanceMonitor.close();
-            this.performanceMonitor = null;
-        }
-        logger.info('AdvancedToolHandlers cleaned up');
-    }
-}

package/dist/src/server/domains/network/handlers.impl.core.runtime.performance.d.ts

@@ -1,63 +0,0 @@
-import { AdvancedToolHandlersRequests } from '../../domains/network/handlers.impl.core.runtime.requests.js';
-export declare class AdvancedToolHandlersPerformance extends AdvancedToolHandlersRequests {
-    handlePerformanceGetMetrics(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handlePerformanceStartCoverage(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handlePerformanceStopCoverage(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handlePerformanceTakeHeapSnapshot(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handlePerformanceTraceStart(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handlePerformanceTraceStop(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleProfilerCpuStart(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleProfilerCpuStop(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleProfilerHeapSamplingStart(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleProfilerHeapSamplingStop(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}