@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/src/server/domains/graphql/handlers.base.d.ts

@@ -0,0 +1,39 @@
+import type { Page } from 'rebrowser-puppeteer-core';
+import type { CodeCollector } from '../../domains/shared/modules.js';
+import type { InterceptRequest, PreviewPayload, ScriptMatchType, ScriptReplaceRule } from '../../domains/graphql/handlers.impl.core.runtime.shared.js';
+export { GraphQLHandlersBase as GraphQLToolHandlersBase };
+export declare class GraphQLHandlersBase {
+    protected readonly collector: CodeCollector;
+    protected readonly scriptReplaceRules: ScriptReplaceRule[];
+    protected readonly interceptionInstalledPages: WeakSet<Page>;
+    constructor(collector: CodeCollector);
+    protected toResponse(payload: unknown): {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    };
+    protected toError(error: unknown, context?: Record<string, unknown>): {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError: boolean;
+    };
+    protected getErrorMessage(error: unknown): string;
+    protected getStringArg(args: Record<string, unknown>, key: string): string | null;
+    protected getNumberArg(args: Record<string, unknown>, key: string, defaultValue: number, min: number, max: number): number;
+    protected getObjectArg(args: Record<string, unknown>, key: string): Record<string, unknown> | null;
+    protected normalizeHeaders(value: unknown): Record<string, string>;
+    protected validateExternalEndpoint(endpoint: string): Promise<string | null>;
+    protected createPreview(text: string, maxChars: number): PreviewPayload;
+    protected serializeForPreview(value: unknown, maxChars: number): PreviewPayload;
+    protected parseMatchType(value: unknown): ScriptMatchType;
+    protected generateRuleId(): string;
+    protected isRequestInterceptHandled(request: InterceptRequest): boolean;
+    protected continueRequest(request: InterceptRequest): Promise<void>;
+    protected ruleMatchesUrl(rule: ScriptReplaceRule, targetUrl: string): boolean;
+    protected findMatchingRule(url: string): ScriptReplaceRule | null;
+    protected handleInterceptedRequest(request: InterceptRequest): Promise<void>;
+    protected ensureScriptInterception(page: Page): Promise<void>;
+}

package/dist/src/server/domains/graphql/handlers.base.js

@@ -0,0 +1,240 @@
+import { isSsrfTarget } from '../../domains/network/replay.js';
+export { GraphQLHandlersBase as GraphQLToolHandlersBase };
+export class GraphQLHandlersBase {
+    collector;
+    scriptReplaceRules = [];
+    interceptionInstalledPages = new WeakSet();
+    constructor(collector) {
+        this.collector = collector;
+    }
+    toResponse(payload) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(payload, null, 2),
+                },
+            ],
+        };
+    }
+    toError(error, context) {
+        const payload = {
+            success: false,
+            error: this.getErrorMessage(error),
+        };
+        if (context) {
+            payload.context = context;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(payload, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+    getErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return String(error);
+    }
+    getStringArg(args, key) {
+        const value = args[key];
+        return typeof value === 'string' ? value : null;
+    }
+    getNumberArg(args, key, defaultValue, min, max) {
+        const value = args[key];
+        let parsed = defaultValue;
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            parsed = value;
+        }
+        else if (typeof value === 'string') {
+            const fromString = Number(value);
+            if (Number.isFinite(fromString)) {
+                parsed = fromString;
+            }
+        }
+        if (parsed < min) {
+            return min;
+        }
+        if (parsed > max) {
+            return max;
+        }
+        return Math.trunc(parsed);
+    }
+    getObjectArg(args, key) {
+        const value = args[key];
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            return value;
+        }
+        return null;
+    }
+    normalizeHeaders(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return {};
+        }
+        const dangerousKeys = new Set(['__proto__', 'constructor', 'prototype']);
+        const headers = Object.create(null);
+        for (const [header, rawValue] of Object.entries(value)) {
+            if (dangerousKeys.has(header))
+                continue;
+            if (typeof rawValue === 'string') {
+                headers[header] = rawValue;
+            }
+            else if (typeof rawValue === 'number' || typeof rawValue === 'boolean') {
+                headers[header] = String(rawValue);
+            }
+        }
+        return headers;
+    }
+    async validateExternalEndpoint(endpoint) {
+        let parsedEndpoint;
+        try {
+            parsedEndpoint = new URL(endpoint);
+        }
+        catch {
+            return `Invalid endpoint URL: ${endpoint}`;
+        }
+        if (parsedEndpoint.protocol !== 'http:' && parsedEndpoint.protocol !== 'https:') {
+            return `Unsupported endpoint protocol: ${parsedEndpoint.protocol} — only http/https allowed`;
+        }
+        if (await isSsrfTarget(parsedEndpoint.toString())) {
+            return `Blocked: endpoint "${endpoint}" resolves to a private/reserved address`;
+        }
+        return null;
+    }
+    createPreview(text, maxChars) {
+        if (text.length <= maxChars) {
+            return {
+                preview: text,
+                truncated: false,
+                totalLength: text.length,
+            };
+        }
+        return {
+            preview: `${text.slice(0, maxChars)}\n... (truncated)`,
+            truncated: true,
+            totalLength: text.length,
+        };
+    }
+    serializeForPreview(value, maxChars) {
+        let serialized;
+        if (typeof value === 'string') {
+            serialized = value;
+        }
+        else {
+            try {
+                serialized = JSON.stringify(value, null, 2);
+            }
+            catch {
+                serialized = String(value);
+            }
+        }
+        return this.createPreview(serialized, maxChars);
+    }
+    parseMatchType(value) {
+        if (value === 'exact' || value === 'contains' || value === 'regex') {
+            return value;
+        }
+        return 'contains';
+    }
+    generateRuleId() {
+        return `script_rule_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    }
+    isRequestInterceptHandled(request) {
+        if (typeof request.isInterceptResolutionHandled !== 'function') {
+            return false;
+        }
+        try {
+            return request.isInterceptResolutionHandled();
+        }
+        catch {
+            return false;
+        }
+    }
+    async continueRequest(request) {
+        if (this.isRequestInterceptHandled(request)) {
+            return;
+        }
+        try {
+            await request.continue();
+        }
+        catch {
+        }
+    }
+    ruleMatchesUrl(rule, targetUrl) {
+        if (rule.matchType === 'exact') {
+            return targetUrl === rule.url;
+        }
+        if (rule.matchType === 'contains') {
+            return targetUrl.includes(rule.url);
+        }
+        try {
+            const regex = new RegExp(rule.url);
+            return regex.test(targetUrl);
+        }
+        catch {
+            return false;
+        }
+    }
+    findMatchingRule(url) {
+        for (let index = this.scriptReplaceRules.length - 1; index >= 0; index -= 1) {
+            const rule = this.scriptReplaceRules[index];
+            if (rule && this.ruleMatchesUrl(rule, url)) {
+                return rule;
+            }
+        }
+        return null;
+    }
+    async handleInterceptedRequest(request) {
+        if (this.isRequestInterceptHandled(request)) {
+            return;
+        }
+        const resourceType = request.resourceType();
+        if (resourceType !== 'script') {
+            await this.continueRequest(request);
+            return;
+        }
+        const requestUrl = request.url();
+        const matchedRule = this.findMatchingRule(requestUrl);
+        if (!matchedRule) {
+            await this.continueRequest(request);
+            return;
+        }
+        matchedRule.hits += 1;
+        try {
+            await request.respond({
+                status: 200,
+                contentType: 'application/javascript; charset=utf-8',
+                headers: {
+                    'cache-control': 'no-store',
+                    'x-script-replaced-by': 'script_replace_persist',
+                },
+                body: matchedRule.replacement,
+            });
+        }
+        catch {
+            await this.continueRequest(request);
+        }
+    }
+    async ensureScriptInterception(page) {
+        if (this.interceptionInstalledPages.has(page)) {
+            return;
+        }
+        await page.setRequestInterception(true);
+        const listener = (request) => {
+            void this.handleInterceptedRequest(request);
+        };
+        const eventHost = page;
+        if (typeof eventHost.prependListener === 'function') {
+            eventHost.prependListener('request', listener);
+        }
+        else {
+            eventHost.on('request', listener);
+        }
+        this.interceptionInstalledPages.add(page);
+    }
+}

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

@@ -1,38 +1 @@
-import type { Page } from 'rebrowser-puppeteer-core';
-import type { CodeCollector } from '../../domains/shared/modules.js';
-import type { InterceptRequest, PreviewPayload, ScriptMatchType, ScriptReplaceRule } from '../../domains/graphql/handlers.impl.core.runtime.shared.js';
-export declare class GraphQLToolHandlersBase {
-    protected readonly collector: CodeCollector;
-    protected readonly scriptReplaceRules: ScriptReplaceRule[];
-    protected readonly interceptionInstalledPages: WeakSet<Page>;
-    constructor(collector: CodeCollector);
-    protected toResponse(payload: unknown): {
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    };
-    protected toError(error: unknown, context?: Record<string, unknown>): {
-        content: {
-            type: "text";
-            text: string;
-        }[];
-        isError: boolean;
-    };
-    protected getErrorMessage(error: unknown): string;
-    protected getStringArg(args: Record<string, unknown>, key: string): string | null;
-    protected getNumberArg(args: Record<string, unknown>, key: string, defaultValue: number, min: number, max: number): number;
-    protected getObjectArg(args: Record<string, unknown>, key: string): Record<string, unknown> | null;
-    protected normalizeHeaders(value: unknown): Record<string, string>;
-    protected validateExternalEndpoint(endpoint: string): Promise<string | null>;
-    protected createPreview(text: string, maxChars: number): PreviewPayload;
-    protected serializeForPreview(value: unknown, maxChars: number): PreviewPayload;
-    protected parseMatchType(value: unknown): ScriptMatchType;
-    protected generateRuleId(): string;
-    protected isRequestInterceptHandled(request: InterceptRequest): boolean;
-    protected continueRequest(request: InterceptRequest): Promise<void>;
-    protected ruleMatchesUrl(rule: ScriptReplaceRule, targetUrl: string): boolean;
-    protected findMatchingRule(url: string): ScriptReplaceRule | null;
-    protected handleInterceptedRequest(request: InterceptRequest): Promise<void>;
-    protected ensureScriptInterception(page: Page): Promise<void>;
-}
+export { GraphQLHandlersBase as GraphQLToolHandlersBase } from '../../domains/graphql/handlers.base.js';

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

@@ -1,239 +1 @@
-import { isSsrfTarget } from '../../domains/network/replay.js';
-export class GraphQLToolHandlersBase {
-    collector;
-    scriptReplaceRules = [];
-    interceptionInstalledPages = new WeakSet();
-    constructor(collector) {
-        this.collector = collector;
-    }
-    toResponse(payload) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(payload, null, 2),
-                },
-            ],
-        };
-    }
-    toError(error, context) {
-        const payload = {
-            success: false,
-            error: this.getErrorMessage(error),
-        };
-        if (context) {
-            payload.context = context;
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(payload, null, 2),
-                },
-            ],
-            isError: true,
-        };
-    }
-    getErrorMessage(error) {
-        if (error instanceof Error) {
-            return error.message;
-        }
-        return String(error);
-    }
-    getStringArg(args, key) {
-        const value = args[key];
-        return typeof value === 'string' ? value : null;
-    }
-    getNumberArg(args, key, defaultValue, min, max) {
-        const value = args[key];
-        let parsed = defaultValue;
-        if (typeof value === 'number' && Number.isFinite(value)) {
-            parsed = value;
-        }
-        else if (typeof value === 'string') {
-            const fromString = Number(value);
-            if (Number.isFinite(fromString)) {
-                parsed = fromString;
-            }
-        }
-        if (parsed < min) {
-            return min;
-        }
-        if (parsed > max) {
-            return max;
-        }
-        return Math.trunc(parsed);
-    }
-    getObjectArg(args, key) {
-        const value = args[key];
-        if (value && typeof value === 'object' && !Array.isArray(value)) {
-            return value;
-        }
-        return null;
-    }
-    normalizeHeaders(value) {
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            return {};
-        }
-        const dangerousKeys = new Set(['__proto__', 'constructor', 'prototype']);
-        const headers = Object.create(null);
-        for (const [header, rawValue] of Object.entries(value)) {
-            if (dangerousKeys.has(header))
-                continue;
-            if (typeof rawValue === 'string') {
-                headers[header] = rawValue;
-            }
-            else if (typeof rawValue === 'number' || typeof rawValue === 'boolean') {
-                headers[header] = String(rawValue);
-            }
-        }
-        return headers;
-    }
-    async validateExternalEndpoint(endpoint) {
-        let parsedEndpoint;
-        try {
-            parsedEndpoint = new URL(endpoint);
-        }
-        catch {
-            return `Invalid endpoint URL: ${endpoint}`;
-        }
-        if (parsedEndpoint.protocol !== 'http:' && parsedEndpoint.protocol !== 'https:') {
-            return `Unsupported endpoint protocol: ${parsedEndpoint.protocol} — only http/https allowed`;
-        }
-        if (await isSsrfTarget(parsedEndpoint.toString())) {
-            return `Blocked: endpoint "${endpoint}" resolves to a private/reserved address`;
-        }
-        return null;
-    }
-    createPreview(text, maxChars) {
-        if (text.length <= maxChars) {
-            return {
-                preview: text,
-                truncated: false,
-                totalLength: text.length,
-            };
-        }
-        return {
-            preview: `${text.slice(0, maxChars)}\n... (truncated)`,
-            truncated: true,
-            totalLength: text.length,
-        };
-    }
-    serializeForPreview(value, maxChars) {
-        let serialized;
-        if (typeof value === 'string') {
-            serialized = value;
-        }
-        else {
-            try {
-                serialized = JSON.stringify(value, null, 2);
-            }
-            catch {
-                serialized = String(value);
-            }
-        }
-        return this.createPreview(serialized, maxChars);
-    }
-    parseMatchType(value) {
-        if (value === 'exact' || value === 'contains' || value === 'regex') {
-            return value;
-        }
-        return 'contains';
-    }
-    generateRuleId() {
-        return `script_rule_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    }
-    isRequestInterceptHandled(request) {
-        if (typeof request.isInterceptResolutionHandled !== 'function') {
-            return false;
-        }
-        try {
-            return request.isInterceptResolutionHandled();
-        }
-        catch {
-            return false;
-        }
-    }
-    async continueRequest(request) {
-        if (this.isRequestInterceptHandled(request)) {
-            return;
-        }
-        try {
-            await request.continue();
-        }
-        catch {
-        }
-    }
-    ruleMatchesUrl(rule, targetUrl) {
-        if (rule.matchType === 'exact') {
-            return targetUrl === rule.url;
-        }
-        if (rule.matchType === 'contains') {
-            return targetUrl.includes(rule.url);
-        }
-        try {
-            const regex = new RegExp(rule.url);
-            return regex.test(targetUrl);
-        }
-        catch {
-            return false;
-        }
-    }
-    findMatchingRule(url) {
-        for (let index = this.scriptReplaceRules.length - 1; index >= 0; index -= 1) {
-            const rule = this.scriptReplaceRules[index];
-            if (rule && this.ruleMatchesUrl(rule, url)) {
-                return rule;
-            }
-        }
-        return null;
-    }
-    async handleInterceptedRequest(request) {
-        if (this.isRequestInterceptHandled(request)) {
-            return;
-        }
-        const resourceType = request.resourceType();
-        if (resourceType !== 'script') {
-            await this.continueRequest(request);
-            return;
-        }
-        const requestUrl = request.url();
-        const matchedRule = this.findMatchingRule(requestUrl);
-        if (!matchedRule) {
-            await this.continueRequest(request);
-            return;
-        }
-        matchedRule.hits += 1;
-        try {
-            await request.respond({
-                status: 200,
-                contentType: 'application/javascript; charset=utf-8',
-                headers: {
-                    'cache-control': 'no-store',
-                    'x-script-replaced-by': 'script_replace_persist',
-                },
-                body: matchedRule.replacement,
-            });
-        }
-        catch {
-            await this.continueRequest(request);
-        }
-    }
-    async ensureScriptInterception(page) {
-        if (this.interceptionInstalledPages.has(page)) {
-            return;
-        }
-        await page.setRequestInterception(true);
-        const listener = (request) => {
-            void this.handleInterceptedRequest(request);
-        };
-        const eventHost = page;
-        if (typeof eventHost.prependListener === 'function') {
-            eventHost.prependListener('request', listener);
-        }
-        else {
-            eventHost.on('request', listener);
-        }
-        this.interceptionInstalledPages.add(page);
-    }
-}
+export { GraphQLHandlersBase as GraphQLToolHandlersBase } from '../../domains/graphql/handlers.base.js';

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

@@ -1,9 +1 @@
-import { GraphQLToolHandlersBase } from '../../domains/graphql/handlers.impl.core.runtime.base.js';
-export declare class GraphQLToolHandlersCallGraph extends GraphQLToolHandlersBase {
-    handleCallGraphAnalyze(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-}
+export { GraphQLToolHandlersRuntime as GraphQLToolHandlersCallGraph, } from '../../domains/graphql/handlers.impl.core.runtime.replay.js';