@jshookmcp/jshook 0.2.3 → 0.2.5

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

@@ -1,79 +1,79 @@
 export { GRAPHQL_MAX_PREVIEW_CHARS, GRAPHQL_MAX_SCHEMA_CHARS, GRAPHQL_MAX_QUERY_CHARS, GRAPHQL_MAX_GRAPH_NODES, GRAPHQL_MAX_GRAPH_EDGES, } from '../../../constants.js';
-export const INTROSPECTION_QUERY = `
-query IntrospectionQuery {
-  __schema {
-    queryType { name }
-    mutationType { name }
-    subscriptionType { name }
-    types { ...FullType }
-    directives {
-      name
-      description
-      locations
-      args(includeDeprecated: true) { ...InputValue }
-    }
-  }
-}
-fragment FullType on __Type {
-  kind
-  name
-  description
-  fields(includeDeprecated: true) {
-    name
-    description
-    args(includeDeprecated: true) { ...InputValue }
-    type { ...TypeRef }
-    isDeprecated
-    deprecationReason
-  }
-  inputFields(includeDeprecated: true) { ...InputValue }
-  interfaces { ...TypeRef }
-  enumValues(includeDeprecated: true) {
-    name
-    description
-    isDeprecated
-    deprecationReason
-  }
-  possibleTypes { ...TypeRef }
-}
-fragment InputValue on __InputValue {
-  name
-  description
-  type { ...TypeRef }
-  defaultValue
-  isDeprecated
-  deprecationReason
-}
-fragment TypeRef on __Type {
-  kind
-  name
-  ofType {
-    kind
-    name
-    ofType {
-      kind
-      name
-      ofType {
-        kind
-        name
-        ofType {
-          kind
-          name
-          ofType {
-            kind
-            name
-            ofType {
-              kind
-              name
-              ofType {
-                kind
-                name
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
+export const INTROSPECTION_QUERY = `
+query IntrospectionQuery {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types { ...FullType }
+    directives {
+      name
+      description
+      locations
+      args(includeDeprecated: true) { ...InputValue }
+    }
+  }
+}
+fragment FullType on __Type {
+  kind
+  name
+  description
+  fields(includeDeprecated: true) {
+    name
+    description
+    args(includeDeprecated: true) { ...InputValue }
+    type { ...TypeRef }
+    isDeprecated
+    deprecationReason
+  }
+  inputFields(includeDeprecated: true) { ...InputValue }
+  interfaces { ...TypeRef }
+  enumValues(includeDeprecated: true) {
+    name
+    description
+    isDeprecated
+    deprecationReason
+  }
+  possibleTypes { ...TypeRef }
+}
+fragment InputValue on __InputValue {
+  name
+  description
+  type { ...TypeRef }
+  defaultValue
+  isDeprecated
+  deprecationReason
+}
+fragment TypeRef on __Type {
+  kind
+  name
+  ofType {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
 `.trim();

package/dist/src/server/domains/hooks/ai-handlers.d.ts

@@ -1,15 +1,8 @@
 import type { PageController } from '../../domains/shared/modules.js';
 export declare class AIHookToolHandlers {
     private pageController;
-    private hookGenerator;
     private injectedHooks;
     constructor(pageController: PageController);
-    handleAIHookGenerate(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
     handleAIHookInject(args: Record<string, unknown>): Promise<{
         content: {
             type: string;

package/dist/src/server/domains/hooks/ai-handlers.js

@@ -1,77 +1,11 @@
-import { AIHookGenerator } from '../../domains/shared/modules.js';
-import { evaluateWithTimeout, evaluateOnNewDocumentWithTimeout } from '../../../modules/collector/PageController.js';
+import { evaluateWithTimeout, evaluateOnNewDocumentWithTimeout, } from '../../../modules/collector/PageController.js';
 import { logger } from '../../../utils/logger.js';
 import { argString, argStringRequired, argBool } from '../../domains/shared/parse-args.js';
 export class AIHookToolHandlers {
     pageController;
-    hookGenerator;
     injectedHooks = new Map();
     constructor(pageController) {
         this.pageController = pageController;
-        this.hookGenerator = new AIHookGenerator();
-    }
-    async handleAIHookGenerate(args) {
-        try {
-            let target;
-            if (args.target) {
-                target = args.target;
-            }
-            else {
-                const pattern = argString(args, 'pattern', '');
-                let targetType = 'function';
-                let targetName = pattern;
-                if (pattern === 'fetch' || pattern === 'XMLHttpRequest') {
-                    targetType = 'api';
-                }
-                else if (pattern.includes('.')) {
-                    targetType = 'object-method';
-                    targetName = pattern.split('.').pop() || pattern;
-                }
-                target = { type: targetType, name: targetName };
-            }
-            const request = {
-                description: argString(args, 'description') || `Hook ${target.name || 'target'}`,
-                target,
-                behavior: args.behavior || {
-                    captureArgs: true,
-                    captureReturn: true,
-                    logToConsole: true,
-                },
-                condition: args.condition,
-                customCode: args.customCode,
-            };
-            const response = this.hookGenerator.generateHook(request);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: response.success,
-                            hookId: response.hookId,
-                            generatedCode: response.generatedCode,
-                            explanation: response.explanation,
-                            injectionMethod: response.injectionMethod,
-                            warnings: response.warnings,
-                            usage: ` ai_hook_inject(hookId: "${response.hookId}") Hook`,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('AI Hook generation failed', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
     }
     async handleAIHookInject(args) {
         try {

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

@@ -1,343 +1,77 @@
+import { tool } from '../../registry/tool-builder.js';
 export const aiHookTools = [
-    {
-        name: 'ai_hook_generate',
-        description: 'Generate hook code for a target function, API, or object method.\n\nHook types:\n- function: Hook a named global function (e.g. window.btoa)\n- object-method: Hook a method on an object (e.g. crypto.subtle.encrypt)\n- api: Hook a built-in API (e.g. fetch, XMLHttpRequest)\n- property: Hook a property getter/setter\n- event: Hook an event listener\n- custom: Provide custom hook code\n\nAfter generating, inject the hook with ai_hook_inject.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                description: {
-                    type: 'string',
-                    description: 'What the hook should do (e.g., "Capture all fetch requests to /api")',
-                },
-                target: {
-                    type: 'object',
-                    description: 'Hook target specification',
-                    properties: {
-                        type: {
-                            type: 'string',
-                            enum: ['function', 'object-method', 'api', 'property', 'event', 'custom'],
-                            description: 'Hook type',
-                        },
-                        name: {
-                            type: 'string',
-                            description: 'Function or API name (e.g., "btoa", "fetch")',
-                        },
-                        pattern: {
-                            type: 'string',
-                            description: 'Pattern for matching (used with api type)',
-                        },
-                        object: {
-                            type: 'string',
-                            description: 'Object path (e.g., "window.crypto.subtle")',
-                        },
-                        property: {
-                            type: 'string',
-                            description: 'Property name to hook',
-                        },
-                    },
-                    required: ['type'],
-                },
-                behavior: {
-                    type: 'object',
-                    description: 'Hook behavior configuration',
-                    properties: {
-                        captureArgs: {
-                            type: 'boolean',
-                            description: 'Capture function arguments',
-                            default: true,
-                        },
-                        captureReturn: {
-                            type: 'boolean',
-                            description: 'Capture return value',
-                            default: true,
-                        },
-                        captureStack: {
-                            type: 'boolean',
-                            description: 'Capture call stack',
-                            default: false,
-                        },
-                        modifyArgs: {
-                            type: 'boolean',
-                            description: 'Allow argument modification',
-                            default: false,
-                        },
-                        modifyReturn: {
-                            type: 'boolean',
-                            description: 'Allow return value modification',
-                            default: false,
-                        },
-                        blockExecution: {
-                            type: 'boolean',
-                            description: 'Block the original function from executing',
-                            default: false,
-                        },
-                        logToConsole: {
-                            type: 'boolean',
-                            description: 'Log hook events to console',
-                            default: true,
-                        },
-                    },
-                },
-                condition: {
-                    type: 'object',
-                    description: 'Conditional trigger for the hook',
-                    properties: {
-                        argFilter: {
-                            type: 'string',
-                            description: 'JS expression to filter by args (e.g., "args[0].includes(\'password\')")',
-                        },
-                        returnFilter: {
-                            type: 'string',
-                            description: 'JS expression to filter by return value',
-                        },
-                        urlPattern: {
-                            type: 'string',
-                            description: 'Regex pattern to match request URL',
-                        },
-                        maxCalls: {
-                            type: 'number',
-                            description: 'Stop capturing after this many calls',
-                        },
-                    },
-                },
-                customCode: {
-                    type: 'object',
-                    description: 'Custom code to inject at hook points',
-                    properties: {
-                        before: {
-                            type: 'string',
-                            description: 'Code to run before the original function',
-                        },
-                        after: {
-                            type: 'string',
-                            description: 'Code to run after the original function',
-                        },
-                        replace: {
-                            type: 'string',
-                            description: 'Code to replace the original function entirely',
-                        },
-                    },
-                },
-            },
-            required: ['description', 'target', 'behavior'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ai_hook_inject',
-        description: 'Inject a generated hook into the page.\n\nMethods:\n- evaluateOnNewDocument: Runs before page scripts (use for API hooks like fetch/XHR)\n- evaluate: Runs in current page context (use for hooking already-loaded code)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                hookId: {
-                    type: 'string',
-                    description: 'Hook ID returned by ai_hook_generate',
-                },
-                code: {
-                    type: 'string',
-                    description: 'Hook code returned by ai_hook_generate',
-                },
-                method: {
-                    type: 'string',
-                    enum: ['evaluateOnNewDocument', 'evaluate'],
-                    description: 'Injection method',
-                    default: 'evaluate',
-                },
-            },
-            required: ['hookId', 'code'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ai_hook_get_data',
-        description: 'Retrieve captured data from an active hook (arguments, return values, timestamps, call count)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                hookId: {
-                    type: 'string',
-                    description: 'Hook ID',
-                },
-            },
-            required: ['hookId'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ai_hook_list',
-        description: 'List all active hooks with their IDs, types, creation time, and call counts',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ai_hook_clear',
-        description: 'Remove one hook by ID or clear all hooks and their captured data',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                hookId: {
-                    type: 'string',
-                    description: 'Hook ID to clear (omit to clear all hooks)',
-                },
-            },
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ai_hook_toggle',
-        description: 'Enable or disable a hook without removing it',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                hookId: {
-                    type: 'string',
-                    description: 'Hook ID',
-                },
-                enabled: {
-                    type: 'boolean',
-                    description: 'true to enable, false to disable',
-                },
+    tool('ai_hook_inject')
+        .desc('Inject a generated hook into the page.\n\nMethods:\n- evaluateOnNewDocument: Runs before page scripts (use for API hooks like fetch/XHR)\n- evaluate: Runs in current page context (use for hooking already-loaded code)')
+        .string('hookId', 'Hook ID for injection')
+        .string('code', 'Hook code to inject')
+        .enum('method', ['evaluateOnNewDocument', 'evaluate'], 'Injection method', {
+        default: 'evaluate',
+    })
+        .required('hookId', 'code')
+        .build(),
+    tool('ai_hook_get_data')
+        .desc('Retrieve captured data from an active hook (arguments, return values, timestamps, call count)')
+        .string('hookId', 'Hook ID')
+        .required('hookId')
+        .build(),
+    tool('ai_hook_list')
+        .desc('List all active hooks with their IDs, types, creation time, and call counts')
+        .build(),
+    tool('ai_hook_clear')
+        .desc('Remove one hook by ID or clear all hooks and their captured data')
+        .string('hookId', 'Hook ID to clear (omit to clear all hooks)')
+        .build(),
+    tool('ai_hook_toggle')
+        .desc('Enable or disable a hook without removing it')
+        .string('hookId', 'Hook ID')
+        .boolean('enabled', 'true to enable, false to disable')
+        .required('hookId', 'enabled')
+        .build(),
+    tool('ai_hook_export')
+        .desc('Export captured hook data in JSON or CSV format')
+        .string('hookId', 'Hook ID to export (omit to export all hooks)')
+        .enum('format', ['json', 'csv'], 'Export format', { default: 'json' })
+        .build(),
+];
+export const hookPresetTools = [
+    tool('hook_preset')
+        .desc('Install a pre-built JavaScript hook from 20+ built-in presets (eval, atob/btoa, Proxy, Reflect, Object.defineProperty, etc.), or provide customTemplate/customTemplates to install your own reusable hook bodies. Use listPresets=true to see all available preset descriptions.')
+        .string('preset', 'Single preset name to install. Accepts built-in preset ids or ids provided by customTemplate/customTemplates.')
+        .array('presets', { type: 'string' }, 'List of preset names to install simultaneously. Accepts built-in ids and custom template ids.')
+        .prop('customTemplate', {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Stable preset id, for example deobfuscation-sinks' },
+            description: {
+                type: 'string',
+                description: 'Human-readable description for listPresets output.',
             },
-            required: ['hookId', 'enabled'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ai_hook_export',
-        description: 'Export captured hook data in JSON or CSV format',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                hookId: {
-                    type: 'string',
-                    description: 'Hook ID to export (omit to export all hooks)',
-                },
-                format: {
-                    type: 'string',
-                    enum: ['json', 'csv'],
-                    description: 'Export format',
-                    default: 'json',
-                },
+            body: {
+                type: 'string',
+                description: 'Hook body snippet inserted into the preset wrapper.',
             },
         },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-];
-export const hookPresetTools = [
-    {
-        name: 'hook_preset',
-        description: 'Install a pre-built JavaScript hook from 20+ built-in presets (eval, atob/btoa, Proxy, Reflect, Object.defineProperty, etc.), or provide customTemplate/customTemplates to install your own reusable hook bodies. Use listPresets=true to see all available preset descriptions.',
-        inputSchema: {
+        required: ['id', 'body'],
+        description: 'Inline custom template. body should contain the hook body inserted into the standard buildHookCode wrapper. Use {{STACK_CODE}} and {{LOG_FN}} placeholders when needed.',
+    })
+        .prop('customTemplates', {
+        type: 'array',
+        items: {
             type: 'object',
             properties: {
-                preset: {
-                    type: 'string',
-                    description: 'Single preset name to install. Accepts built-in preset ids or ids provided by customTemplate/customTemplates.',
-                },
-                presets: {
-                    type: 'array',
-                    description: 'List of preset names to install simultaneously. Accepts built-in ids and custom template ids.',
-                    items: { type: 'string' },
-                },
-                customTemplate: {
-                    type: 'object',
-                    description: 'Inline custom template. body should contain the hook body inserted into the standard buildHookCode wrapper. Use {{STACK_CODE}} and {{LOG_FN}} placeholders when needed.',
-                    properties: {
-                        id: {
-                            type: 'string',
-                            description: 'Stable preset id, for example deobfuscation-sinks',
-                        },
-                        description: {
-                            type: 'string',
-                            description: 'Human-readable description for listPresets output.',
-                        },
-                        body: {
-                            type: 'string',
-                            description: 'Hook body snippet inserted into the preset wrapper.',
-                        },
-                    },
-                    required: ['id', 'body'],
-                },
-                customTemplates: {
-                    type: 'array',
-                    description: 'List of inline custom templates to register for this invocation.',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            id: { type: 'string' },
-                            description: { type: 'string' },
-                            body: { type: 'string' },
-                        },
-                        required: ['id', 'body'],
-                    },
-                },
-                captureStack: {
-                    type: 'boolean',
-                    description: 'Include call stack in captured data (default: false, has performance impact).',
-                    default: false,
-                },
-                logToConsole: {
-                    type: 'boolean',
-                    description: 'Log hook events to browser console (default: true).',
-                    default: true,
-                },
-                method: {
-                    type: 'string',
-                    enum: ['evaluate', 'evaluateOnNewDocument'],
-                    description: 'Injection method: evaluate=current page, evaluateOnNewDocument=before page scripts (default: evaluate).',
-                    default: 'evaluate',
-                },
-                listPresets: {
-                    type: 'boolean',
-                    description: 'Set to true to list all available presets with descriptions instead of installing.',
-                    default: false,
-                },
+                id: { type: 'string' },
+                description: { type: 'string' },
+                body: { type: 'string' },
             },
-            required: [],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
+            required: ['id', 'body'],
+        },
+        description: 'List of inline custom templates to register for this invocation.',
+    })
+        .boolean('captureStack', 'Include call stack in captured data (has performance impact)', {
+        default: false,
+    })
+        .boolean('logToConsole', 'Log hook events to browser console', { default: true })
+        .enum('method', ['evaluate', 'evaluateOnNewDocument'], 'Injection method: evaluate=current page, evaluateOnNewDocument=before page scripts', { default: 'evaluate' })
+        .boolean('listPresets', 'Set to true to list all available presets with descriptions instead of installing.', { default: false })
+        .build(),
 ];

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

@@ -9,7 +9,7 @@ declare const manifest: {
     domain: "hooks";
     depKey: "aiHookHandlers";
     secondaryDepKeys: string[];
-    profiles: "full"[];
+    profiles: ("workflow" | "full")[];
     ensure: typeof ensure;
     registrations: {
         tool: {