@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/server/domains/browser/definitions.tools.page-core.js

@@ -1,7 +1,7 @@
+import { tool } from '../../registry/tool-builder.js';
 export const browserPageCoreTools = [
-    {
-        name: 'page_navigate',
-        description: `Navigate to a URL
+    tool('page_navigate')
+        .desc(`Navigate to a URL
 
 Features:
 - Automatic CAPTCHA detection
@@ -14,102 +14,39 @@ If you want to capture network requests, you have two options:
 2. Set enableNetworkMonitoring=true in page_navigate (convenient for quick capture)
 
 Example with network monitoring:
-page_navigate(url="https:
+page_navigate(url="https:")
 -> Network monitoring auto-enabled
 -> Page loads
--> Use network_get_requests to see captured requests`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: {
-                    type: 'string',
-                    description: 'Target URL to navigate to',
-                },
-                waitUntil: {
-                    type: 'string',
-                    description: 'When to consider navigation succeeded',
-                    enum: ['load', 'domcontentloaded', 'networkidle', 'commit'],
-                    default: 'networkidle',
-                },
-                timeout: {
-                    type: 'number',
-                    description: 'Navigation timeout in milliseconds',
-                    default: 30000,
-                },
-                enableNetworkMonitoring: {
-                    type: 'boolean',
-                    description: ' Auto-enable network monitoring before navigation to capture all requests. If already enabled, this has no effect.',
-                    default: false,
-                },
-            },
-            required: ['url'],
-        },
-    },
-    {
-        name: 'page_reload',
-        description: 'Reload current page',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'page_back',
-        description: 'Navigate back in history',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'page_forward',
-        description: 'Navigate forward in history',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'dom_query_selector',
-        description: 'Query single element (like document.querySelector). AI should use this BEFORE clicking to verify element exists.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: {
-                    type: 'string',
-                    description: 'CSS selector',
-                },
-                getAttributes: {
-                    type: 'boolean',
-                    description: 'Whether to get element attributes',
-                    default: true,
-                },
-            },
-            required: ['selector'],
-        },
-    },
-    {
-        name: 'dom_query_all',
-        description: 'Query all matching elements (like document.querySelectorAll)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: {
-                    type: 'string',
-                    description: 'CSS selector',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum number of elements to return',
-                    default: 100,
-                },
-            },
-            required: ['selector'],
-        },
-    },
-    {
-        name: 'dom_get_structure',
-        description: `Get page DOM structure (for AI to understand page layout).
+-> Use network_get_requests to see captured requests`)
+        .string('url', 'Target URL to navigate to')
+        .enum('waitUntil', ['load', 'domcontentloaded', 'networkidle', 'commit'], 'When to consider navigation succeeded', { default: 'networkidle' })
+        .number('timeout', 'Navigation timeout in milliseconds', { default: 30000 })
+        .boolean('enableNetworkMonitoring', 'Auto-enable network monitoring before navigation to capture all requests. If already enabled, this has no effect.', { default: false })
+        .required('url')
+        .idempotent()
+        .openWorld()
+        .build(),
+    tool('page_reload').desc('Reload current page').idempotent().openWorld().build(),
+    tool('page_back').desc('Navigate back in history').openWorld().build(),
+    tool('page_forward').desc('Navigate forward in history').openWorld().build(),
+    tool('dom_query_selector')
+        .desc('Query single element (like document.querySelector). AI should use this BEFORE clicking to verify element exists.')
+        .string('selector', 'CSS selector')
+        .boolean('getAttributes', 'Whether to get element attributes', { default: true })
+        .required('selector')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('dom_query_all')
+        .desc('Query all matching elements (like document.querySelectorAll)')
+        .string('selector', 'CSS selector')
+        .number('limit', 'Maximum number of elements to return', { default: 100 })
+        .required('selector')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('dom_get_structure')
+        .desc(`Get page DOM structure (for AI to understand page layout).
 
 IMPORTANT: Large DOM structures (>50KB) automatically return summary + detailId.
 
@@ -120,163 +57,72 @@ Best Practices:
 
 Example:
 dom_get_structure(maxDepth=2, includeText=false)
--> Returns compact structure without text content`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                maxDepth: {
-                    type: 'number',
-                    description: 'Maximum depth of DOM tree (default: 3, recommend: 2 for large pages)',
-                    default: 3,
-                },
-                includeText: {
-                    type: 'boolean',
-                    description: 'Whether to include text content (set false to reduce size)',
-                    default: true,
-                },
-            },
-        },
-    },
-    {
-        name: 'dom_find_clickable',
-        description: 'Find all clickable elements (buttons, links). Use this to discover what can be clicked.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                filterText: {
-                    type: 'string',
-                    description: 'Filter by text content (optional)',
-                },
-            },
-        },
-    },
-    {
-        name: 'page_click',
-        description: 'Click an element. Use dom_query_selector FIRST to verify element exists.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: {
-                    type: 'string',
-                    description: 'CSS selector of element to click',
-                },
-                button: {
-                    type: 'string',
-                    description: 'Mouse button to click',
-                    enum: ['left', 'right', 'middle'],
-                    default: 'left',
-                },
-                clickCount: {
-                    oneOf: [{ type: 'number' }, { type: 'string' }],
-                    description: 'Number of clicks (numeric string is accepted and auto-normalized)',
-                    default: 1,
-                },
-                delay: {
-                    oneOf: [{ type: 'number' }, { type: 'string' }],
-                    description: 'Delay between mousedown and mouseup in milliseconds (numeric string is accepted)',
-                },
-            },
-            required: ['selector'],
-        },
-    },
-    {
-        name: 'page_type',
-        description: 'Type text into an input element',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: {
-                    type: 'string',
-                    description: 'CSS selector of input element',
-                },
-                text: {
-                    type: 'string',
-                    description: 'Text to type',
-                },
-                delay: {
-                    type: 'number',
-                    description: 'Delay between key presses in milliseconds',
-                },
-            },
-            required: ['selector', 'text'],
-        },
-    },
-    {
-        name: 'page_select',
-        description: 'Select option(s) in a <select> element',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: {
-                    type: 'string',
-                    description: 'CSS selector of select element',
-                },
-                values: {
-                    type: 'array',
-                    description: 'Values to select',
-                    items: {
-                        type: 'string',
-                    },
-                },
-            },
-            required: ['selector', 'values'],
-        },
-    },
-    {
-        name: 'page_hover',
-        description: 'Hover over an element',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: {
-                    type: 'string',
-                    description: 'CSS selector of element to hover',
-                },
-            },
-            required: ['selector'],
-        },
-    },
-    {
-        name: 'page_scroll',
-        description: 'Scroll the page',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                x: {
-                    type: 'number',
-                    description: 'Horizontal scroll position',
-                    default: 0,
-                },
-                y: {
-                    type: 'number',
-                    description: 'Vertical scroll position',
-                    default: 0,
-                },
-            },
-        },
-    },
-    {
-        name: 'page_wait_for_selector',
-        description: 'Wait for an element to appear',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: {
-                    type: 'string',
-                    description: 'CSS selector to wait for',
-                },
-                timeout: {
-                    type: 'number',
-                    description: 'Timeout in milliseconds',
-                    default: 30000,
-                },
-            },
-            required: ['selector'],
-        },
-    },
-    {
-        name: 'page_evaluate',
-        description: `Execute JavaScript code in page context and get result.
+-> Returns compact structure without text content`)
+        .number('maxDepth', 'Maximum depth of DOM tree (default: 3, recommend: 2 for large pages)', {
+        default: 3,
+    })
+        .boolean('includeText', 'Whether to include text content (set false to reduce size)', {
+        default: true,
+    })
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('dom_find_clickable')
+        .desc('Find all clickable elements (buttons, links). Use this to discover what can be clicked.')
+        .string('filterText', 'Filter by text content (optional)')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('page_click')
+        .desc('Click an element. Use dom_query_selector FIRST to verify element exists.')
+        .string('selector', 'CSS selector of element to click')
+        .enum('button', ['left', 'right', 'middle'], 'Mouse button to click', { default: 'left' })
+        .number('clickCount', 'Number of clicks (numeric string is accepted and auto-normalized)', {
+        default: 1,
+    })
+        .number('delay', 'Delay between mousedown and mouseup in milliseconds (numeric string is accepted)')
+        .required('selector')
+        .openWorld()
+        .build(),
+    tool('page_type')
+        .desc('Type text into an input element')
+        .string('selector', 'CSS selector of input element')
+        .string('text', 'Text to type')
+        .number('delay', 'Delay between key presses in milliseconds')
+        .required('selector', 'text')
+        .openWorld()
+        .build(),
+    tool('page_select')
+        .desc('Select option(s) in a <select> element')
+        .string('selector', 'CSS selector of select element')
+        .array('values', { type: 'string' }, 'Values to select')
+        .required('selector', 'values')
+        .idempotent()
+        .openWorld()
+        .build(),
+    tool('page_hover')
+        .desc('Hover over an element')
+        .string('selector', 'CSS selector of element to hover')
+        .required('selector')
+        .idempotent()
+        .openWorld()
+        .build(),
+    tool('page_scroll')
+        .desc('Scroll the page')
+        .number('x', 'Horizontal scroll position', { default: 0 })
+        .number('y', 'Vertical scroll position', { default: 0 })
+        .idempotent()
+        .build(),
+    tool('page_wait_for_selector')
+        .desc('Wait for an element to appear')
+        .string('selector', 'CSS selector to wait for')
+        .number('timeout', 'Timeout in milliseconds', { default: 30000 })
+        .required('selector')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('page_evaluate')
+        .desc(`Execute JavaScript code in page context and get result.
 
 IMPORTANT: Large results (>50KB) automatically return summary + detailId to prevent context overflow.
 Use get_detailed_data(detailId) to retrieve full data if needed.
@@ -289,111 +135,59 @@ Best Practices:
 Example:
 page_evaluate("({ keys: Object.keys(window.byted_acrawler), type: typeof window.byted_acrawler })")
 -> Returns small summary
--> If you need full object, use the returned detailId`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                code: {
-                    type: 'string',
-                    description: 'JavaScript code to execute',
-                },
-                autoSummarize: {
-                    type: 'boolean',
-                    description: 'Auto-summarize large results (default: true)',
-                    default: true,
-                },
-                maxSize: {
-                    type: 'number',
-                    description: 'Max result size in bytes before auto-summarizing (default: 50KB)',
-                    default: 51200,
-                },
-                fieldFilter: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Server-side field filter: remove keys matching these names from the result object (recursive). Useful to strip noise fields like "icon", "avatar", "base64Image".',
-                },
-                stripBase64: {
-                    type: 'boolean',
-                    description: 'Strip data URI and bare base64 strings from the result, replacing them with a size placeholder. Prevents context overflow from embedded images/fonts (default: false).',
-                    default: false,
-                },
-            },
-            required: ['code'],
-        },
-    },
-    {
-        name: 'page_screenshot',
-        description: `Take a screenshot of the page, a specific DOM element, multiple elements, or a pixel region.
+-> If you need full object, use the returned detailId`)
+        .string('code', 'JavaScript code to execute')
+        .boolean('autoSummarize', 'Auto-summarize large results (default: true)', { default: true })
+        .number('maxSize', 'Max result size in bytes before auto-summarizing (default: 50KB)', {
+        default: 51200,
+    })
+        .array('fieldFilter', { type: 'string' }, 'Server-side field filter: remove keys matching these names from the result object (recursive). Useful to strip noise fields like "icon", "avatar", "base64Image".')
+        .boolean('stripBase64', 'Strip data URI and bare base64 strings from the result, replacing them with a size placeholder. Prevents context overflow from embedded images/fonts (default: false).', { default: false })
+        .required('code')
+        .openWorld()
+        .build(),
+    tool('page_screenshot')
+        .desc(`Take a screenshot of the page, a specific DOM element, multiple elements, or a pixel region.
 
 Modes:
 - Full page: omit selector or pass "all"
 - Single element: selector = ".my-class"
 - Multiple elements: selector = [".header", "#main", ".footer"] — returns one screenshot per element
-- Pixel region: pass clip = {x, y, width, height} (ignored when selector is set)`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: {
-                    oneOf: [
-                        { type: 'string', description: 'Single CSS selector' },
-                        {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'Array of CSS selectors for batch element screenshots',
-                        },
-                    ],
-                    description: 'CSS selector(s) of the element(s) to screenshot. Omit or pass "all" for full page viewport.',
-                },
-                clip: {
-                    type: 'object',
-                    description: 'Pixel region to capture (ignored when selector is set)',
-                    properties: {
-                        x: { type: 'number', description: 'Left offset in pixels' },
-                        y: { type: 'number', description: 'Top offset in pixels' },
-                        width: { type: 'number', description: 'Region width in pixels' },
-                        height: { type: 'number', description: 'Region height in pixels' },
-                    },
-                    required: ['x', 'y', 'width', 'height'],
-                },
-                path: {
-                    type: 'string',
-                    description: 'File path to save screenshot (optional). For batch mode, used as directory or base name.',
-                },
-                type: {
-                    type: 'string',
-                    description: 'Image format',
-                    enum: ['png', 'jpeg'],
-                    default: 'png',
-                },
-                quality: {
-                    type: 'number',
-                    description: 'Image quality (0-100, only for jpeg)',
-                },
-                fullPage: {
-                    type: 'boolean',
-                    description: 'Capture full scrollable page (ignored when selector or clip is set)',
-                    default: false,
-                },
-            },
-        },
-    },
-    {
-        name: 'get_all_scripts',
-        description: 'Get list of all loaded scripts on the page',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                includeSource: {
-                    type: 'boolean',
-                    description: 'Whether to include script source code',
-                    default: false,
-                },
+- Pixel region: pass clip = {x, y, width, height} (ignored when selector is set)`)
+        .prop('selector', {
+        oneOf: [
+            { type: 'string', description: 'Single CSS selector' },
+            {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Array of CSS selectors for batch element screenshots',
             },
-        },
-    },
-    {
-        name: 'get_script_source',
-        description: `Get source code of a specific script.
+        ],
+        description: 'CSS selector(s) of the element(s) to screenshot. Omit or pass "all" for full page viewport.',
+    })
+        .object('clip', {
+        x: { type: 'number', description: 'Left offset in pixels' },
+        y: { type: 'number', description: 'Top offset in pixels' },
+        width: { type: 'number', description: 'Region width in pixels' },
+        height: { type: 'number', description: 'Region height in pixels' },
+    }, 'Pixel region to capture (ignored when selector is set)', { required: ['x', 'y', 'width', 'height'] })
+        .string('path', 'File path to save screenshot (optional). For batch mode, used as directory or base name.')
+        .enum('type', ['png', 'jpeg'], 'Image format', { default: 'png' })
+        .number('quality', 'Image quality (0-100, only for jpeg)')
+        .boolean('fullPage', 'Capture full scrollable page (ignored when selector or clip is set)', {
+        default: false,
+    })
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('get_all_scripts')
+        .desc('Get list of all loaded scripts on the page')
+        .boolean('includeSource', 'Whether to include script source code', { default: false })
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('get_script_source')
+        .desc(`Get source code of a specific script.
 
 IMPORTANT: Large scripts (>50KB) automatically return summary + detailId.
 Use preview mode first to check script size before fetching full source.
@@ -406,37 +200,14 @@ Best Practices:
 Example:
 get_script_source(scriptId="abc", preview=true)
 -> Returns: { lines: 5000, size: "500KB", preview: "...", detailId: "..." }
--> Then: get_detailed_data(detailId) to get full source`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                scriptId: {
-                    type: 'string',
-                    description: 'Script ID from get_all_scripts',
-                },
-                url: {
-                    type: 'string',
-                    description: 'Script URL (supports wildcards like *.js)',
-                },
-                preview: {
-                    type: 'boolean',
-                    description: 'Return preview only (first 100 lines + metadata)',
-                    default: false,
-                },
-                maxLines: {
-                    type: 'number',
-                    description: 'Max lines to return in preview mode (default: 100)',
-                    default: 100,
-                },
-                startLine: {
-                    type: 'number',
-                    description: 'Start line number (1-based, for partial fetch)',
-                },
-                endLine: {
-                    type: 'number',
-                    description: 'End line number (1-based, for partial fetch)',
-                },
-            },
-        },
-    },
+-> Then: get_detailed_data(detailId) to get full source`)
+        .string('scriptId', 'Script ID from get_all_scripts')
+        .string('url', 'Script URL (supports wildcards like *.js)')
+        .boolean('preview', 'Return preview only (first 100 lines + metadata)', { default: false })
+        .number('maxLines', 'Max lines to return in preview mode (default: 100)', { default: 100 })
+        .number('startLine', 'Start line number (1-based, for partial fetch)')
+        .number('endLine', 'End line number (1-based, for partial fetch)')
+        .readOnly()
+        .idempotent()
+        .build(),
 ];