@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/domains/transform/handlers.impl.transform-crypto.js

@@ -1,252 +0,0 @@
-import { CRYPTO_KEYWORDS, } from '../../domains/transform/handlers.impl.transform-base.js';
-import { TransformToolHandlersOps } from '../../domains/transform/handlers.impl.transform-ops.js';
-import { evaluateWithTimeout } from '../../../modules/collector/PageController.js';
-export class TransformToolHandlersCrypto extends TransformToolHandlersOps {
-    async handleCryptoExtractStandalone(args) {
-        try {
-            const targetFunction = this.requireString(args.targetFunction, 'targetFunction').trim();
-            const includePolyfills = this.parseBoolean(args.includePolyfills, true);
-            const page = await this.collector.getActivePage();
-            const extracted = (await evaluateWithTimeout(page, (target, keywords) => {
-                const keywordList = Array.isArray(keywords) ? keywords : [];
-                const lowerKeywords = keywordList.map((item) => String(item).toLowerCase());
-                const globalObj = window;
-                const scoreFunction = (path, source) => {
-                    const text = (path + '\\n' + source).toLowerCase();
-                    let score = 0;
-                    for (const keyword of lowerKeywords) {
-                        if (text.includes(keyword)) {
-                            score += 1;
-                        }
-                    }
-                    return score;
-                };
-                const candidates = [];
-                const pushCandidate = (path, value, boost = 0) => {
-                    if (typeof value !== 'function')
-                        return;
-                    const source = Function.prototype.toString.call(value);
-                    if (source.includes('[native code]'))
-                        return;
-                    const score = scoreFunction(path, source) + boost;
-                    if (score <= 0 && boost <= 0)
-                        return;
-                    candidates.push({
-                        path,
-                        source,
-                        score,
-                    });
-                };
-                if (target.length > 0) {
-                    const resolved = (() => {
-                        const normalized = target.startsWith('window.') ? target.slice(7) : target;
-                        const parts = normalized.split('.').filter(Boolean);
-                        let cursor = window;
-                        for (const part of parts) {
-                            if (cursor === null ||
-                                cursor === undefined ||
-                                (typeof cursor !== 'object' && typeof cursor !== 'function')) {
-                                return undefined;
-                            }
-                            const carrier = cursor;
-                            if (!(part in carrier)) {
-                                return undefined;
-                            }
-                            cursor = carrier[part];
-                        }
-                        return cursor;
-                    })();
-                    pushCandidate(target, resolved, 100);
-                }
-                const globalKeys = Object.getOwnPropertyNames(globalObj).slice(0, 800);
-                for (const key of globalKeys) {
-                    const topValue = globalObj[key];
-                    pushCandidate('window.' + key, topValue);
-                    if (topValue && typeof topValue === 'object') {
-                        const nestedObj = topValue;
-                        const nestedKeys = Object.keys(nestedObj).slice(0, 40);
-                        for (const nestedKey of nestedKeys) {
-                            pushCandidate('window.' + key + '.' + nestedKey, nestedObj[nestedKey]);
-                        }
-                    }
-                }
-                candidates.sort((a, b) => b.score - a.score);
-                const selected = candidates[0];
-                if (!selected) {
-                    return {
-                        targetPath: null,
-                        targetSource: '',
-                        candidates: [],
-                        dependencies: [],
-                        dependencySnippets: [],
-                    };
-                }
-                const identifierRegex = /\\b[A-Za-z_$][A-Za-z0-9_$]{1,}\\b/g;
-                const reserved = new Set([
-                    'function',
-                    'return',
-                    'const',
-                    'let',
-                    'var',
-                    'if',
-                    'else',
-                    'for',
-                    'while',
-                    'switch',
-                    'case',
-                    'break',
-                    'continue',
-                    'new',
-                    'this',
-                    'window',
-                    'globalThis',
-                    'Math',
-                    'JSON',
-                    'Date',
-                    'Array',
-                    'Object',
-                    'String',
-                    'Number',
-                    'Boolean',
-                    'Promise',
-                    'RegExp',
-                    'Error',
-                    'null',
-                    'undefined',
-                    'true',
-                    'false',
-                    'async',
-                    'await',
-                ]);
-                const dependencyNames = Array.from(new Set((selected.source.match(identifierRegex) ?? []).filter((name) => !reserved.has(name)))).slice(0, 30);
-                const dependencySnippets = [];
-                for (const depName of dependencyNames) {
-                    if (!(depName in globalObj))
-                        continue;
-                    const depValue = globalObj[depName];
-                    if (typeof depValue === 'function') {
-                        const depSource = Function.prototype.toString.call(depValue);
-                        if (!depSource.includes('[native code]') && depSource.length < 50000) {
-                            dependencySnippets.push('const ' + depName + ' = ' + depSource + ';');
-                        }
-                        continue;
-                    }
-                    if (depValue === null ||
-                        typeof depValue === 'string' ||
-                        typeof depValue === 'number' ||
-                        typeof depValue === 'boolean') {
-                        dependencySnippets.push('const ' + depName + ' = ' + JSON.stringify(depValue) + ';');
-                        continue;
-                    }
-                    if (typeof depValue === 'object') {
-                        try {
-                            const serialized = JSON.stringify(depValue);
-                            if (serialized && serialized.length < 4000) {
-                                dependencySnippets.push('const ' + depName + ' = ' + serialized + ';');
-                            }
-                        }
-                        catch {
-                        }
-                    }
-                }
-                return {
-                    targetPath: selected.path,
-                    targetSource: selected.source,
-                    candidates: candidates.slice(0, 20),
-                    dependencies: dependencyNames,
-                    dependencySnippets,
-                };
-            }, targetFunction, CRYPTO_KEYWORDS));
-            if (!extracted || extracted.targetSource.trim().length === 0) {
-                throw new Error('No crypto/signature-like function found on current page');
-            }
-            const functionName = this.resolveFunctionName(targetFunction, extracted.targetPath ?? '', extracted.targetSource);
-            const sections = [`'use strict';`];
-            if (includePolyfills) {
-                sections.push(this.buildCryptoPolyfills());
-            }
-            if (extracted.dependencySnippets.length > 0) {
-                sections.push(extracted.dependencySnippets.join('\n'));
-            }
-            sections.push(`const ${functionName} = ${extracted.targetSource.trim()};`);
-            sections.push(`if (typeof globalThis !== 'undefined') { globalThis.${functionName} = ${functionName}; }`);
-            const extractedCode = sections.filter((part) => part.trim().length > 0).join('\n\n');
-            return this.toTextResponse({
-                extractedCode,
-                dependencies: extracted.dependencies,
-                size: extractedCode.length,
-            });
-        }
-        catch (error) {
-            return this.fail('crypto_extract_standalone', error);
-        }
-    }
-    async handleCryptoTestHarness(args) {
-        try {
-            const code = this.requireString(args.code, 'code');
-            const functionName = this.requireString(args.functionName, 'functionName');
-            const testInputs = this.parseTestInputs(args.testInputs);
-            const harness = await this.runCryptoHarness(code, functionName, testInputs);
-            return this.toTextResponse({
-                results: harness.results.map((row) => ({
-                    input: row.input,
-                    output: row.output,
-                    duration: row.duration,
-                    ...(row.error ? { error: row.error } : {}),
-                })),
-                allPassed: harness.allPassed,
-            });
-        }
-        catch (error) {
-            return this.fail('crypto_test_harness', error);
-        }
-    }
-    async handleCryptoCompare(args) {
-        try {
-            const code1 = this.requireString(args.code1, 'code1');
-            const code2 = this.requireString(args.code2, 'code2');
-            const functionName = this.requireString(args.functionName, 'functionName');
-            const testInputs = this.parseTestInputs(args.testInputs);
-            const [run1, run2] = await Promise.all([
-                this.runCryptoHarness(code1, functionName, testInputs),
-                this.runCryptoHarness(code2, functionName, testInputs),
-            ]);
-            const rows = testInputs.map((input, index) => {
-                const left = run1.results[index] ?? {
-                    input,
-                    output: '',
-                    duration: 0,
-                    error: 'missing result from implementation #1',
-                };
-                const right = run2.results[index] ?? {
-                    input,
-                    output: '',
-                    duration: 0,
-                    error: 'missing result from implementation #2',
-                };
-                const sameOutput = left.output === right.output;
-                const noError = !left.error && !right.error;
-                return {
-                    input,
-                    output1: left.output,
-                    output2: right.output,
-                    duration1: left.duration,
-                    duration2: right.duration,
-                    match: sameOutput && noError,
-                    ...(left.error ? { error1: left.error } : {}),
-                    ...(right.error ? { error2: right.error } : {}),
-                };
-            });
-            const matches = rows.filter((row) => row.match).length;
-            const mismatches = rows.length - matches;
-            return this.toTextResponse({
-                matches,
-                mismatches,
-                results: rows,
-            });
-        }
-        catch (error) {
-            return this.fail('crypto_compare', error);
-        }
-    }
-}

package/dist/src/server/domains/transform/handlers.impl.transform-ops.d.ts

@@ -1,14 +0,0 @@
-import type { ApplyResult, TransformKind } from '../../domains/transform/handlers.impl.transform-base.js';
-import { TransformToolHandlersBase } from '../../domains/transform/handlers.impl.transform-base.js';
-export declare class TransformToolHandlersOps extends TransformToolHandlersBase {
-    protected resolveTransformsForApply(chainName: string, transformsRaw: unknown): TransformKind[];
-    protected applyTransforms(code: string, transforms: TransformKind[]): ApplyResult;
-    protected applySingleTransform(code: string, transform: TransformKind): string;
-    protected transformConstantFold(code: string): string;
-    protected transformStringDecrypt(code: string): string;
-    protected transformDeadCodeRemove(code: string): string;
-    protected transformControlFlowFlatten(code: string): string;
-    protected transformRenameVars(code: string): string;
-    protected buildDiff(original: string, transformed: string): string;
-    protected buildFallbackDiff(oldLines: string[], newLines: string[]): string;
-}

package/dist/src/server/domains/transform/handlers.impl.transform-ops.js

@@ -1,224 +0,0 @@
-import { DEAD_CODE_IF_FALSE, DEAD_CODE_IF_FALSE_WITH_ELSE, NUMERIC_BINARY_EXPR, STRING_CONCAT_EXPR, STRING_LITERAL_EXPR, TransformLimit, TransformToolHandlersBase, } from '../../domains/transform/handlers.impl.transform-base.js';
-export class TransformToolHandlersOps extends TransformToolHandlersBase {
-    resolveTransformsForApply(chainName, transformsRaw) {
-        if (chainName.length > 0) {
-            const chain = this.chains.get(chainName);
-            if (!chain) {
-                throw new Error(`Transform chain not found: ${chainName}`);
-            }
-            return [...chain.transforms];
-        }
-        return this.parseTransforms(transformsRaw);
-    }
-    applyTransforms(code, transforms) {
-        let transformed = code;
-        const appliedTransforms = [];
-        for (const transform of transforms) {
-            const before = transformed;
-            transformed = this.applySingleTransform(transformed, transform);
-            if (transformed !== before) {
-                appliedTransforms.push(transform);
-            }
-        }
-        return { transformed, appliedTransforms };
-    }
-    applySingleTransform(code, transform) {
-        switch (transform) {
-            case 'constant_fold':
-                return this.transformConstantFold(code);
-            case 'string_decrypt':
-                return this.transformStringDecrypt(code);
-            case 'dead_code_remove':
-                return this.transformDeadCodeRemove(code);
-            case 'control_flow_flatten':
-                return this.transformControlFlowFlatten(code);
-            case 'rename_vars':
-                return this.transformRenameVars(code);
-            default:
-                return code;
-        }
-    }
-    transformConstantFold(code) {
-        let current = code;
-        for (let round = 0; round < 4; round++) {
-            const numericFolded = current.replace(NUMERIC_BINARY_EXPR, (_full, leftRaw, operator, rightRaw) => {
-                const left = Number(leftRaw);
-                const right = Number(rightRaw);
-                if (!Number.isFinite(left) || !Number.isFinite(right)) {
-                    return `${leftRaw}${operator}${rightRaw}`;
-                }
-                let value = null;
-                switch (operator) {
-                    case '+':
-                        value = left + right;
-                        break;
-                    case '-':
-                        value = left - right;
-                        break;
-                    case '*':
-                        value = left * right;
-                        break;
-                    case '/':
-                        if (right !== 0)
-                            value = left / right;
-                        break;
-                    case '%':
-                        if (right !== 0)
-                            value = left % right;
-                        break;
-                    default:
-                        value = null;
-                }
-                if (value === null || !Number.isFinite(value)) {
-                    return `${leftRaw}${operator}${rightRaw}`;
-                }
-                return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(12)));
-            });
-            const stringFolded = numericFolded.replace(STRING_CONCAT_EXPR, (_full, q1, left, q2, right) => {
-                const quote = q1 === q2 ? q1 : "'";
-                const merged = `${left}${right}`;
-                return `${quote}${this.escapeStringContent(merged, quote)}${quote}`;
-            });
-            if (stringFolded === current) {
-                break;
-            }
-            current = stringFolded;
-        }
-        return current;
-    }
-    transformStringDecrypt(code) {
-        return code.replace(STRING_LITERAL_EXPR, (_full, quote, inner) => {
-            const decoded = this.decodeEscapedString(inner);
-            if (decoded === inner) {
-                return `${quote}${inner}${quote}`;
-            }
-            return `${quote}${this.escapeStringContent(decoded, quote)}${quote}`;
-        });
-    }
-    transformDeadCodeRemove(code) {
-        const withElseSimplified = code.replace(DEAD_CODE_IF_FALSE_WITH_ELSE, (_full, _ifBody, elseBody) => elseBody);
-        return withElseSimplified.replace(DEAD_CODE_IF_FALSE, '');
-    }
-    transformControlFlowFlatten(code) {
-        const flattenedPattern = /var\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*['"]([^'"]+)['"]\.split\(\s*['"]\|['"]\s*\)\s*;\s*var\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*0\s*;\s*while\s*\(\s*!!\[\]\s*\)\s*\{\s*switch\s*\(\s*\1\[\s*\3\+\+\s*\]\s*\)\s*\{([\s\S]*?)\}\s*break;\s*\}/g;
-        return code.replace(flattenedPattern, (_full, _dispatcher, orderRaw, _cursor, switchBody) => {
-            const caseRegex = /case\s*['"]([^'"]+)['"]\s*:\s*([\s\S]*?)(?=case\s*['"]|default\s*:|$)/g;
-            const caseMap = new Map();
-            let match;
-            while ((match = caseRegex.exec(switchBody)) !== null) {
-                const caseKey = match[1];
-                const body = match[2] ?? '';
-                const cleaned = body
-                    .replace(/\bcontinue\s*;?/g, '')
-                    .replace(/\bbreak\s*;?/g, '')
-                    .trim();
-                if (caseKey && cleaned.length > 0) {
-                    caseMap.set(caseKey, cleaned);
-                }
-            }
-            const order = orderRaw.split('|').map((item) => item.trim());
-            const rebuilt = order
-                .map((token) => caseMap.get(token))
-                .filter((part) => typeof part === 'string' && part.length > 0)
-                .join('\n');
-            return rebuilt.length > 0 ? rebuilt : _full;
-        });
-    }
-    transformRenameVars(code) {
-        const declaredSingleLetterVars = new Set();
-        const declarationRegex = /\b(?:var|let|const)\s+([A-Za-z])\b/g;
-        let match;
-        while ((match = declarationRegex.exec(code)) !== null) {
-            const name = match[1];
-            if (name) {
-                declaredSingleLetterVars.add(name);
-            }
-        }
-        if (declaredSingleLetterVars.size === 0) {
-            return code;
-        }
-        const renameMap = new Map();
-        let counter = 1;
-        for (const name of declaredSingleLetterVars) {
-            renameMap.set(name, `var_${counter}`);
-            counter += 1;
-        }
-        return code.replace(/\b([A-Za-z])\b/g, (token, identifier, offset, full) => {
-            const replacement = renameMap.get(identifier);
-            if (!replacement) {
-                return token;
-            }
-            const prev = offset > 0 ? full[offset - 1] : '';
-            if (prev === '.' || prev === "'" || prev === '"' || prev === '`' || prev === '$') {
-                return token;
-            }
-            return replacement;
-        });
-    }
-    buildDiff(original, transformed) {
-        if (original === transformed) {
-            return '';
-        }
-        const oldLines = original.split('\n');
-        const newLines = transformed.split('\n');
-        if (oldLines.length * newLines.length > TransformLimit.MAX_LCS_CELLS) {
-            return this.buildFallbackDiff(oldLines, newLines);
-        }
-        const m = oldLines.length;
-        const n = newLines.length;
-        const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-        for (let i = m - 1; i >= 0; i--) {
-            for (let j = n - 1; j >= 0; j--) {
-                dp[i][j] =
-                    oldLines[i] === newLines[j]
-                        ? dp[i + 1][j + 1] + 1
-                        : Math.max(dp[i + 1][j], dp[i][j + 1]);
-            }
-        }
-        const diffLines = [];
-        let i = 0;
-        let j = 0;
-        while (i < m && j < n) {
-            if (oldLines[i] === newLines[j]) {
-                diffLines.push(` ${oldLines[i]}`);
-                i += 1;
-                j += 1;
-                continue;
-            }
-            if (dp[i + 1][j] >= dp[i][j + 1]) {
-                diffLines.push(`-${oldLines[i]}`);
-                i += 1;
-            }
-            else {
-                diffLines.push(`+${newLines[j]}`);
-                j += 1;
-            }
-        }
-        while (i < m) {
-            diffLines.push(`-${oldLines[i]}`);
-            i += 1;
-        }
-        while (j < n) {
-            diffLines.push(`+${newLines[j]}`);
-            j += 1;
-        }
-        return diffLines.join('\n');
-    }
-    buildFallbackDiff(oldLines, newLines) {
-        let start = 0;
-        while (start < oldLines.length &&
-            start < newLines.length &&
-            oldLines[start] === newLines[start]) {
-            start += 1;
-        }
-        let oldEnd = oldLines.length - 1;
-        let newEnd = newLines.length - 1;
-        while (oldEnd >= start && newEnd >= start && oldLines[oldEnd] === newLines[newEnd]) {
-            oldEnd -= 1;
-            newEnd -= 1;
-        }
-        const removed = oldLines.slice(start, oldEnd + 1).map((line) => `-${line}`);
-        const added = newLines.slice(start, newEnd + 1).map((line) => `+${line}`);
-        return [...removed, ...added].join('\n');
-    }
-}

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

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

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

@@ -1,2 +0,0 @@
-export { transformTools } from '../../domains/transform/definitions.js';
-export { TransformToolHandlers } from '../../domains/transform/handlers.js';

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

@@ -1,2 +0,0 @@
-export { transformTools } from '../../domains/transform/definitions.js';
-export { TransformToolHandlers } from '../../domains/transform/handlers.js';

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

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

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

@@ -1,54 +0,0 @@
-import { bindByDepKey, toolLookup } from '../../domains/shared/registry.js';
-import { transformTools } from '../../domains/transform/definitions.js';
-import { TransformToolHandlers } from '../../domains/transform/index.js';
-import { CodeCollector } from '../../domains/shared/modules.js';
-const DOMAIN = 'transform';
-const DEP_KEY = 'transformHandlers';
-const t = toolLookup(transformTools);
-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.transformHandlers)
-        ctx.transformHandlers = new TransformToolHandlers(ctx.collector);
-    return ctx.transformHandlers;
-}
-const manifest = {
-    kind: 'domain-manifest',
-    version: 1,
-    domain: DOMAIN,
-    depKey: DEP_KEY,
-    profiles: ['workflow', 'full'],
-    ensure,
-    registrations: [
-        {
-            tool: t('ast_transform_preview'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleAstTransformPreview(a)),
-        },
-        {
-            tool: t('ast_transform_chain'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleAstTransformChain(a)),
-        },
-        {
-            tool: t('ast_transform_apply'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleAstTransformApply(a)),
-        },
-        {
-            tool: t('crypto_extract_standalone'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleCryptoExtractStandalone(a)),
-        },
-        {
-            tool: t('crypto_test_harness'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleCryptoTestHarness(a)),
-        },
-        { tool: t('crypto_compare'), domain: DOMAIN, bind: b((h, a) => h.handleCryptoCompare(a)) },
-    ],
-};
-export default manifest;

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

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