@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/server/domains/debugger/definitions.tools.core.js

@@ -1,207 +1,79 @@
+import { tool } from '../../registry/tool-builder.js';
 export const DEBUGGER_CORE_TOOLS = [
-    {
-        name: 'debugger_enable',
-        description: 'Enable the debugger (must be called before setting breakpoints)',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'debugger_disable',
-        description: 'Disable the debugger and clear all breakpoints',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'debugger_pause',
-        description: 'Pause execution at the next statement',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'debugger_resume',
-        description: 'Resume execution (continue)',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'debugger_step_into',
-        description: 'Step into the next function call',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'debugger_step_over',
-        description: 'Step over the next function call',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'debugger_step_out',
-        description: 'Step out of the current function',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'breakpoint_set',
-        description: 'Set a breakpoint at a specific location. Supports URL-based and scriptId-based breakpoints with optional conditions.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: {
-                    type: 'string',
-                    description: 'URL of the script (e.g., "app.js", "https://cdn.example.com/app.js")',
-                },
-                scriptId: {
-                    type: 'string',
-                    description: 'Script ID (alternative to URL, get from get_all_scripts)',
-                },
-                lineNumber: {
-                    type: 'number',
-                    description: 'Line number (0-based)',
-                },
-                columnNumber: {
-                    type: 'number',
-                    description: 'Column number (0-based, optional)',
-                },
-                condition: {
-                    type: 'string',
-                    description: 'Conditional breakpoint expression (e.g., "x > 100")',
-                },
-            },
-            required: ['lineNumber'],
-        },
-    },
-    {
-        name: 'breakpoint_remove',
-        description: 'Remove a breakpoint by its ID',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                breakpointId: {
-                    type: 'string',
-                    description: 'Breakpoint ID (from breakpoint_set or breakpoint_list)',
-                },
-            },
-            required: ['breakpointId'],
-        },
-    },
-    {
-        name: 'breakpoint_list',
-        description: 'List all active breakpoints',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'get_call_stack',
-        description: 'Get the current call stack (only available when paused at a breakpoint)',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'debugger_evaluate',
-        description: 'Evaluate an expression in the context of the current call frame (only when paused)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                expression: {
-                    type: 'string',
-                    description: 'JavaScript expression to evaluate (e.g., "x + y", "user.name")',
-                },
-                callFrameId: {
-                    type: 'string',
-                    description: 'Call frame ID (from get_call_stack, defaults to current frame)',
-                },
-            },
-            required: ['expression'],
-        },
-    },
-    {
-        name: 'debugger_evaluate_global',
-        description: 'Evaluate an expression in the global context (does not require paused state)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                expression: {
-                    type: 'string',
-                    description: 'JavaScript expression to evaluate',
-                },
-            },
-            required: ['expression'],
-        },
-    },
-    {
-        name: 'debugger_wait_for_paused',
-        description: 'Wait for the debugger to pause (useful after setting breakpoints and triggering code)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                timeout: {
-                    type: 'number',
-                    description: 'Timeout in milliseconds (default: 30000)',
-                    default: 30000,
-                },
-            },
-        },
-    },
-    {
-        name: 'debugger_get_paused_state',
-        description: 'Get the current paused state (check if debugger is paused and why)',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'breakpoint_set_on_exception',
-        description: 'Pause on exceptions (all exceptions or only uncaught)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                state: {
-                    type: 'string',
-                    description: 'Exception pause state',
-                    enum: ['none', 'uncaught', 'all'],
-                    default: 'none',
-                },
-            },
-            required: ['state'],
-        },
-    },
-    {
-        name: 'get_object_properties',
-        description: 'Get all properties of an object (when paused, use objectId from variables)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                objectId: {
-                    type: 'string',
-                    description: 'Object ID (from get_scope_variables)',
-                },
-            },
-            required: ['objectId'],
-        },
-    },
-    {
-        name: 'get_scope_variables_enhanced',
-        description: `Enhanced scope variable inspection with deep object traversal.
+    tool('debugger_enable')
+        .desc('Enable the debugger (must be called before setting breakpoints)')
+        .idempotent()
+        .build(),
+    tool('debugger_disable')
+        .desc('Disable the debugger and clear all breakpoints')
+        .destructive()
+        .build(),
+    tool('debugger_pause').desc('Pause execution at the next statement').build(),
+    tool('debugger_resume').desc('Resume execution (continue)').build(),
+    tool('debugger_step_into').desc('Step into the next function call').build(),
+    tool('debugger_step_over').desc('Step over the next function call').build(),
+    tool('debugger_step_out').desc('Step out of the current function').build(),
+    tool('breakpoint_set')
+        .desc('Set a breakpoint at a specific location. Supports URL-based and scriptId-based breakpoints with optional conditions.')
+        .string('url', 'URL of the script (e.g., "app.js", "https://cdn.example.com/app.js")')
+        .string('scriptId', 'Script ID (alternative to URL, get from get_all_scripts)')
+        .number('lineNumber', 'Line number (0-based)')
+        .number('columnNumber', 'Column number (0-based, optional)')
+        .string('condition', 'Conditional breakpoint expression (e.g., "x > 100")')
+        .required('lineNumber')
+        .idempotent()
+        .build(),
+    tool('breakpoint_remove')
+        .desc('Remove a breakpoint by its ID')
+        .string('breakpointId', 'Breakpoint ID (from breakpoint_set or breakpoint_list)')
+        .required('breakpointId')
+        .idempotent()
+        .build(),
+    tool('breakpoint_list').desc('List all active breakpoints').readOnly().idempotent().build(),
+    tool('get_call_stack')
+        .desc('Get the current call stack (only available when paused at a breakpoint)')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('debugger_evaluate')
+        .desc('Evaluate an expression in the context of the current call frame (only when paused)')
+        .string('expression', 'JavaScript expression to evaluate (e.g., "x + y", "user.name")')
+        .string('callFrameId', 'Call frame ID (from get_call_stack, defaults to current frame)')
+        .required('expression')
+        .openWorld()
+        .build(),
+    tool('debugger_evaluate_global')
+        .desc('Evaluate an expression in the global context (does not require paused state)')
+        .string('expression', 'JavaScript expression to evaluate')
+        .required('expression')
+        .openWorld()
+        .build(),
+    tool('debugger_wait_for_paused')
+        .desc('Wait for the debugger to pause (useful after setting breakpoints and triggering code)')
+        .number('timeout', 'Timeout in milliseconds (default: 30000)', { default: 30000 })
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('debugger_get_paused_state')
+        .desc('Get the current paused state (check if debugger is paused and why)')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('breakpoint_set_on_exception')
+        .desc('Pause on exceptions (all exceptions or only uncaught)')
+        .enum('state', ['none', 'uncaught', 'all'], 'Exception pause state', { default: 'none' })
+        .required('state')
+        .idempotent()
+        .build(),
+    tool('get_object_properties')
+        .desc('Get all properties of an object (when paused, use objectId from variables)')
+        .string('objectId', 'Object ID (from get_scope_variables)')
+        .required('objectId')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('get_scope_variables_enhanced')
+        .desc(`Enhanced scope variable inspection with deep object traversal.
 
 Improvements over get_scope_variables:
 1. Graceful error handling for "Could not find object" errors (retries with fallback)
@@ -216,35 +88,20 @@ Use cases:
 
 Examples:
 get_scope_variables_enhanced()
-get_scope_variables_enhanced(callFrameId="xxx", includeObjectProperties=true)`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                callFrameId: {
-                    type: 'string',
-                    description: 'Call frame ID (from get_call_stack, defaults to current frame)',
-                },
-                includeObjectProperties: {
-                    type: 'boolean',
-                    description: 'Expand object properties recursively (default: false)',
-                    default: false,
-                },
-                maxDepth: {
-                    type: 'number',
-                    description: 'Maximum traversal depth for nested objects (default: 1)',
-                    default: 1,
-                },
-                skipErrors: {
-                    type: 'boolean',
-                    description: 'Skip properties that throw errors during access (default: true)',
-                    default: true,
-                },
-            },
-        },
-    },
-    {
-        name: 'debugger_save_session',
-        description: `Save the current debugging session to a JSON file for later restoration.
+get_scope_variables_enhanced(callFrameId="xxx", includeObjectProperties=true)`)
+        .string('callFrameId', 'Call frame ID (from get_call_stack, defaults to current frame)')
+        .boolean('includeObjectProperties', 'Expand object properties recursively (default: false)', {
+        default: false,
+    })
+        .number('maxDepth', 'Maximum traversal depth for nested objects (default: 1)', { default: 1 })
+        .boolean('skipErrors', 'Skip properties that throw errors during access (default: true)', {
+        default: true,
+    })
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('debugger_save_session')
+        .desc(`Save the current debugging session to a JSON file for later restoration.
 
 Captures:
 - All active breakpoints (location, condition, action)
@@ -257,24 +114,13 @@ Saved to:
 
 Examples:
 debugger_save_session()
-debugger_save_session(filePath="my-debug-session.json", metadata={description: "Login flow debugging"})`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                filePath: {
-                    type: 'string',
-                    description: 'Output file path (defaults to ./debugger-sessions/<timestamp>.json)',
-                },
-                metadata: {
-                    type: 'object',
-                    description: 'Optional metadata to attach (e.g., description, tags)',
-                },
-            },
-        },
-    },
-    {
-        name: 'debugger_load_session',
-        description: `Load a previously saved debugging session to restore breakpoints and watches.
+debugger_save_session(filePath="my-debug-session.json", metadata={description: "Login flow debugging"})`)
+        .string('filePath', 'Output file path (defaults to ./debugger-sessions/<timestamp>.json)')
+        .object('metadata', {}, 'Optional metadata to attach (e.g., description, tags)')
+        .idempotent()
+        .build(),
+    tool('debugger_load_session')
+        .desc(`Load a previously saved debugging session to restore breakpoints and watches.
 
 Two input modes:
 1. File path: provide filePath to load from disk
@@ -287,24 +133,13 @@ Restores:
 
 Examples:
 debugger_load_session(filePath="my-debug-session.json")
-debugger_load_session(sessionData="{...}")`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                filePath: {
-                    type: 'string',
-                    description: 'Path to the saved session file',
-                },
-                sessionData: {
-                    type: 'string',
-                    description: 'Session JSON string (alternative to filePath)',
-                },
-            },
-        },
-    },
-    {
-        name: 'debugger_export_session',
-        description: `Export the current debugging session as a JSON string for sharing or backup.
+debugger_load_session(sessionData="{...}")`)
+        .string('filePath', 'Path to the saved session file')
+        .string('sessionData', 'Session JSON string (alternative to filePath)')
+        .idempotent()
+        .build(),
+    tool('debugger_export_session')
+        .desc(`Export the current debugging session as a JSON string for sharing or backup.
 
 Returns session data as JSON, including:
 - Active breakpoints
@@ -313,20 +148,13 @@ Returns session data as JSON, including:
 
 Examples:
 debugger_export_session()
-debugger_export_session(metadata={description: "API debugging session"})`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                metadata: {
-                    type: 'object',
-                    description: 'Optional metadata to include in the export',
-                },
-            },
-        },
-    },
-    {
-        name: 'debugger_list_sessions',
-        description: `List all saved debugging sessions in the ./debugger-sessions/ directory.
+debugger_export_session(metadata={description: "API debugging session"})`)
+        .object('metadata', {}, 'Optional metadata to include in the export')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('debugger_list_sessions')
+        .desc(`List all saved debugging sessions in the ./debugger-sessions/ directory.
 
 Returns for each session:
 - File name and path
@@ -338,10 +166,8 @@ Use cases:
 - Clean up old sessions
 
 Examples:
-debugger_list_sessions()`,
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
+debugger_list_sessions()`)
+        .readOnly()
+        .idempotent()
+        .build(),
 ];

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

@@ -26,8 +26,15 @@ const manifest = {
     profiles: ['workflow', 'full'],
     ensure,
     prerequisites: {
-        debugger_enable: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        breakpoint_set: [{ condition: 'Browser must be launched', fix: 'Call browser_launch and debugger_enable first' }],
+        debugger_enable: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        breakpoint_set: [
+            {
+                condition: 'Browser must be launched',
+                fix: 'Call browser_launch and debugger_enable first',
+            },
+        ],
     },
     registrations: [
         { tool: t('debugger_enable'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerEnable(a)) },

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

@@ -1,155 +1,45 @@
+import { tool } from '../../registry/tool-builder.js';
 export const encodingTools = [
-    {
-        name: 'binary_detect_format',
-        description: 'Detect binary payload format/encoding via magic bytes, encoding heuristics, and Shannon entropy.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                data: {
-                    type: 'string',
-                    description: 'Input payload string. For source=file, this is optional. For source=raw + requestId, this can be omitted.',
-                },
-                source: {
-                    type: 'string',
-                    enum: ['base64', 'hex', 'file', 'raw'],
-                    description: 'How to interpret input payload',
-                },
-                filePath: {
-                    type: 'string',
-                    description: 'File path when source=file (reads first 512 bytes)',
-                },
-                requestId: {
-                    type: 'string',
-                    description: 'Optional captured network requestId to resolve response body from active page context',
-                },
-            },
-            required: ['source'],
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'binary_decode',
-        description: 'Decode binary payloads (base64/hex/url/protobuf/msgpack) into hex, utf8, or json output.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                data: {
-                    type: 'string',
-                    description: 'Input encoded payload',
-                },
-                encoding: {
-                    type: 'string',
-                    enum: ['base64', 'hex', 'url', 'protobuf', 'msgpack'],
-                    description: 'Declared input encoding/format',
-                },
-                outputFormat: {
-                    type: 'string',
-                    enum: ['hex', 'utf8', 'json'],
-                    description: 'Target output format',
-                    default: 'hex',
-                },
-            },
-            required: ['data', 'encoding'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'binary_encode',
-        description: 'Encode utf8/hex/json input into base64/hex/url output.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                data: {
-                    type: 'string',
-                    description: 'Input payload',
-                },
-                inputFormat: {
-                    type: 'string',
-                    enum: ['utf8', 'hex', 'json'],
-                    description: 'How to parse input payload',
-                },
-                outputEncoding: {
-                    type: 'string',
-                    enum: ['base64', 'hex', 'url'],
-                    description: 'Desired output encoding',
-                },
-            },
-            required: ['data', 'inputFormat', 'outputEncoding'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'binary_entropy_analysis',
-        description: 'Compute Shannon entropy + byte frequency distribution to assess plaintext/encoded/compressed/encrypted/random likelihood.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                data: {
-                    type: 'string',
-                    description: 'Input payload string (optional when source=file)',
-                },
-                source: {
-                    type: 'string',
-                    enum: ['base64', 'hex', 'raw', 'file'],
-                    description: 'How to interpret input payload',
-                },
-                filePath: {
-                    type: 'string',
-                    description: 'File path when source=file',
-                },
-                blockSize: {
-                    type: 'number',
-                    description: 'Block size for per-block entropy (default: 256)',
-                    default: 256,
-                },
-            },
-            required: ['source'],
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'protobuf_decode_raw',
-        description: 'Decode base64 protobuf bytes without schema using wire-type aware recursive parser.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                data: {
-                    type: 'string',
-                    description: 'Base64-encoded protobuf payload',
-                },
-                maxDepth: {
-                    type: 'number',
-                    description: 'Maximum recursive decode depth (default: 5)',
-                    default: 5,
-                },
-            },
-            required: ['data'],
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-    },
+    tool('binary_detect_format')
+        .desc('Detect binary payload format/encoding via magic bytes, encoding heuristics, and Shannon entropy')
+        .string('data', 'Input payload')
+        .enum('source', ['base64', 'hex', 'file', 'raw'], 'How to interpret input payload')
+        .string('filePath', 'File path when source=file')
+        .string('requestId', 'Captured network requestId to resolve response body')
+        .required('source')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('binary_decode')
+        .desc('Decode binary payloads into hex, utf8, or json output')
+        .string('data', 'Input encoded payload')
+        .enum('encoding', ['base64', 'hex', 'url', 'protobuf', 'msgpack'], 'Declared input encoding')
+        .enum('outputFormat', ['hex', 'utf8', 'json'], 'Target output format', { default: 'hex' })
+        .required('data', 'encoding')
+        .build(),
+    tool('binary_encode')
+        .desc('Encode utf8/hex/json input into base64/hex/url output')
+        .string('data', 'Input payload')
+        .enum('inputFormat', ['utf8', 'hex', 'json'], 'How to parse input')
+        .enum('outputEncoding', ['base64', 'hex', 'url'], 'Desired output encoding')
+        .required('data', 'inputFormat', 'outputEncoding')
+        .build(),
+    tool('binary_entropy_analysis')
+        .desc('Compute Shannon entropy + byte frequency to assess plaintext/encoded/compressed/encrypted likelihood')
+        .string('data', 'Input payload')
+        .enum('source', ['base64', 'hex', 'raw', 'file'], 'How to interpret input payload')
+        .string('filePath', 'File path when source=file')
+        .number('blockSize', 'Block size for per-block entropy', { default: 256 })
+        .required('source')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('protobuf_decode_raw')
+        .desc('Decode base64 protobuf bytes without schema using wire-type aware recursive parser')
+        .string('data', 'Base64-encoded protobuf payload')
+        .number('maxDepth', 'Maximum recursive decode depth', { default: 5 })
+        .required('data')
+        .readOnly()
+        .idempotent()
+        .build(),
 ];