@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/server/domains/network/handlers.base.performance.d.ts

@@ -0,0 +1,63 @@
+import { NetworkHandlersCore } from './handlers.base.core.js';
+export declare class NetworkHandlersPerformance extends NetworkHandlersCore {
+    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;
+        }[];
+    }>;
+}

package/dist/src/server/domains/network/handlers.base.performance.js

@@ -0,0 +1,193 @@
+import { NetworkHandlersCore } from './handlers.base.core.js';
+import { asOptionalBoolean, asOptionalNumber, asOptionalString, asOptionalStringArray, toCpuProfilePayload, } from './handlers.base.types.js';
+export class NetworkHandlersPerformance extends NetworkHandlersCore {
+    async handlePerformanceGetMetrics(args) {
+        const includeTimeline = args.includeTimeline === true;
+        const monitor = this.getPerformanceMonitor();
+        const metrics = await monitor.getPerformanceMetrics();
+        const result = { success: true, metrics };
+        if (includeTimeline) {
+            result.timeline = await monitor.getPerformanceTimeline();
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    async handlePerformanceStartCoverage(_args) {
+        const monitor = this.getPerformanceMonitor();
+        await monitor.startCoverage();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ success: true, message: 'Code coverage collection started' }, null, 2),
+                },
+            ],
+        };
+    }
+    async handlePerformanceStopCoverage(_args) {
+        const monitor = this.getPerformanceMonitor();
+        const coverage = await monitor.stopCoverage();
+        const avgCoverage = coverage.length > 0
+            ? coverage.reduce((sum, info) => sum + info.coveragePercentage, 0) / coverage.length
+            : 0;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ success: true, coverage, totalScripts: coverage.length, avgCoverage }, null, 2),
+                },
+            ],
+        };
+    }
+    async handlePerformanceTakeHeapSnapshot(_args) {
+        const monitor = this.getPerformanceMonitor();
+        const snapshot = await monitor.takeHeapSnapshot();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        snapshotSize: snapshot.length,
+                        message: 'Heap snapshot taken (data too large to return, saved internally)',
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async handlePerformanceTraceStart(args) {
+        const monitor = this.getPerformanceMonitor();
+        const categories = asOptionalStringArray(args.categories);
+        const screenshots = asOptionalBoolean(args.screenshots);
+        await monitor.startTracing({ categories, screenshots });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        message: 'Performance tracing started. Call performance_trace_stop to save the trace.',
+                    }),
+                },
+            ],
+        };
+    }
+    async handlePerformanceTraceStop(args) {
+        const monitor = this.getPerformanceMonitor();
+        const artifactPath = asOptionalString(args.artifactPath);
+        const result = await monitor.stopTracing({ artifactPath });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        artifactPath: result.artifactPath,
+                        eventCount: result.eventCount,
+                        sizeBytes: result.sizeBytes,
+                        sizeKB: (result.sizeBytes / 1024).toFixed(1),
+                        hint: 'Open the trace file in Chrome DevTools → Performance tab → Load profile',
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async handleProfilerCpuStart(_args) {
+        const monitor = this.getPerformanceMonitor();
+        await monitor.startCPUProfiling();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        message: 'CPU profiling started. Call profiler_cpu_stop to save the profile.',
+                    }),
+                },
+            ],
+        };
+    }
+    async handleProfilerCpuStop(args) {
+        const monitor = this.getPerformanceMonitor();
+        const profileRaw = await monitor.stopCPUProfiling();
+        const profile = toCpuProfilePayload(profileRaw) || profileRaw;
+        const { writeFile } = await import('node:fs/promises');
+        const { resolveArtifactPath } = await import('../../../utils/artifacts.js');
+        const artifactPath = asOptionalString(args.artifactPath);
+        const profileJson = JSON.stringify(profile, null, 2);
+        let savedPath;
+        if (artifactPath) {
+            await writeFile(artifactPath, profileJson, 'utf-8');
+            savedPath = artifactPath;
+        }
+        else {
+            const { absolutePath, displayPath } = await resolveArtifactPath({
+                category: 'profiles',
+                toolName: 'cpu-profile',
+                ext: 'cpuprofile',
+            });
+            await writeFile(absolutePath, profileJson, 'utf-8');
+            savedPath = displayPath;
+        }
+        const hotFunctions = profile.nodes
+            .filter((n) => (n.hitCount || 0) > 0)
+            .toSorted((a, b) => (b.hitCount || 0) - (a.hitCount || 0))
+            .slice(0, 20)
+            .map((n) => ({
+            functionName: n.callFrame?.functionName || '(anonymous)',
+            url: n.callFrame?.url,
+            line: n.callFrame?.lineNumber,
+            hitCount: n.hitCount,
+        }));
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        artifactPath: savedPath,
+                        totalNodes: profile.nodes.length,
+                        totalSamples: profile.samples?.length || 0,
+                        durationMs: profile.endTime - profile.startTime,
+                        hotFunctions,
+                        hint: 'Open the .cpuprofile file in Chrome DevTools → Performance tab',
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async handleProfilerHeapSamplingStart(args) {
+        const monitor = this.getPerformanceMonitor();
+        const samplingInterval = asOptionalNumber(args.samplingInterval);
+        await monitor.startHeapSampling({ samplingInterval });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        message: 'Heap sampling started. Call profiler_heap_sampling_stop to save the report.',
+                    }),
+                },
+            ],
+        };
+    }
+    async handleProfilerHeapSamplingStop(args) {
+        const monitor = this.getPerformanceMonitor();
+        const artifactPath = asOptionalString(args.artifactPath);
+        const topN = asOptionalNumber(args.topN);
+        const result = await monitor.stopHeapSampling({ artifactPath, topN });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        artifactPath: result.artifactPath,
+                        sampleCount: result.sampleCount,
+                        topAllocations: result.topAllocations,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+}

package/dist/src/server/domains/network/handlers.base.types.d.ts

@@ -0,0 +1,42 @@
+import { DetailedDataManager } from '../../../utils/DetailedDataManager.js';
+export declare const EXCLUDED_RESOURCE_TYPES: Set<string>;
+export declare const TYPE_SORT_PRIORITY: Record<string, number>;
+export declare const DEFAULT_SORT_PRIORITY = 6;
+export interface NetworkRequestPayload {
+    requestId?: string;
+    url: string;
+    method: string;
+    type?: string;
+    timestamp?: number;
+    [key: string]: unknown;
+}
+export interface NetworkResponsePayload {
+    status: number;
+    [key: string]: unknown;
+}
+export interface CpuProfileCallFramePayload {
+    functionName?: string;
+    url?: string;
+    lineNumber?: number;
+}
+export interface CpuProfileNodePayload {
+    hitCount?: number;
+    callFrame?: CpuProfileCallFramePayload;
+}
+export interface CpuProfilePayload {
+    nodes: CpuProfileNodePayload[];
+    samples?: unknown[];
+    startTime: number;
+    endTime: number;
+}
+export declare const isObjectRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const isNetworkRequestPayload: (value: unknown) => value is NetworkRequestPayload;
+export declare const isNetworkResponsePayload: (value: unknown) => value is NetworkResponsePayload;
+export declare const isFiniteNumber: (value: unknown) => value is number;
+export declare const asOptionalString: (value: unknown) => string | undefined;
+export declare const asOptionalBoolean: (value: unknown) => boolean | undefined;
+export declare const asOptionalNumber: (value: unknown) => number | undefined;
+export declare const asOptionalStringArray: (value: unknown) => string[] | undefined;
+export declare const isCpuProfileNodePayload: (value: unknown) => value is CpuProfileNodePayload;
+export declare const toCpuProfilePayload: (value: unknown) => CpuProfilePayload | null;
+export declare function getDetailedDataManager(): DetailedDataManager;

package/dist/src/server/domains/network/handlers.base.types.js

@@ -0,0 +1,89 @@
+import { DetailedDataManager } from '../../../utils/DetailedDataManager.js';
+export const EXCLUDED_RESOURCE_TYPES = new Set([
+    'Image',
+    'Font',
+    'Stylesheet',
+    'Media',
+    'Manifest',
+    'Ping',
+]);
+export const TYPE_SORT_PRIORITY = {
+    XHR: 0,
+    Fetch: 1,
+    Document: 2,
+    Script: 3,
+    WebSocket: 4,
+    EventSource: 5,
+};
+export const DEFAULT_SORT_PRIORITY = 6;
+export const isObjectRecord = (value) => typeof value === 'object' && value !== null;
+export const isNetworkRequestPayload = (value) => {
+    if (!isObjectRecord(value)) {
+        return false;
+    }
+    return typeof value.url === 'string' && typeof value.method === 'string';
+};
+export const isNetworkResponsePayload = (value) => {
+    if (!isObjectRecord(value)) {
+        return false;
+    }
+    return typeof value.status === 'number';
+};
+export const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+export const asOptionalString = (value) => typeof value === 'string' ? value : undefined;
+export const asOptionalBoolean = (value) => typeof value === 'boolean' ? value : undefined;
+export const asOptionalNumber = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+export const asOptionalStringArray = (value) => {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value.every((item) => typeof item === 'string') ? value : undefined;
+};
+export const isCpuProfileNodePayload = (value) => {
+    if (!isObjectRecord(value)) {
+        return false;
+    }
+    if (value.hitCount !== undefined && typeof value.hitCount !== 'number') {
+        return false;
+    }
+    if (value.callFrame !== undefined && !isObjectRecord(value.callFrame)) {
+        return false;
+    }
+    if (isObjectRecord(value.callFrame)) {
+        if (value.callFrame.functionName !== undefined &&
+            typeof value.callFrame.functionName !== 'string') {
+            return false;
+        }
+        if (value.callFrame.url !== undefined && typeof value.callFrame.url !== 'string') {
+            return false;
+        }
+        if (value.callFrame.lineNumber !== undefined &&
+            typeof value.callFrame.lineNumber !== 'number') {
+            return false;
+        }
+    }
+    return true;
+};
+export const toCpuProfilePayload = (value) => {
+    if (!isObjectRecord(value)) {
+        return null;
+    }
+    if (!Array.isArray(value.nodes)) {
+        return null;
+    }
+    if (typeof value.startTime !== 'number' || typeof value.endTime !== 'number') {
+        return null;
+    }
+    if (!value.nodes.every((node) => isCpuProfileNodePayload(node))) {
+        return null;
+    }
+    return {
+        nodes: value.nodes,
+        samples: Array.isArray(value.samples) ? value.samples : undefined,
+        startTime: value.startTime,
+        endTime: value.endTime,
+    };
+};
+export function getDetailedDataManager() {
+    return DetailedDataManager.getInstance();
+}

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

@@ -1 +1 @@
-export { AdvancedToolHandlersRuntime as AdvancedToolHandlers } from '../../domains/network/handlers.impl.core.runtime.replay.js';
+export { AdvancedToolHandlersIntercept as AdvancedToolHandlers } from '../../domains/network/handlers.impl.core.runtime.intercept.js';

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

@@ -0,0 +1,21 @@
+import { AdvancedToolHandlersRuntime as AdvancedToolHandlersReplay } from '../../domains/network/handlers.impl.core.runtime.replay.js';
+export declare class AdvancedToolHandlersIntercept extends AdvancedToolHandlersReplay {
+    handleNetworkInterceptResponse(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleNetworkInterceptList(_args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleNetworkInterceptDisable(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+}

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

@@ -0,0 +1,186 @@
+import { AdvancedToolHandlersRuntime as AdvancedToolHandlersReplay } from '../../domains/network/handlers.impl.core.runtime.replay.js';
+const isObjectRecord = (value) => typeof value === 'object' && value !== null;
+export class AdvancedToolHandlersIntercept extends AdvancedToolHandlersReplay {
+    async handleNetworkInterceptResponse(args) {
+        try {
+            const rules = [];
+            if (Array.isArray(args.rules)) {
+                for (const rawRule of args.rules) {
+                    if (isObjectRecord(rawRule) && typeof rawRule.urlPattern === 'string') {
+                        rules.push({
+                            urlPattern: rawRule.urlPattern,
+                            urlPatternType: rawRule.urlPatternType === 'regex' ? 'regex' : 'glob',
+                            stage: rawRule.stage === 'Request' ? 'Request' : 'Response',
+                            responseCode: typeof rawRule.responseCode === 'number' ? rawRule.responseCode : 200,
+                            responseHeaders: isObjectRecord(rawRule.responseHeaders)
+                                ? rawRule.responseHeaders
+                                : undefined,
+                            responseBody: typeof rawRule.responseBody === 'string'
+                                ? rawRule.responseBody
+                                : typeof rawRule.responseBody === 'object'
+                                    ? JSON.stringify(rawRule.responseBody)
+                                    : undefined,
+                        });
+                    }
+                }
+            }
+            else if (typeof args.urlPattern === 'string') {
+                rules.push({
+                    urlPattern: args.urlPattern,
+                    urlPatternType: args.urlPatternType === 'regex' ? 'regex' : 'glob',
+                    stage: args.stage === 'Request' ? 'Request' : 'Response',
+                    responseCode: typeof args.responseCode === 'number' ? args.responseCode : 200,
+                    responseHeaders: isObjectRecord(args.responseHeaders)
+                        ? args.responseHeaders
+                        : undefined,
+                    responseBody: typeof args.responseBody === 'string'
+                        ? args.responseBody
+                        : typeof args.responseBody === 'object' && args.responseBody !== null
+                            ? JSON.stringify(args.responseBody)
+                            : undefined,
+                });
+            }
+            if (rules.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: 'No valid rules provided. Provide either "urlPattern" (single) or "rules" array (batch).',
+                                usage: {
+                                    single: {
+                                        urlPattern: '*api/status*',
+                                        responseCode: 200,
+                                        responseBody: '{"status":"active"}',
+                                    },
+                                    batch: {
+                                        rules: [
+                                            {
+                                                urlPattern: '*api/status*',
+                                                responseBody: '{"status":"active"}',
+                                            },
+                                        ],
+                                    },
+                                },
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            const createdRules = await this.consoleMonitor.enableFetchIntercept(rules);
+            const status = this.consoleMonitor.getFetchInterceptStatus();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: `Added ${createdRules.length} interception rule(s)`,
+                            createdRules: createdRules.map((r) => ({
+                                id: r.id,
+                                urlPattern: r.urlPattern,
+                                stage: r.stage,
+                                responseCode: r.responseCode,
+                            })),
+                            totalActiveRules: status.rules.length,
+                            hint: 'Use network_intercept_list to see all rules and hit counts. Use network_intercept_disable to remove rules.',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                            hint: 'Ensure browser is launched and a page is active before enabling interception.',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async handleNetworkInterceptList(_args) {
+        const status = this.consoleMonitor.getFetchInterceptStatus();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        ...status,
+                        hint: status.rules.length > 0
+                            ? 'Use network_intercept_disable(ruleId) to remove a specific rule, or network_intercept_disable(all=true) to remove all.'
+                            : 'No active interception rules. Use network_intercept_response to add rules.',
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async handleNetworkInterceptDisable(args) {
+        const ruleId = typeof args.ruleId === 'string' ? args.ruleId : undefined;
+        const all = args.all === true;
+        if (!ruleId && !all) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: 'Provide either "ruleId" to remove a specific rule, or "all": true to disable all.',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        try {
+            if (all) {
+                const result = await this.consoleMonitor.disableFetchIntercept();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Disabled all interception. Removed ${result.removedRules} rule(s).`,
+                                removedRules: result.removedRules,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            const removed = await this.consoleMonitor.removeFetchInterceptRule(ruleId);
+            const status = this.consoleMonitor.getFetchInterceptStatus();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: removed,
+                            message: removed ? `Rule ${ruleId} removed.` : `Rule ${ruleId} not found.`,
+                            remainingRules: status.rules.length,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+}

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

@@ -1 +1 @@
-export { AdvancedToolHandlersRuntime as AdvancedToolHandlers } from '../../domains/network/handlers.impl.core.runtime.replay.js';
+export { AdvancedToolHandlersIntercept as AdvancedToolHandlers } from '../../domains/network/handlers.impl.core.runtime.intercept.js';

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

@@ -156,6 +156,21 @@ const manifest = {
             domain: DOMAIN,
             bind: b((h, a) => h.handleNetworkReplayRequest(a)),
         },
+        {
+            tool: t('network_intercept_response'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleNetworkInterceptResponse(a)),
+        },
+        {
+            tool: t('network_intercept_list'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleNetworkInterceptList(a)),
+        },
+        {
+            tool: t('network_intercept_disable'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleNetworkInterceptDisable(a)),
+        },
     ],
 };
 export default manifest;

package/dist/src/server/domains/network/replay.js

@@ -126,14 +126,11 @@ export async function replayRequest(base, args, maxBodyBytes = 512_000) {
         let currentBody = body;
         let resp;
         for (let hop = 0; hop < MAX_REDIRECTS; hop++) {
-            const { pinnedUrl, originalHost } = await resolvePinned(currentUrl);
+            const { pinnedUrl } = await resolvePinned(currentUrl);
             if (!pinnedUrl.startsWith('https://') && !LOOPBACK_HTTP_URL_RE.test(pinnedUrl)) {
                 throw new Error(`Replay blocked: insecure HTTP is only allowed for loopback targets, got "${currentUrl}"`);
             }
             const hopHeaders = { ...mergedHeaders };
-            if (pinnedUrl !== currentUrl && !hopHeaders['host'] && !hopHeaders['Host']) {
-                hopHeaders['Host'] = originalHost;
-            }
             resp = await fetch(pinnedUrl, {
                 method: currentMethod,
                 headers: hopHeaders,