@jshookmcp/jshook 0.2.0 → 0.2.1

package/dist/src/server/domains/encoding/{handlers.impl.core.runtime.format.d.ts → handlers.base.d.ts}

@@ -1,6 +1,6 @@
 import type { CodeCollector } from '../../domains/shared/modules.js';
-import type { DecodeEncoding, OutputFormat } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export declare class EncodingToolHandlersFormat {
+import { type ByteFrequencyEntry, type DecodeEncoding, type DetectSource, type EntropyAssessment, type EntropySource, type OutputFormat } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
+export declare class EncodingHandlersBase {
     protected collector: CodeCollector;
     constructor(collector: CodeCollector);
     protected isMostlyPrintableText(text: string): boolean;
@@ -39,4 +39,24 @@ export declare class EncodingToolHandlersFormat {
             text: string;
         }[];
     };
+    protected resolveBufferBySource(options: {
+        source: DetectSource | EntropySource;
+        data?: string;
+        filePath?: string;
+        maxBytes?: number;
+    }): Promise<Buffer>;
+    protected resolveRequestBodyFromActivePage(requestId: string): Promise<Buffer | null>;
+    protected detectMagicFormats(buffer: Buffer): string[];
+    protected detectStructuredFormats(buffer: Buffer): string[];
+    protected detectEncodingSignals(source: DetectSource, data: string | undefined, buffer: Buffer): string[];
+    protected calculateShannonEntropy(buffer: Buffer): number;
+    protected calculateByteFrequency(buffer: Buffer): ByteFrequencyEntry[];
+    protected calculateBlockEntropies(buffer: Buffer, blockSize: number): Array<{
+        index: number;
+        start: number;
+        end: number;
+        entropy: number;
+    }>;
+    protected assessEntropy(entropy: number, buffer: Buffer): EntropyAssessment;
+    protected printableRatio(buffer: Buffer): number;
 }

package/dist/src/server/domains/encoding/{handlers.impl.core.runtime.analysis.js → handlers.base.js}

@@ -1,9 +1,197 @@
 import { readFile, realpath } from 'node:fs/promises';
-import { resolve, isAbsolute } from 'node:path';
-import { tmpdir, homedir } from 'node:os';
-import { EncodingToolHandlersFormat } from '../../domains/encoding/handlers.impl.core.runtime.format.js';
+import { isAbsolute, resolve } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
 import { MAGIC_SIGNATURES, } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export class EncodingToolHandlersAnalysis extends EncodingToolHandlersFormat {
+export class EncodingHandlersBase {
+    collector;
+    constructor(collector) {
+        this.collector = collector;
+    }
+    isMostlyPrintableText(text) {
+        if (text.length === 0) {
+            return true;
+        }
+        let printable = 0;
+        for (const ch of text) {
+            const code = ch.charCodeAt(0);
+            if ((code >= 0x20 && code <= 0x7e) || code === 0x09 || code === 0x0a || code === 0x0d) {
+                printable += 1;
+            }
+        }
+        return printable / text.length >= 0.85;
+    }
+    previewHex(buffer, maxBytes) {
+        const sample = buffer.subarray(0, maxBytes);
+        return Array.from(sample.values())
+            .map((value) => value.toString(16).padStart(2, '0'))
+            .join(' ');
+    }
+    hexDump(buffer, bytesPerRow = 16) {
+        const lines = [];
+        for (let offset = 0; offset < buffer.length; offset += bytesPerRow) {
+            const row = buffer.subarray(offset, offset + bytesPerRow);
+            const hex = Array.from(row.values())
+                .map((value) => value.toString(16).padStart(2, '0'))
+                .join(' ');
+            const ascii = Array.from(row.values())
+                .map((value) => (value >= 0x20 && value <= 0x7e ? String.fromCharCode(value) : '.'))
+                .join('');
+            lines.push(`${offset.toString(16).padStart(8, '0')}  ${hex.padEnd(47)}  |${ascii}|`);
+        }
+        return lines.join('\n');
+    }
+    decodeHexString(value) {
+        const cleaned = value
+            .trim()
+            .replace(/^0x/i, '')
+            .replace(/[\s:,-]/g, '');
+        if (cleaned.length === 0) {
+            return Buffer.alloc(0);
+        }
+        if (cleaned.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(cleaned)) {
+            throw new Error('Invalid hex string');
+        }
+        return Buffer.from(cleaned, 'hex');
+    }
+    decodeBase64String(value) {
+        const cleaned = value.trim().replace(/\s+/g, '');
+        if (cleaned.length === 0) {
+            return Buffer.alloc(0);
+        }
+        if (!this.looksLikeBase64(cleaned)) {
+            throw new Error('Invalid base64 string');
+        }
+        return Buffer.from(cleaned, 'base64');
+    }
+    decodeBinaryAuto(value) {
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            return Buffer.alloc(0);
+        }
+        if (this.looksLikeHex(trimmed)) {
+            return this.decodeHexString(trimmed);
+        }
+        if (this.looksLikeBase64(trimmed)) {
+            return this.decodeBase64String(trimmed);
+        }
+        return Buffer.from(trimmed, 'utf8');
+    }
+    looksLikeHex(value) {
+        const cleaned = value
+            .trim()
+            .replace(/^0x/i, '')
+            .replace(/[\s:,-]/g, '');
+        return cleaned.length > 0 && cleaned.length % 2 === 0 && /^[0-9a-fA-F]+$/.test(cleaned);
+    }
+    looksLikeBase64(value) {
+        const cleaned = value.trim().replace(/\s+/g, '');
+        if (cleaned.length === 0 || cleaned.length % 4 !== 0) {
+            return false;
+        }
+        if (!/^[A-Za-z0-9+/]*={0,2}$/.test(cleaned)) {
+            return false;
+        }
+        try {
+            const decoded = Buffer.from(cleaned, 'base64');
+            const normalizedInput = cleaned.replace(/=+$/, '');
+            const normalizedRoundtrip = decoded.toString('base64').replace(/=+$/, '');
+            return normalizedInput === normalizedRoundtrip;
+        }
+        catch {
+            return false;
+        }
+    }
+    looksLikeUrlEncoded(value) {
+        return /%[0-9a-fA-F]{2}/.test(value) || /\+/.test(value);
+    }
+    decodeUrl(value) {
+        return decodeURIComponent(value.replace(/\+/g, '%20'));
+    }
+    encodeUrlBytes(buffer) {
+        let encoded = '';
+        for (const value of buffer.values()) {
+            const isAlphaNum = (value >= 0x30 && value <= 0x39) ||
+                (value >= 0x41 && value <= 0x5a) ||
+                (value >= 0x61 && value <= 0x7a);
+            const isUnreserved = value === 0x2d || value === 0x2e || value === 0x5f || value === 0x7e;
+            if (isAlphaNum || isUnreserved) {
+                encoded += String.fromCharCode(value);
+            }
+            else {
+                encoded += `%${value.toString(16).toUpperCase().padStart(2, '0')}`;
+            }
+        }
+        return encoded;
+    }
+    toSafeUtf8(buffer) {
+        const text = buffer.toString('utf8');
+        if ((text.match(/\uFFFD/g) ?? []).length > 0) {
+            return null;
+        }
+        return text;
+    }
+    tryParseJson(text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    renderDecodedOutput(params) {
+        const { encoding, outputFormat, buffer, jsonValue } = params;
+        if (outputFormat === 'hex') {
+            return this.ok({
+                success: true,
+                encoding,
+                outputFormat,
+                byteLength: buffer.length,
+                result: buffer.toString('hex'),
+                hexDump: this.hexDump(buffer),
+            });
+        }
+        if (outputFormat === 'utf8') {
+            return this.ok({
+                success: true,
+                encoding,
+                outputFormat,
+                byteLength: buffer.length,
+                result: buffer.toString('utf8'),
+            });
+        }
+        const utf8 = this.toSafeUtf8(buffer);
+        const maybeJson = utf8 === null ? null : this.tryParseJson(utf8);
+        return this.ok({
+            success: true,
+            encoding,
+            outputFormat,
+            byteLength: buffer.length,
+            result: jsonValue ??
+                {
+                    parsedJson: maybeJson,
+                    utf8,
+                    hex: buffer.toString('hex'),
+                },
+        });
+    }
+    ok(payload) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(payload, null, 2),
+                },
+            ],
+        };
+    }
+    fail(tool, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return this.ok({
+            success: false,
+            tool,
+            error: message,
+        });
+    }
     async resolveBufferBySource(options) {
         const { source, data, filePath, maxBytes } = options;
         if (source === 'file') {

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

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

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

@@ -1,5 +1,5 @@
-import { EncodingToolHandlersParsers } from '../../domains/encoding/handlers.impl.core.runtime.parsers.js';
-export declare class EncodingToolHandlers extends EncodingToolHandlersParsers {
+import { EncodingHandlersBase } from '../../domains/encoding/handlers.base.js';
+export declare class EncodingToolHandlers extends EncodingHandlersBase {
     handleBinaryDetectFormat(args: Record<string, unknown>): Promise<{
         content: {
             type: string;

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

@@ -1,16 +1,15 @@
-import { EncodingToolHandlersParsers } from '../../domains/encoding/handlers.impl.core.runtime.parsers.js';
+import { EncodingHandlersBase } from '../../domains/encoding/handlers.base.js';
+import { parseProtobufMessage } from '../../domains/encoding/encoding-protobuf.js';
+import { decodeMsgPack } from '../../domains/encoding/encoding-msgpack.js';
 import { DECODE_ENCODING_SET, DETECT_SOURCE_SET, ENTROPY_SOURCE_SET, INPUT_FORMAT_SET, OUTPUT_ENCODING_SET, OUTPUT_FORMAT_SET, } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export class EncodingToolHandlers extends EncodingToolHandlersParsers {
+import { argString, argNumber, argEnum } from '../../domains/shared/parse-args.js';
+export class EncodingToolHandlers extends EncodingHandlersBase {
     async handleBinaryDetectFormat(args) {
         try {
-            const sourceRaw = args.source ?? 'raw';
-            if (!DETECT_SOURCE_SET.has(sourceRaw)) {
-                throw new Error(`Invalid source: ${sourceRaw}`);
-            }
-            const source = sourceRaw;
-            const data = typeof args.data === 'string' ? args.data : undefined;
-            const filePath = typeof args.filePath === 'string' ? args.filePath : undefined;
-            const requestId = typeof args.requestId === 'string' ? args.requestId : undefined;
+            const source = argEnum(args, 'source', DETECT_SOURCE_SET, 'raw');
+            const data = argString(args, 'data');
+            const filePath = argString(args, 'filePath');
+            const requestId = argString(args, 'requestId');
             let buffer = null;
             let requestBodyUsed = false;
             if (source === 'raw' && requestId) {
@@ -54,20 +53,15 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
     }
     async handleBinaryDecode(args) {
         try {
-            const data = typeof args.data === 'string' ? args.data : '';
-            const encodingRaw = args.encoding ?? '';
-            const outputFormatRaw = args.outputFormat ?? 'hex';
+            const data = argString(args, 'data', '');
+            const encoding = argEnum(args, 'encoding', DECODE_ENCODING_SET);
+            const outputFormat = argEnum(args, 'outputFormat', OUTPUT_FORMAT_SET, 'hex');
             if (!data) {
                 throw new Error('data is required');
             }
-            if (!DECODE_ENCODING_SET.has(encodingRaw)) {
-                throw new Error(`Invalid encoding: ${encodingRaw}`);
-            }
-            if (!OUTPUT_FORMAT_SET.has(outputFormatRaw)) {
-                throw new Error(`Invalid outputFormat: ${outputFormatRaw}`);
+            if (!encoding) {
+                throw new Error('encoding is required');
             }
-            const encoding = encodingRaw;
-            const outputFormat = outputFormatRaw;
             if (encoding === 'url') {
                 const decoded = this.decodeUrl(data);
                 if (outputFormat === 'hex') {
@@ -103,7 +97,7 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
                     ? this.decodeHexString(data)
                     : this.decodeBinaryAuto(data);
             if (encoding === 'protobuf') {
-                const parsed = this.parseProtobufMessage(rawBuffer, 0, 5);
+                const parsed = parseProtobufMessage(rawBuffer, 0, 5);
                 return this.renderDecodedOutput({
                     encoding,
                     outputFormat,
@@ -116,7 +110,7 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
                 });
             }
             if (encoding === 'msgpack') {
-                const parsed = this.decodeMsgPack(rawBuffer);
+                const parsed = decodeMsgPack(rawBuffer);
                 return this.renderDecodedOutput({
                     encoding,
                     outputFormat,
@@ -136,20 +130,12 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
     }
     async handleBinaryEncode(args) {
         try {
-            const data = typeof args.data === 'string' ? args.data : '';
-            const inputFormatRaw = args.inputFormat ?? '';
-            const outputEncodingRaw = args.outputEncoding ?? '';
+            const data = argString(args, 'data', '');
+            const inputFormat = argEnum(args, 'inputFormat', INPUT_FORMAT_SET, 'utf8');
+            const outputEncoding = argEnum(args, 'outputEncoding', OUTPUT_ENCODING_SET, 'base64');
             if (!data) {
                 throw new Error('data is required');
             }
-            if (!INPUT_FORMAT_SET.has(inputFormatRaw)) {
-                throw new Error(`Invalid inputFormat: ${inputFormatRaw}`);
-            }
-            if (!OUTPUT_ENCODING_SET.has(outputEncodingRaw)) {
-                throw new Error(`Invalid outputEncoding: ${outputEncodingRaw}`);
-            }
-            const inputFormat = inputFormatRaw;
-            const outputEncoding = outputEncodingRaw;
             let buffer;
             if (inputFormat === 'utf8') {
                 buffer = Buffer.from(data, 'utf8');
@@ -180,17 +166,13 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
     }
     async handleBinaryEntropyAnalysis(args) {
         try {
-            const sourceRaw = args.source ?? 'raw';
-            if (!ENTROPY_SOURCE_SET.has(sourceRaw)) {
-                throw new Error(`Invalid source: ${sourceRaw}`);
-            }
-            const source = sourceRaw;
-            const data = typeof args.data === 'string' ? args.data : undefined;
-            const filePath = typeof args.filePath === 'string' ? args.filePath : undefined;
+            const source = argEnum(args, 'source', ENTROPY_SOURCE_SET, 'raw');
+            const data = argString(args, 'data');
+            const filePath = argString(args, 'filePath');
             if (source !== 'file' && !data) {
                 throw new Error('data is required for non-file source');
             }
-            const blockSizeRaw = typeof args.blockSize === 'number' ? args.blockSize : 256;
+            const blockSizeRaw = argNumber(args, 'blockSize', 256);
             const blockSize = Math.max(16, Math.min(8192, Math.trunc(blockSizeRaw || 256)));
             const buffer = await this.resolveBufferBySource({
                 source,
@@ -218,14 +200,14 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
     }
     async handleProtobufDecodeRaw(args) {
         try {
-            const data = typeof args.data === 'string' ? args.data : '';
+            const data = argString(args, 'data', '');
             if (!data) {
                 throw new Error('data is required');
             }
-            const maxDepthRaw = typeof args.maxDepth === 'number' ? args.maxDepth : 5;
+            const maxDepthRaw = argNumber(args, 'maxDepth', 5);
             const maxDepth = Math.max(1, Math.min(20, Math.trunc(maxDepthRaw || 5)));
             const buffer = this.decodeBase64String(data);
-            const parsed = this.parseProtobufMessage(buffer, 0, maxDepth);
+            const parsed = parseProtobufMessage(buffer, 0, maxDepth);
             return this.ok({
                 success: parsed.error === undefined,
                 byteLength: buffer.length,

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

@@ -30,7 +30,10 @@ export interface MsgPackDecodeResult {
     value: unknown;
     offset: number;
 }
-export declare const MAGIC_SIGNATURES: ReadonlyArray<MagicSignature>;
+export declare const MAGIC_SIGNATURES: {
+    format: string;
+    bytes: number[];
+}[];
 export declare const DETECT_SOURCE_SET: ReadonlySet<DetectSource>;
 export declare const ENTROPY_SOURCE_SET: ReadonlySet<EntropySource>;
 export declare const DECODE_ENCODING_SET: ReadonlySet<DecodeEncoding>;

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

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

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/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>;
+}