@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/server/domains/sourcemap/handlers.impl.sourcemap-parse-base.js

@@ -1,308 +0,0 @@
-import { evaluateWithTimeout } from '../../../modules/collector/PageController.js';
-var VlqConstant;
-(function (VlqConstant) {
-    VlqConstant[VlqConstant["BASE_SHIFT"] = 5] = "BASE_SHIFT";
-    VlqConstant[VlqConstant["BASE"] = 32] = "BASE";
-    VlqConstant[VlqConstant["BASE_MASK"] = 31] = "BASE_MASK";
-    VlqConstant[VlqConstant["CONTINUATION_BIT"] = 32] = "CONTINUATION_BIT";
-})(VlqConstant || (VlqConstant = {}));
-const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const BASE64_DECODE_MAP = new Map(Array.from(BASE64_ALPHABET).map((char, index) => [char, index]));
-export class SourcemapToolHandlersParseBase {
-    collector;
-    constructor(collector) {
-        this.collector = collector;
-    }
-    async parseSourceMap(sourceMapUrl, scriptUrl) {
-        const loaded = await this.loadSourceMap(sourceMapUrl, scriptUrl);
-        const mappings = this.decodeMappings(loaded.map.mappings);
-        const generatedLines = new Set(mappings.map((item) => item.generatedLine));
-        return {
-            resolvedUrl: loaded.resolvedUrl,
-            map: loaded.map,
-            mappings,
-            mappingsCount: generatedLines.size,
-            segmentCount: mappings.length,
-        };
-    }
-    async loadSourceMap(sourceMapUrl, scriptUrl) {
-        const resolvedUrl = this.resolveSourceMapUrl(sourceMapUrl, scriptUrl ?? '');
-        let sourceMapText = '';
-        if (resolvedUrl.startsWith('data:')) {
-            sourceMapText = this.decodeDataUriJson(resolvedUrl);
-        }
-        else {
-            sourceMapText = await this.fetchSourceMapText(resolvedUrl);
-        }
-        let parsedJson;
-        try {
-            parsedJson = JSON.parse(sourceMapText);
-        }
-        catch {
-            throw new Error(`Invalid SourceMap JSON: ${resolvedUrl}`);
-        }
-        const map = this.normalizeSourceMap(parsedJson);
-        return { resolvedUrl, map };
-    }
-    normalizeSourceMap(value) {
-        const record = this.asRecord(value);
-        const versionRaw = record.version;
-        if (versionRaw !== 3) {
-            throw new Error('Only SourceMap version 3 is supported');
-        }
-        const mappings = this.asString(record.mappings);
-        if (mappings === undefined) {
-            throw new Error('SourceMap.mappings is required');
-        }
-        const rawSources = Array.isArray(record.sources) ? record.sources : [];
-        const sources = rawSources
-            .map((item) => this.asString(item))
-            .filter((item) => typeof item === 'string');
-        const rawNames = Array.isArray(record.names) ? record.names : [];
-        const names = rawNames
-            .map((item) => this.asString(item))
-            .filter((item) => typeof item === 'string');
-        const sourceRoot = this.asString(record.sourceRoot);
-        let sourcesContent;
-        if (Array.isArray(record.sourcesContent)) {
-            sourcesContent = record.sourcesContent.map((item) => {
-                if (typeof item === 'string') {
-                    return item;
-                }
-                if (item === null) {
-                    return null;
-                }
-                return null;
-            });
-        }
-        return {
-            version: 3,
-            sources,
-            sourcesContent,
-            mappings,
-            names,
-            sourceRoot,
-        };
-    }
-    decodeMappings(mappings) {
-        if (!mappings) {
-            return [];
-        }
-        const decoded = [];
-        let previousSource = 0;
-        let previousOriginalLine = 0;
-        let previousOriginalColumn = 0;
-        let previousName = 0;
-        const lines = mappings.split(';');
-        for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
-            const line = lines[lineIndex] ?? '';
-            let generatedColumn = 0;
-            if (!line) {
-                continue;
-            }
-            const segments = line.split(',');
-            for (const segment of segments) {
-                if (!segment) {
-                    continue;
-                }
-                const values = this.decodeVlqSegment(segment);
-                const generatedDelta = values[0];
-                if (generatedDelta === undefined) {
-                    continue;
-                }
-                generatedColumn += generatedDelta;
-                const mapping = {
-                    generatedLine: lineIndex + 1,
-                    generatedColumn,
-                };
-                if (values.length >= 4) {
-                    previousSource += values[1] ?? 0;
-                    previousOriginalLine += values[2] ?? 0;
-                    previousOriginalColumn += values[3] ?? 0;
-                    mapping.sourceIndex = previousSource;
-                    mapping.originalLine = previousOriginalLine + 1;
-                    mapping.originalColumn = previousOriginalColumn;
-                    if (values.length >= 5) {
-                        previousName += values[4] ?? 0;
-                        mapping.nameIndex = previousName;
-                    }
-                }
-                decoded.push(mapping);
-            }
-        }
-        return decoded;
-    }
-    decodeVlqSegment(segment) {
-        const values = [];
-        let index = 0;
-        while (index < segment.length) {
-            let result = 0;
-            let shift = 0;
-            let continuation = true;
-            while (continuation) {
-                const char = segment.charAt(index);
-                if (!char) {
-                    throw new Error(`Unexpected end of VLQ segment: "${segment}"`);
-                }
-                index += 1;
-                const digit = BASE64_DECODE_MAP.get(char);
-                if (digit === undefined) {
-                    throw new Error(`Invalid VLQ base64 char "${char}" in segment "${segment}"`);
-                }
-                continuation = (digit & VlqConstant.CONTINUATION_BIT) !== 0;
-                const digitValue = digit & VlqConstant.BASE_MASK;
-                result += digitValue << shift;
-                shift += VlqConstant.BASE_SHIFT;
-            }
-            values.push(this.fromVlqSigned(result));
-        }
-        return values;
-    }
-    fromVlqSigned(value) {
-        const isNegative = (value & 1) === 1;
-        const shifted = value >> 1;
-        return isNegative ? -shifted : shifted;
-    }
-    async fetchSourceMapText(resolvedUrl) {
-        this.validateFetchUrl(resolvedUrl);
-        {
-            const ac = new AbortController();
-            const t = setTimeout(() => ac.abort(), 10000);
-            try {
-                const response = await fetch(resolvedUrl, { signal: ac.signal });
-                if (!response.ok) {
-                    throw new Error(`HTTP ${response.status} ${response.statusText}`);
-                }
-                return await response.text();
-            }
-            catch (err) {
-                if (err.name === 'AbortError') {
-                    throw new Error(`SourceMap fetch timed out after 10s: ${resolvedUrl}`, { cause: err });
-                }
-            }
-            finally {
-                clearTimeout(t);
-            }
-        }
-        const page = await this.collector.getActivePage();
-        const fetched = await evaluateWithTimeout(page, async (url) => {
-            const ac = new AbortController();
-            const t = setTimeout(() => ac.abort(), 10000);
-            try {
-                const resp = await fetch(url, { signal: ac.signal });
-                if (!resp.ok) {
-                    return `__FETCH_ERROR__HTTP ${resp.status} ${resp.statusText}`;
-                }
-                return await resp.text();
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                return `__FETCH_ERROR__${message}`;
-            }
-            finally {
-                clearTimeout(t);
-            }
-        }, resolvedUrl);
-        if (typeof fetched !== 'string') {
-            throw new Error('Failed to fetch SourceMap content');
-        }
-        if (fetched.startsWith('__FETCH_ERROR__')) {
-            const message = fetched.slice('__FETCH_ERROR__'.length);
-            throw new Error(message || 'Failed to fetch SourceMap content');
-        }
-        return fetched;
-    }
-    validateFetchUrl(url) {
-        let parsed;
-        try {
-            parsed = new URL(url);
-        }
-        catch {
-            throw new Error(`Invalid URL: ${url}`);
-        }
-        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-            throw new Error(`Blocked: unsupported protocol "${parsed.protocol}"`);
-        }
-        const hostname = parsed.hostname.toLowerCase();
-        const blockedPatterns = [
-            /^127\./,
-            /^10\./,
-            /^172\.(1[6-9]|2\d|3[01])\./,
-            /^192\.168\./,
-            /^0\./,
-            /^169\.254\./,
-            /^\[?::1\]?$/,
-            /^\[?fe80:/i,
-            /^\[?fc00:/i,
-            /^\[?fd/i,
-        ];
-        const blockedHostnames = ['localhost', 'metadata.google.internal', 'metadata'];
-        if (blockedHostnames.includes(hostname)) {
-            throw new Error(`SSRF blocked: hostname "${hostname}" is not allowed`);
-        }
-        for (const pattern of blockedPatterns) {
-            if (pattern.test(hostname)) {
-                throw new Error(`SSRF blocked: protected/reserved IP "${hostname}" is not allowed`);
-            }
-        }
-    }
-    decodeDataUriJson(dataUri) {
-        const commaIndex = dataUri.indexOf(',');
-        if (commaIndex === -1) {
-            throw new Error('Invalid data URI source map');
-        }
-        const metadata = dataUri.slice(0, commaIndex);
-        const dataPart = dataUri.slice(commaIndex + 1);
-        if (/;base64/i.test(metadata)) {
-            return Buffer.from(dataPart, 'base64').toString('utf-8');
-        }
-        return decodeURIComponent(dataPart);
-    }
-    resolveSourceMapUrl(sourceMapUrl, scriptUrl) {
-        const trimmed = sourceMapUrl.trim();
-        if (!trimmed) {
-            return '';
-        }
-        if (trimmed.startsWith('data:')) {
-            return trimmed;
-        }
-        if (this.hasProtocol(trimmed)) {
-            return trimmed;
-        }
-        if (!scriptUrl) {
-            return trimmed;
-        }
-        try {
-            return new URL(trimmed, scriptUrl).toString();
-        }
-        catch {
-            return trimmed;
-        }
-    }
-    extractSourceMappingUrlFromScript(scriptSource) {
-        const tail = scriptSource.slice(-8192);
-        const regex = /(?:\/\/[@#]\s*sourceMappingURL=([^\s]+)|\/\*[@#]\s*sourceMappingURL=([^*]+)\*\/)/g;
-        let match;
-        let found = null;
-        while (true) {
-            match = regex.exec(tail);
-            if (!match) {
-                break;
-            }
-            const candidate = (match[1] ?? match[2] ?? '').trim();
-            if (candidate) {
-                found = candidate;
-            }
-        }
-        return found;
-    }
-    hasProtocol(value) {
-        return /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value);
-    }
-    asRecord(value) {
-        return typeof value === 'object' && value !== null ? value : {};
-    }
-    asString(value) {
-        return typeof value === 'string' ? value : undefined;
-    }
-}

package/dist/src/server/domains/sourcemap/handlers.js

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

package/dist/src/server/domains/sourcemap/index.d.ts

@@ -1,2 +0,0 @@
-export { sourcemapTools } from '../../domains/sourcemap/definitions.js';
-export { SourcemapToolHandlers } from '../../domains/sourcemap/handlers.js';

package/dist/src/server/domains/sourcemap/index.js

@@ -1,2 +0,0 @@
-export { sourcemapTools } from '../../domains/sourcemap/definitions.js';
-export { SourcemapToolHandlers } from '../../domains/sourcemap/handlers.js';

package/dist/src/server/domains/sourcemap/manifest.d.ts

@@ -1,57 +0,0 @@
-import type { MCPServerContext } from '../../domains/shared/registry.js';
-import { SourcemapToolHandlers } from '../../domains/sourcemap/index.js';
-type H = SourcemapToolHandlers;
-declare function ensure(ctx: MCPServerContext): H;
-declare const manifest: {
-    kind: "domain-manifest";
-    version: 1;
-    domain: "sourcemap";
-    depKey: "sourcemapHandlers";
-    profiles: ("workflow" | "full")[];
-    ensure: typeof ensure;
-    registrations: {
-        tool: {
-            inputSchema: {
-                [x: string]: unknown;
-                type: "object";
-                properties?: {
-                    [x: string]: object;
-                } | undefined;
-                required?: string[] | undefined;
-            };
-            name: string;
-            description?: string | undefined;
-            outputSchema?: {
-                [x: string]: unknown;
-                type: "object";
-                properties?: {
-                    [x: string]: object;
-                } | undefined;
-                required?: string[] | undefined;
-            } | undefined;
-            annotations?: {
-                title?: string | undefined;
-                readOnlyHint?: boolean | undefined;
-                destructiveHint?: boolean | undefined;
-                idempotentHint?: boolean | undefined;
-                openWorldHint?: boolean | undefined;
-            } | undefined;
-            execution?: {
-                taskSupport?: "optional" | "required" | "forbidden" | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-            icons?: {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-                theme?: "light" | "dark" | undefined;
-            }[] | undefined;
-            title?: string | undefined;
-        };
-        domain: "sourcemap";
-        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
-    }[];
-};
-export default manifest;

package/dist/src/server/domains/sourcemap/manifest.js

@@ -1,53 +0,0 @@
-import { bindByDepKey, toolLookup } from '../../domains/shared/registry.js';
-import { sourcemapTools } from '../../domains/sourcemap/definitions.js';
-import { SourcemapToolHandlers } from '../../domains/sourcemap/index.js';
-import { CodeCollector } from '../../domains/shared/modules.js';
-const DOMAIN = 'sourcemap';
-const DEP_KEY = 'sourcemapHandlers';
-const t = toolLookup(sourcemapTools);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-function ensure(ctx) {
-    if (!ctx.collector) {
-        ctx.collector = new CodeCollector(ctx.config.puppeteer);
-        void ctx.registerCaches();
-    }
-    if (!ctx.sourcemapHandlers)
-        ctx.sourcemapHandlers = new SourcemapToolHandlers(ctx.collector);
-    return ctx.sourcemapHandlers;
-}
-const manifest = {
-    kind: 'domain-manifest',
-    version: 1,
-    domain: DOMAIN,
-    depKey: DEP_KEY,
-    profiles: ['workflow', 'full'],
-    ensure,
-    registrations: [
-        {
-            tool: t('sourcemap_discover'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleSourcemapDiscover(a)),
-        },
-        {
-            tool: t('sourcemap_fetch_and_parse'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleSourcemapFetchAndParse(a)),
-        },
-        {
-            tool: t('sourcemap_reconstruct_tree'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleSourcemapReconstructTree(a)),
-        },
-        {
-            tool: t('extension_list_installed'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleExtensionListInstalled(a)),
-        },
-        {
-            tool: t('extension_execute_in_context'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleExtensionExecuteInContext(a)),
-        },
-    ],
-};
-export default manifest;

package/dist/src/server/domains/streaming/definitions.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-export declare const streamingTools: Tool[];

package/dist/src/server/domains/streaming/definitions.js

@@ -1,38 +0,0 @@
-import { tool } from '../../registry/tool-builder.js';
-export const streamingTools = [
-    tool('ws_monitor_enable')
-        .desc('Enable WebSocket frame capture via CDP Network events')
-        .string('urlFilter', 'Regex filter for WebSocket URL')
-        .number('maxFrames', 'Maximum frames in memory', { default: 1000 })
-        .build(),
-    tool('ws_monitor_disable')
-        .desc('Disable WebSocket monitoring and return capture summary')
-        .destructive()
-        .build(),
-    tool('ws_get_frames')
-        .desc('Get captured WebSocket frames with pagination and payload filter')
-        .enum('direction', ['sent', 'received', 'all'], 'Frame direction filter', { default: 'all' })
-        .number('limit', 'Maximum frames to return', { default: 100 })
-        .number('offset', 'Pagination offset', { default: 0 })
-        .string('payloadFilter', 'Regex filter on frame payload')
-        .readOnly()
-        .build(),
-    tool('ws_get_connections')
-        .desc('Get tracked WebSocket connections and frame counts')
-        .readOnly()
-        .build(),
-    tool('sse_monitor_enable')
-        .desc('Enable SSE monitoring by injecting EventSource interceptor')
-        .string('urlFilter', 'Regex filter for EventSource URL')
-        .number('maxEvents', 'Maximum SSE events in memory', { default: 2000 })
-        .boolean('persistent', 'Survive page navigations via evaluateOnNewDocument')
-        .build(),
-    tool('sse_get_events')
-        .desc('Get captured SSE events with filters and pagination')
-        .string('sourceUrl', 'Filter by EventSource URL')
-        .string('eventType', 'Filter by SSE event type')
-        .number('limit', 'Maximum events', { default: 100 })
-        .number('offset', 'Pagination offset', { default: 0 })
-        .readOnly()
-        .build(),
-];

package/dist/src/server/domains/streaming/handlers.d.ts

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

package/dist/src/server/domains/streaming/handlers.impl.core.d.ts

@@ -1,3 +0,0 @@
-import { StreamingToolHandlersSse } from '../../domains/streaming/handlers.impl.streaming-sse.js';
-export declare class StreamingToolHandlers extends StreamingToolHandlersSse {
-}

package/dist/src/server/domains/streaming/handlers.impl.core.js

@@ -1,3 +0,0 @@
-import { StreamingToolHandlersSse } from '../../domains/streaming/handlers.impl.streaming-sse.js';
-export class StreamingToolHandlers extends StreamingToolHandlersSse {
-}

package/dist/src/server/domains/streaming/handlers.impl.streaming-base.d.ts

@@ -1,105 +0,0 @@
-import type { CodeCollector } from '../../domains/shared/modules.js';
-import { RingBuffer } from '../../../utils/RingBuffer.js';
-export type TextToolResponse = {
-    content: [{
-        type: 'text';
-        text: string;
-    }];
-};
-export type WsDirection = 'sent' | 'received';
-export type WsQueryDirection = WsDirection | 'all';
-export type CdpEventPayload = unknown;
-export type CdpEventHandler = (params: CdpEventPayload) => void;
-export interface CdpSessionLike {
-    send(method: string, params?: Record<string, unknown>): Promise<unknown>;
-    on(event: string, handler: CdpEventHandler): void;
-    off(event: string, handler: CdpEventHandler): void;
-    detach(): Promise<void>;
-}
-export interface WsFrameRecord {
-    requestId: string;
-    timestamp: number;
-    direction: WsDirection;
-    opcode: number;
-    payloadLength: number;
-    payloadPreview: string;
-    payloadSample: string;
-    isBinary: boolean;
-}
-export interface WsFrameOrderEntry {
-    requestId: string;
-    frame: WsFrameRecord;
-}
-interface WsConnectionRecord {
-    requestId: string;
-    url: string;
-    status: 'connecting' | 'open' | 'closed' | 'error';
-    framesCount: number;
-    createdTimestamp: number;
-    closedTimestamp?: number;
-    handshakeStatus?: number;
-}
-interface WsMonitorConfig {
-    enabled: boolean;
-    maxFrames: number;
-    urlFilterRaw?: string;
-    urlFilter?: RegExp;
-}
-export interface WsMonitorListeners {
-    created: CdpEventHandler;
-    closed: CdpEventHandler;
-    handshake: CdpEventHandler;
-    frameSent: CdpEventHandler;
-    frameReceived: CdpEventHandler;
-}
-export interface SseEventRecord {
-    sourceUrl: string;
-    eventType: string;
-    dataPreview: string;
-    dataLength: number;
-    lastEventId: string | null;
-    timestamp: number;
-}
-export interface SseEnableResult {
-    success: boolean;
-    message: string;
-    patched: boolean;
-    urlFilter?: string;
-    maxEvents: number;
-    existingEvents: number;
-}
-export declare class StreamingToolHandlersBase {
-    protected collector: CodeCollector;
-    protected wsSession: CdpSessionLike | null;
-    protected wsListeners: WsMonitorListeners | null;
-    protected wsConfig: WsMonitorConfig;
-    protected wsFramesByRequest: Map<string, WsFrameRecord[]>;
-    protected wsFrameOrder: RingBuffer<WsFrameOrderEntry>;
-    protected wsConnections: Map<string, WsConnectionRecord>;
-    protected sseConfig: {
-        maxEvents: number;
-        urlFilterRaw?: string;
-    };
-    constructor(collector: CodeCollector);
-    protected asJson(payload: unknown): TextToolResponse;
-    protected parseOptionalStringArg(value: unknown): string | undefined;
-    protected parseNumberArg(value: unknown, options: {
-        defaultValue: number;
-        min: number;
-        max: number;
-        integer?: boolean;
-    }): number;
-    protected parseWsDirection(value: unknown): WsQueryDirection;
-    protected compileRegex(pattern: string): {
-        regex?: RegExp;
-        error?: string;
-    };
-    protected getWsFrameStats(): {
-        total: number;
-        sent: number;
-        received: number;
-    };
-    protected appendWsFrame(requestId: string, frame: WsFrameRecord): void;
-    protected enforceWsFrameLimit(): void;
-}
-export {};