@jshookmcp/jshook 0.2.0 → 0.2.1

package/dist/tests/server/ToolRouter.test.js

@@ -0,0 +1,288 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+function tool(name, description = `Description for ${name}`, inputSchema = { type: 'object', properties: {} }) {
+    return { name, description, inputSchema };
+}
+const mocks = vi.hoisted(() => {
+    const logger = {
+        info: vi.fn(),
+    };
+    const builtinTools = [
+        tool('browser_launch', 'Launch a browser'),
+        tool('browser_attach', 'Attach to an existing browser'),
+        tool('page_navigate', 'Navigate to a page'),
+        tool('page_screenshot', 'Take a screenshot'),
+        tool('page_click', 'Click an element'),
+        tool('page_type', 'Type into an input'),
+        tool('page_evaluate', 'Evaluate JavaScript'),
+        tool('network_enable', 'Enable request capture'),
+        tool('network_get_requests', 'Inspect captured requests'),
+        tool('get_token_budget_stats', 'Inspect token budget state'),
+        tool('run_extension_workflow', 'Execute extension workflow'),
+        tool('list_extension_workflows', 'List loaded extension workflows'),
+    ];
+    const domainMap = new Map([
+        ['browser_launch', 'browser'],
+        ['browser_attach', 'browser'],
+        ['page_navigate', 'browser'],
+        ['page_screenshot', 'browser'],
+        ['page_click', 'browser'],
+        ['page_type', 'browser'],
+        ['page_evaluate', 'browser'],
+        ['network_enable', 'network'],
+        ['network_get_requests', 'network'],
+        ['get_token_budget_stats', 'maintenance'],
+        ['run_extension_workflow', 'workflow'],
+        ['list_extension_workflows', 'workflow'],
+    ]);
+    return {
+        logger,
+        builtinTools,
+        domainMap,
+    };
+});
+vi.mock('@utils/logger', () => ({
+    logger: mocks.logger,
+}));
+vi.mock('@server/ToolCatalog', () => ({
+    allTools: mocks.builtinTools,
+    getToolDomain: (name) => mocks.domainMap.get(name) ?? null,
+}));
+vi.mock('@server/MCPServer.search.helpers', () => ({
+    getActiveToolNames: (ctx) => new Set([
+        ...ctx.selectedTools.map((candidate) => candidate.name),
+        ...ctx.activatedToolNames,
+    ]),
+}));
+import { describeTool, generateExampleArgs, routeToolRequest } from '../../src/server/ToolRouter.js';
+function createCtx(overrides = {}) {
+    return {
+        selectedTools: [],
+        activatedToolNames: new Set(),
+        extensionToolsByName: new Map(),
+        pageController: undefined,
+        consoleMonitor: undefined,
+        ...overrides,
+    };
+}
+describe('ToolRouter', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('generates example arguments from required fields, enums, defaults, and primitive types', () => {
+        const example = generateExampleArgs({
+            type: 'object',
+            required: ['url', 'count', 'flag', 'mode', 'items', 'config'],
+            properties: {
+                url: { type: 'string' },
+                count: { type: 'integer' },
+                flag: { type: 'boolean' },
+                mode: { type: 'string', enum: ['fast', 'slow'] },
+                items: { type: 'array' },
+                config: { type: 'object' },
+                optionalDefault: { type: 'string', default: 'value' },
+                skippedOptional: { type: 'string' },
+            },
+        });
+        expect(example).toEqual({
+            url: '<url>',
+            count: 0,
+            flag: false,
+            mode: 'fast',
+            items: [],
+            config: {},
+            optionalDefault: 'value',
+        });
+    });
+    it('returns an empty example object for non-object schemas', () => {
+        expect(generateExampleArgs(undefined)).toEqual({});
+        expect(generateExampleArgs({ type: 'string' })).toEqual({});
+    });
+    it('describes built-in and extension tools using canonical names', () => {
+        const ctx = createCtx({
+            extensionToolsByName: new Map([
+                [
+                    'custom_tool',
+                    {
+                        name: 'custom_tool',
+                        domain: 'workflow',
+                        tool: tool('custom_tool', 'Custom workflow description\nExtra implementation details', { type: 'object', properties: { input: { type: 'string' } } }),
+                    },
+                ],
+            ]),
+        });
+        expect(describeTool('mcp__jshook__page_navigate', ctx)).toEqual({
+            name: 'page_navigate',
+            description: 'Navigate to a page',
+            inputSchema: { type: 'object', properties: {} },
+        });
+        expect(describeTool('custom_tool', ctx)).toEqual({
+            name: 'custom_tool',
+            description: 'Custom workflow description',
+            inputSchema: { type: 'object', properties: { input: { type: 'string' } } },
+        });
+        expect(describeTool('missing_tool', ctx)).toBeNull();
+    });
+    it('prioritizes browser bootstrap and suppresses maintenance noise for network-capture tasks without a page', async () => {
+        const ctx = createCtx({
+            pageController: {
+                getPage: vi.fn(async () => {
+                    throw new Error('no page');
+                }),
+            },
+            consoleMonitor: {
+                getNetworkStatus: vi.fn(() => ({ enabled: false })),
+                getNetworkRequests: vi.fn(() => []),
+            },
+        });
+        const searchEngine = {
+            search: vi.fn(() => [
+                {
+                    name: 'get_token_budget_stats',
+                    shortDescription: 'Inspect token budget state',
+                    score: 50,
+                    domain: 'maintenance',
+                    isActive: false,
+                },
+                {
+                    name: 'network_get_requests',
+                    shortDescription: 'Inspect captured requests',
+                    score: 20,
+                    domain: 'network',
+                    isActive: false,
+                },
+            ]),
+        };
+        const response = await routeToolRequest({ task: 'capture network traffic for this page', context: { autoActivate: false } }, ctx, searchEngine);
+        expect(searchEngine.search).toHaveBeenCalledWith('capture network traffic for this page', 10, new Set());
+        expect(response.workflowHint).toContain('Network capture workflow');
+        expect(response.recommendations[0]).toMatchObject({
+            name: 'browser_launch',
+            domain: 'browser',
+            isActive: false,
+        });
+        expect(response.recommendations.map((item) => item.name)).not.toContain('get_token_budget_stats');
+        expect(response.nextActions[0]).toEqual({
+            step: 1,
+            action: 'activate',
+            toolName: undefined,
+            command: 'activate_tools with names: ["browser_launch", "browser_attach", "network_enable", "page_navigate", "network_get_requests"]',
+            description: 'Activate 5 recommended tools',
+        });
+    });
+    it('prioritizes network_get_requests when a page exists and traffic is already captured', async () => {
+        const ctx = createCtx({
+            pageController: {
+                getPage: vi.fn(async () => ({})),
+            },
+            consoleMonitor: {
+                getNetworkStatus: vi.fn(() => ({ enabled: true })),
+                getNetworkRequests: vi.fn(() => [{ id: '1' }]),
+            },
+        });
+        const searchEngine = {
+            search: vi.fn(() => [
+                {
+                    name: 'get_token_budget_stats',
+                    shortDescription: 'Inspect token budget state',
+                    score: 60,
+                    domain: 'maintenance',
+                    isActive: false,
+                },
+                {
+                    name: 'page_navigate',
+                    shortDescription: 'Navigate to a page',
+                    score: 10,
+                    domain: 'browser',
+                    isActive: false,
+                },
+            ]),
+        };
+        const response = await routeToolRequest({ task: 'capture network traffic for this page', context: { autoActivate: false } }, ctx, searchEngine);
+        expect(response.recommendations).toHaveLength(4);
+        expect(response.recommendations[0].name).toBe('network_get_requests');
+        expect(response.recommendations[0].activationCommand).toBe('activate_tools with names: ["network_get_requests"]');
+    });
+    it('boosts preferred domains for non-workflow searches', async () => {
+        const ctx = createCtx();
+        const searchEngine = {
+            search: vi.fn(() => [
+                {
+                    name: 'page_navigate',
+                    shortDescription: 'Navigate to a page',
+                    score: 10,
+                    domain: 'browser',
+                    isActive: false,
+                },
+                {
+                    name: 'network_get_requests',
+                    shortDescription: 'Inspect captured requests',
+                    score: 9.5,
+                    domain: 'network',
+                    isActive: false,
+                },
+            ]),
+        };
+        const response = await routeToolRequest({ task: 'inspect requests', context: { preferredDomain: 'network', autoActivate: false } }, ctx, searchEngine);
+        expect(response.recommendations).toHaveLength(2);
+        expect(response.recommendations[0].name).toBe('network_get_requests');
+    });
+    it('emits a direct call next action when the top recommendation is already active', async () => {
+        const ctx = createCtx({
+            selectedTools: [tool('get_token_budget_stats')],
+            activatedToolNames: new Set(['get_token_budget_stats']),
+        });
+        const searchEngine = {
+            search: vi.fn(() => [
+                {
+                    name: 'get_token_budget_stats',
+                    shortDescription: 'Inspect token budget state',
+                    score: 5,
+                    domain: 'maintenance',
+                    isActive: true,
+                },
+            ]),
+        };
+        const response = await routeToolRequest({ task: 'token budget report', context: { autoActivate: false } }, ctx, searchEngine);
+        expect(response.nextActions).toEqual([
+            {
+                step: 1,
+                action: 'call',
+                toolName: 'get_token_budget_stats',
+                command: 'get_token_budget_stats',
+                exampleArgs: {},
+                description: 'Call get_token_budget_stats. Use describe_tool("get_token_budget_stats") only if you need the full schema.',
+            },
+        ]);
+    });
+    it('keeps maintenance recommendations for maintenance-oriented tasks', async () => {
+        const ctx = createCtx();
+        const searchEngine = {
+            search: vi.fn(() => [
+                {
+                    name: 'get_token_budget_stats',
+                    shortDescription: 'Inspect token budget state',
+                    score: 10,
+                    domain: 'maintenance',
+                    isActive: false,
+                },
+                {
+                    name: 'page_navigate',
+                    shortDescription: 'Navigate to a page',
+                    score: 9,
+                    domain: 'browser',
+                    isActive: false,
+                },
+            ]),
+        };
+        const response = await routeToolRequest({ task: 'cleanup cache and inspect token budget', context: { autoActivate: false } }, ctx, searchEngine);
+        expect(response.recommendations).toHaveLength(2);
+        expect(response.recommendations[0].name).toBe('get_token_budget_stats');
+        expect(response.nextActions[0]).toEqual({
+            step: 1,
+            action: 'activate',
+            toolName: undefined,
+            command: 'activate_tools with names: ["get_token_budget_stats", "page_navigate"]',
+            description: 'Activate 2 recommended tools',
+        });
+    });
+});

package/dist/tests/server/domains/analysis/definitions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/analysis/definitions.test.js

@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest';
+import { coreTools } from '../../../../src/server/domains/analysis/definitions.js';
+describe('server/domains/analysis/definitions', () => {
+    it('exports coreTools as a non-empty array', () => {
+        expect(Array.isArray(coreTools)).toBe(true);
+        expect(coreTools.length).toBeGreaterThan(0);
+    });
+    it('every tool has name, description, and inputSchema', () => {
+        coreTools.forEach((tool) => {
+            expect(tool).toEqual(expect.objectContaining({
+                name: expect.any(String),
+                description: expect.any(String),
+                inputSchema: expect.objectContaining({
+                    type: 'object',
+                }),
+            }));
+        });
+    });
+    it('has no duplicate tool names', () => {
+        const names = coreTools.map((t) => t.name);
+        expect(new Set(names).size).toBe(names.length);
+    });
+    it('includes expected core tools', () => {
+        const names = coreTools.map((t) => t.name);
+        expect(names).toContain('collect_code');
+        expect(names).toContain('search_in_scripts');
+        expect(names).toContain('extract_function_tree');
+        expect(names).toContain('deobfuscate');
+        expect(names).toContain('understand_code');
+        expect(names).toContain('detect_crypto');
+        expect(names).toContain('manage_hooks');
+        expect(names).toContain('detect_obfuscation');
+        expect(names).toContain('advanced_deobfuscate');
+        expect(names).toContain('webcrack_unpack');
+        expect(names).toContain('clear_collected_data');
+        expect(names).toContain('get_collection_stats');
+        expect(names).toContain('webpack_enumerate');
+        expect(names).toContain('source_map_extract');
+    });
+    it('collect_code requires url parameter', () => {
+        const tool = coreTools.find((t) => t.name === 'collect_code');
+        expect(tool.inputSchema.required).toContain('url');
+        expect(tool.inputSchema.properties).toHaveProperty('url');
+        expect(tool.inputSchema.properties).toHaveProperty('smartMode');
+        expect(tool.inputSchema.properties).toHaveProperty('compress');
+    });
+    it('search_in_scripts requires keyword parameter', () => {
+        const tool = coreTools.find((t) => t.name === 'search_in_scripts');
+        expect(tool.inputSchema.required).toContain('keyword');
+        expect(tool.inputSchema.properties).toHaveProperty('isRegex');
+        expect(tool.inputSchema.properties).toHaveProperty('caseSensitive');
+        expect(tool.inputSchema.properties).toHaveProperty('maxMatches');
+    });
+    it('extract_function_tree requires scriptId and functionName', () => {
+        const tool = coreTools.find((t) => t.name === 'extract_function_tree');
+        expect(tool.inputSchema.required).toContain('scriptId');
+        expect(tool.inputSchema.required).toContain('functionName');
+    });
+    it('deobfuscate requires code and has webcrack options', () => {
+        const tool = coreTools.find((t) => t.name === 'deobfuscate');
+        expect(tool.inputSchema.required).toContain('code');
+        expect(tool.inputSchema.properties).toHaveProperty('unpack');
+        expect(tool.inputSchema.properties).toHaveProperty('unminify');
+        expect(tool.inputSchema.properties).toHaveProperty('jsx');
+        expect(tool.inputSchema.properties).toHaveProperty('mangle');
+        expect(tool.inputSchema.properties).toHaveProperty('outputDir');
+        expect(tool.inputSchema.properties).toHaveProperty('mappings');
+    });
+    it('understand_code requires code and has focus enum', () => {
+        const tool = coreTools.find((t) => t.name === 'understand_code');
+        expect(tool.inputSchema.required).toContain('code');
+        const focusProp = tool.inputSchema.properties.focus;
+        expect(focusProp.enum).toContain('structure');
+        expect(focusProp.enum).toContain('business');
+        expect(focusProp.enum).toContain('security');
+        expect(focusProp.enum).toContain('all');
+    });
+    it('manage_hooks requires action and has correct enums', () => {
+        const tool = coreTools.find((t) => t.name === 'manage_hooks');
+        expect(tool.inputSchema.required).toContain('action');
+        const actionProp = tool.inputSchema.properties.action;
+        expect(actionProp.enum).toEqual(['create', 'list', 'records', 'clear']);
+    });
+    it('advanced_deobfuscate requires code and has webcrack options', () => {
+        const tool = coreTools.find((t) => t.name === 'advanced_deobfuscate');
+        expect(tool.inputSchema.required).toContain('code');
+        expect(tool.inputSchema.properties).toHaveProperty('aggressiveVM');
+        expect(tool.inputSchema.properties).toHaveProperty('useASTOptimization');
+        expect(tool.inputSchema.properties).toHaveProperty('timeout');
+        expect(tool.inputSchema.properties).toHaveProperty('unpack');
+    });
+    it('webcrack_unpack requires code and has extraction options', () => {
+        const tool = coreTools.find((t) => t.name === 'webcrack_unpack');
+        expect(tool.inputSchema.required).toContain('code');
+        expect(tool.inputSchema.properties).toHaveProperty('includeModuleCode');
+        expect(tool.inputSchema.properties).toHaveProperty('maxBundleModules');
+        expect(tool.inputSchema.properties).toHaveProperty('mappings');
+    });
+    it('clear_collected_data and get_collection_stats have no required params', () => {
+        const clearTool = coreTools.find((t) => t.name === 'clear_collected_data');
+        const statsTool = coreTools.find((t) => t.name === 'get_collection_stats');
+        expect(clearTool.inputSchema.required ?? []).toHaveLength(0);
+        expect(statsTool.inputSchema.required ?? []).toHaveLength(0);
+    });
+    it('webpack_enumerate has optional searchKeyword', () => {
+        const tool = coreTools.find((t) => t.name === 'webpack_enumerate');
+        expect(tool.inputSchema.properties).toHaveProperty('searchKeyword');
+        expect(tool.inputSchema.properties).toHaveProperty('maxResults');
+        expect(tool.inputSchema.required ?? []).toHaveLength(0);
+    });
+    it('source_map_extract has optional filter and content params', () => {
+        const tool = coreTools.find((t) => t.name === 'source_map_extract');
+        expect(tool.inputSchema.properties).toHaveProperty('includeContent');
+        expect(tool.inputSchema.properties).toHaveProperty('filterPath');
+        expect(tool.inputSchema.properties).toHaveProperty('maxFiles');
+    });
+    it('deobfuscate mappings items have required path and pattern', () => {
+        const tool = coreTools.find((t) => t.name === 'deobfuscate');
+        const mappings = tool.inputSchema.properties.mappings;
+        expect(mappings.items?.required).toContain('path');
+        expect(mappings.items?.required).toContain('pattern');
+    });
+});

package/dist/tests/server/domains/analysis/exports.test.d.ts

@@ -0,0 +1 @@
+import '../shared/manifest-test-mocks.js';

package/dist/tests/server/domains/analysis/exports.test.js

@@ -0,0 +1,19 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import '../shared/manifest-test-mocks.js';
+import { assertDomainExportContract } from '../shared/export-contract-helpers.js';
+describe('server/domains/analysis exports', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    it('exposes core tool definitions and a matching manifest', async () => {
+        expect.hasAssertions();
+        await assertDomainExportContract({
+            expectedDomain: 'core',
+            definitionExportNames: ['coreTools'],
+            loadDefinitions: () => import('../../../../src/server/domains/analysis/definitions.js'),
+            getToolArrays: (module) => [module.coreTools],
+            loadManifest: () => import('../../../../src/server/domains/analysis/manifest.js'),
+        });
+    });
+});

package/dist/tests/server/domains/analysis/handlers-extended.test.d.ts

@@ -0,0 +1 @@
+export {};