@jshookmcp/jshook 0.2.2 → 0.2.5

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

@@ -1,212 +1,52 @@
+import { tool } from '../../registry/tool-builder.js';
+const transformsEnum = [
+    'constant_fold',
+    'string_decrypt',
+    'dead_code_remove',
+    'control_flow_flatten',
+    'rename_vars',
+];
 export const transformTools = [
-    {
-        name: 'ast_transform_preview',
-        description: 'Preview lightweight AST-like transforms (string/regex based) and return before/after diff.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                code: {
-                    type: 'string',
-                    description: 'Source code to transform.',
-                },
-                transforms: {
-                    type: 'array',
-                    description: 'Ordered transform list.',
-                    items: {
-                        type: 'string',
-                        enum: [
-                            'constant_fold',
-                            'string_decrypt',
-                            'dead_code_remove',
-                            'control_flow_flatten',
-                            'rename_vars',
-                        ],
-                    },
-                },
-                preview: {
-                    type: 'boolean',
-                    description: 'Whether to generate line diff output.',
-                    default: true,
-                },
-            },
-            required: ['code', 'transforms'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ast_transform_chain',
-        description: 'Create and store an in-memory transform chain.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'Chain name.',
-                },
-                transforms: {
-                    type: 'array',
-                    description: 'Ordered transform list.',
-                    items: {
-                        type: 'string',
-                        enum: [
-                            'constant_fold',
-                            'string_decrypt',
-                            'dead_code_remove',
-                            'control_flow_flatten',
-                            'rename_vars',
-                        ],
-                    },
-                },
-                description: {
-                    type: 'string',
-                    description: 'Optional chain description.',
-                },
-            },
-            required: ['name', 'transforms'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ast_transform_apply',
-        description: 'Apply transforms to input code or a live page scriptId.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                scriptId: {
-                    type: 'string',
-                    description: 'Target script ID from page debugger context.',
-                },
-                code: {
-                    type: 'string',
-                    description: 'Direct source code input.',
-                },
-                chainName: {
-                    type: 'string',
-                    description: 'Use a saved transform chain by name.',
-                },
-                transforms: {
-                    type: 'array',
-                    description: 'Direct transform list (used when chainName is not provided).',
-                    items: {
-                        type: 'string',
-                        enum: [
-                            'constant_fold',
-                            'string_decrypt',
-                            'dead_code_remove',
-                            'control_flow_flatten',
-                            'rename_vars',
-                        ],
-                    },
-                },
-            },
-            required: [],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'crypto_extract_standalone',
-        description: 'Extract crypto/sign/encrypt function from current page and generate standalone runnable code.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetFunction: {
-                    type: 'string',
-                    description: 'Target function name/path, e.g. "window.sign".',
-                },
-                includePolyfills: {
-                    type: 'boolean',
-                    description: 'Include minimal runtime polyfills.',
-                    default: true,
-                },
-            },
-            required: ['targetFunction'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'crypto_test_harness',
-        description: 'Run extracted crypto code in worker_threads + vm sandbox and return deterministic test results.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                code: {
-                    type: 'string',
-                    description: 'Standalone function code.',
-                },
-                functionName: {
-                    type: 'string',
-                    description: 'Exported function name to execute.',
-                },
-                testInputs: {
-                    type: 'array',
-                    description: 'Input list for test execution.',
-                    items: {
-                        type: 'string',
-                    },
-                },
-            },
-            required: ['code', 'functionName', 'testInputs'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'crypto_compare',
-        description: 'Compare two crypto implementations against identical test vectors.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                code1: {
-                    type: 'string',
-                    description: 'Implementation A code.',
-                },
-                code2: {
-                    type: 'string',
-                    description: 'Implementation B code.',
-                },
-                functionName: {
-                    type: 'string',
-                    description: 'Function name shared by both implementations.',
-                },
-                testInputs: {
-                    type: 'array',
-                    description: 'Input list for comparison.',
-                    items: {
-                        type: 'string',
-                    },
-                },
-            },
-            required: ['code1', 'code2', 'functionName', 'testInputs'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
+    tool('ast_transform_preview')
+        .desc('Preview lightweight AST-like transforms (string/regex based) and return before/after diff.')
+        .string('code', 'Source code to transform.')
+        .array('transforms', { type: 'string', enum: transformsEnum }, 'Ordered transform list.')
+        .boolean('preview', 'Whether to generate line diff output.', { default: true })
+        .required('code', 'transforms')
+        .build(),
+    tool('ast_transform_chain')
+        .desc('Create and store an in-memory transform chain.')
+        .string('name', 'Chain name.')
+        .array('transforms', { type: 'string', enum: transformsEnum }, 'Ordered transform list.')
+        .string('description', 'Optional chain description.')
+        .required('name', 'transforms')
+        .build(),
+    tool('ast_transform_apply')
+        .desc('Apply transforms to input code or a live page scriptId.')
+        .string('scriptId', 'Target script ID from page debugger context.')
+        .string('code', 'Direct source code input.')
+        .string('chainName', 'Use a saved transform chain by name.')
+        .array('transforms', { type: 'string', enum: transformsEnum }, 'Direct transform list (used when chainName is not provided).')
+        .build(),
+    tool('crypto_extract_standalone')
+        .desc('Extract crypto/sign/encrypt function from current page and generate standalone runnable code.')
+        .string('targetFunction', 'Target function name/path, e.g. "window.sign".')
+        .boolean('includePolyfills', 'Include minimal runtime polyfills.', { default: true })
+        .required('targetFunction')
+        .build(),
+    tool('crypto_test_harness')
+        .desc('Run extracted crypto code in worker_threads + vm sandbox and return deterministic test results.')
+        .string('code', 'Standalone function code.')
+        .string('functionName', 'Exported function name to execute.')
+        .array('testInputs', { type: 'string' }, 'Input list for test execution.')
+        .required('code', 'functionName', 'testInputs')
+        .build(),
+    tool('crypto_compare')
+        .desc('Compare two crypto implementations against identical test vectors.')
+        .string('code1', 'Implementation A code.')
+        .string('code2', 'Implementation B code.')
+        .string('functionName', 'Function name shared by both implementations.')
+        .array('testInputs', { type: 'string' }, 'Input list for comparison.')
+        .required('code1', 'code2', 'functionName', 'testInputs')
+        .build(),
 ];

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

@@ -1,6 +1,11 @@
 import { ScriptManager } from '../../domains/shared/modules.js';
 import { WorkerPool } from '../../../utils/WorkerPool.js';
 import { TRANSFORM_WORKER_TIMEOUT_MS, TRANSFORM_CRYPTO_POOL_MAX_WORKERS, TRANSFORM_CRYPTO_POOL_IDLE_TIMEOUT_MS, TRANSFORM_CRYPTO_POOL_MAX_OLD_GEN_MB, TRANSFORM_CRYPTO_POOL_MAX_YOUNG_GEN_MB, } from '../../../constants.js';
+function extractLastSegment(value) {
+    const normalized = value.startsWith('window.') ? value.slice(7) : value;
+    const parts = normalized.split('.').filter(Boolean);
+    return parts.length > 0 ? parts[parts.length - 1] : '';
+}
 const SUPPORTED_TRANSFORMS = [
     'constant_fold',
     'string_decrypt',
@@ -279,7 +284,7 @@ export class TransformToolHandlersBase {
                 }
             }
             for (const script of scripts) {
-                if (script.id === id || (script.dataset && script.dataset.scriptId === id)) {
+                if (script.id === id || script.dataset?.scriptId === id) {
                     if (script.textContent && script.textContent.trim().length > 0) {
                         return script.textContent;
                     }
@@ -313,11 +318,6 @@ export class TransformToolHandlersBase {
         throw new Error(`Unable to resolve source from scriptId: ${scriptId}`);
     }
     resolveFunctionName(targetFunction, targetPath, source) {
-        const extractLastSegment = (value) => {
-            const normalized = value.startsWith('window.') ? value.slice(7) : value;
-            const parts = normalized.split('.').filter(Boolean);
-            return parts.length > 0 ? parts[parts.length - 1] : '';
-        };
         const candidateFromTarget = extractLastSegment(targetFunction);
         if (this.isValidIdentifier(candidateFromTarget)) {
             return candidateFromTarget;

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

@@ -11,24 +11,6 @@ export class TransformToolHandlersCrypto extends TransformToolHandlersOps {
                 const keywordList = Array.isArray(keywords) ? keywords : [];
                 const lowerKeywords = keywordList.map((item) => String(item).toLowerCase());
                 const globalObj = window;
-                const resolvePath = (path) => {
-                    const normalized = path.startsWith('window.') ? path.slice(7) : path;
-                    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;
-                };
                 const scoreFunction = (path, source) => {
                     const text = (path + '\\n' + source).toLowerCase();
                     let score = 0;
@@ -56,7 +38,24 @@ export class TransformToolHandlersCrypto extends TransformToolHandlersOps {
                     });
                 };
                 if (target.length > 0) {
-                    const resolved = resolvePath(target);
+                    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);

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

@@ -7,7 +7,7 @@ declare const manifest: {
     version: 1;
     domain: "transform";
     depKey: "transformHandlers";
-    profiles: "full"[];
+    profiles: ("workflow" | "full")[];
     ensure: typeof ensure;
     registrations: {
         tool: {

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

@@ -20,7 +20,7 @@ const manifest = {
     version: 1,
     domain: DOMAIN,
     depKey: DEP_KEY,
-    profiles: ['full'],
+    profiles: ['workflow', 'full'],
     ensure,
     registrations: [
         {