@jshookmcp/jshook 0.2.0 → 0.2.2

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

@@ -1,7 +1,57 @@
-import type { DomainManifest } from '../../domains/shared/registry.js';
+import type { MCPServerContext } from '../../domains/shared/registry.js';
 import { EncodingToolHandlers } from '../../domains/encoding/index.js';
-declare const DOMAIN: "encoding";
-declare const DEP_KEY: "encodingHandlers";
 type H = EncodingToolHandlers;
-declare const manifest: DomainManifest<typeof DEP_KEY, H, typeof DOMAIN>;
+declare function ensure(ctx: MCPServerContext): H;
+declare const manifest: {
+    kind: "domain-manifest";
+    version: 1;
+    domain: "encoding";
+    depKey: "encodingHandlers";
+    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: "encoding";
+        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
+    }[];
+};
 export default manifest;

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

@@ -16,16 +16,30 @@ function ensure(ctx) {
     return ctx.encodingHandlers;
 }
 const manifest = {
-    kind: 'domain-manifest', version: 1,
-    domain: DOMAIN, depKey: DEP_KEY,
+    kind: 'domain-manifest',
+    version: 1,
+    domain: DOMAIN,
+    depKey: DEP_KEY,
     profiles: ['workflow', 'full'],
     ensure,
     registrations: [
-        { tool: t('binary_detect_format'), domain: DOMAIN, bind: b((h, a) => h.handleBinaryDetectFormat(a)) },
+        {
+            tool: t('binary_detect_format'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleBinaryDetectFormat(a)),
+        },
         { tool: t('binary_decode'), domain: DOMAIN, bind: b((h, a) => h.handleBinaryDecode(a)) },
         { tool: t('binary_encode'), domain: DOMAIN, bind: b((h, a) => h.handleBinaryEncode(a)) },
-        { tool: t('binary_entropy_analysis'), domain: DOMAIN, bind: b((h, a) => h.handleBinaryEntropyAnalysis(a)) },
-        { tool: t('protobuf_decode_raw'), domain: DOMAIN, bind: b((h, a) => h.handleProtobufDecodeRaw(a)) },
+        {
+            tool: t('binary_entropy_analysis'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleBinaryEntropyAnalysis(a)),
+        },
+        {
+            tool: t('protobuf_decode_raw'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleProtobufDecodeRaw(a)),
+        },
     ],
 };
 export default manifest;

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

@@ -16,6 +16,12 @@ export const graphqlTools = [
                 },
             },
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'script_replace_persist',
@@ -40,6 +46,12 @@ export const graphqlTools = [
             },
             required: ['url', 'replacement'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
     },
     {
         name: 'graphql_introspect',
@@ -61,6 +73,12 @@ export const graphqlTools = [
             },
             required: ['endpoint'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
     },
     {
         name: 'graphql_extract_queries',
@@ -75,6 +93,12 @@ export const graphqlTools = [
                 },
             },
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'graphql_replay',
@@ -109,5 +133,11 @@ export const graphqlTools = [
             },
             required: ['endpoint', 'query'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
     },
 ];

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';