@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/MCPServer.search.handlers.extensions.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const mocks = vi.hoisted(() => ({
+    asTextResponse: vi.fn((text) => ({
+        content: [{ type: 'text', text }],
+    })),
+}));
+vi.mock('@server/domains/shared/response', () => ({
+    asTextResponse: mocks.asTextResponse,
+}));
+import { handleExtensionsList, handleExtensionsReload, } from '../../src/server/MCPServer.search.handlers.extensions.js';
+function parseResponse(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('MCPServer.search.handlers.extensions', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('reloads extensions and returns a formatted JSON response', async () => {
+        const ctx = {
+            reloadExtensions: vi.fn(async () => ({
+                success: true,
+                addedTools: 2,
+            })),
+        };
+        const response = await handleExtensionsReload(ctx);
+        expect(ctx.reloadExtensions).toHaveBeenCalledTimes(1);
+        expect(mocks.asTextResponse).toHaveBeenCalledWith(JSON.stringify({
+            success: true,
+            addedTools: 2,
+        }, null, 2));
+        expect(parseResponse(response)).toEqual({
+            success: true,
+            addedTools: 2,
+        });
+        expect(response.content[0].text).toContain('\n  "success": true,\n');
+    });
+    it('lists extensions and returns a formatted JSON response', async () => {
+        const ctx = {
+            listExtensions: vi.fn(() => ({
+                success: true,
+                plugins: ['workflow-kit'],
+            })),
+        };
+        const response = await handleExtensionsList(ctx);
+        expect(ctx.listExtensions).toHaveBeenCalledTimes(1);
+        expect(mocks.asTextResponse).toHaveBeenCalledWith(JSON.stringify({
+            success: true,
+            plugins: ['workflow-kit'],
+        }, null, 2));
+        expect(parseResponse(response)).toEqual({
+            success: true,
+            plugins: ['workflow-kit'],
+        });
+    });
+});

package/dist/tests/server/MCPServer.search.handlers.route.test.d.ts

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

package/dist/tests/server/MCPServer.search.handlers.route.test.js

@@ -0,0 +1,206 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const state = vi.hoisted(() => ({
+    routeToolRequest: vi.fn(),
+    describeTool: vi.fn(),
+    buildCallToolCommand: vi.fn((name, _schema) => `call_tool({ name: "${name}", args: {} })`),
+    activateToolNames: vi.fn(),
+    handleActivateDomain: vi.fn(),
+    getSearchEngine: vi.fn(() => ({ kind: 'engine' })),
+}));
+vi.mock('@server/domains/shared/response', () => ({
+    asTextResponse: (text) => ({
+        content: [{ type: 'text', text }],
+    }),
+}));
+vi.mock('@server/ToolRouter', () => ({
+    routeToolRequest: state.routeToolRequest,
+    describeTool: state.describeTool,
+    buildCallToolCommand: state.buildCallToolCommand,
+}));
+vi.mock('@server/MCPServer.search.handlers.activate', () => ({
+    activateToolNames: state.activateToolNames,
+}));
+vi.mock('@server/MCPServer.search.handlers.domain', () => ({
+    handleActivateDomain: state.handleActivateDomain,
+}));
+vi.mock('@server/MCPServer.search.helpers', () => ({
+    getSearchEngine: state.getSearchEngine,
+}));
+vi.mock('@src/constants', () => ({
+    ACTIVATION_TTL_MINUTES: 30,
+}));
+import { handleDescribeTool, handleRouteTool, } from '../../src/server/MCPServer.search.handlers.route.js';
+function createCtx(overrides = {}) {
+    return {
+        enabledDomains: new Set(),
+        activatedToolNames: new Set(),
+        ...overrides,
+    };
+}
+function parseResponse(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('MCPServer.search.handlers.route', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        state.getSearchEngine.mockReturnValue({ kind: 'engine' });
+        state.activateToolNames.mockResolvedValue({
+            activated: [],
+            alreadyActive: [],
+            notFound: [],
+            totalActive: 0,
+        });
+        state.handleActivateDomain.mockResolvedValue({
+            content: [{ type: 'text', text: '{"success":true}' }],
+        });
+    });
+    it('rejects invalid route_tool requests', async () => {
+        const ctx = createCtx();
+        expect(parseResponse(await handleRouteTool(ctx, {}))).toEqual({
+            success: false,
+            error: 'task must be a non-empty string',
+        });
+    });
+    it('passes through route results when autoActivate is disabled', async () => {
+        const ctx = createCtx();
+        state.routeToolRequest.mockResolvedValueOnce({
+            recommendations: [],
+            nextActions: [{ step: 1, action: 'call', command: 'page_navigate', description: 'Call it' }],
+        });
+        const response = parseResponse(await handleRouteTool(ctx, {
+            task: 'navigate to a page',
+            context: { autoActivate: false },
+        }));
+        expect(response).toEqual({
+            recommendations: [],
+            nextActions: [{ step: 1, action: 'call', command: 'page_navigate', description: 'Call it' }],
+        });
+        expect(state.routeToolRequest).toHaveBeenCalledOnce();
+        expect(state.handleActivateDomain).not.toHaveBeenCalled();
+        expect(state.activateToolNames).not.toHaveBeenCalled();
+    });
+    it('auto-activates inactive recommendation domains and reroutes with autoActivate disabled', async () => {
+        const ctx = createCtx();
+        state.routeToolRequest
+            .mockResolvedValueOnce({
+            recommendations: [
+                { name: 'page_navigate', domain: 'browser', isActive: false },
+                { name: 'network_get_requests', domain: 'network', isActive: false },
+            ],
+            nextActions: [],
+        })
+            .mockResolvedValueOnce({
+            recommendations: [
+                { name: 'page_navigate', domain: 'browser', isActive: true },
+                { name: 'network_get_requests', domain: 'network', isActive: true },
+            ],
+            nextActions: [{ step: 1, action: 'call', command: 'page_navigate', description: 'Call it' }],
+        });
+        state.handleActivateDomain.mockImplementation(async (innerCtx, args) => {
+            if (args.domain === 'browser') {
+                innerCtx.enabledDomains.add('browser');
+                innerCtx.activatedToolNames.add('page_navigate');
+            }
+            if (args.domain === 'network') {
+                innerCtx.enabledDomains.add('network');
+                innerCtx.activatedToolNames.add('network_get_requests');
+            }
+            return { content: [{ type: 'text', text: '{"success":true}' }] };
+        });
+        const response = parseResponse(await handleRouteTool(ctx, { task: 'inspect requests' }));
+        expect(state.handleActivateDomain).toHaveBeenNthCalledWith(1, ctx, {
+            domain: 'browser',
+            ttlMinutes: 30,
+        });
+        expect(state.handleActivateDomain).toHaveBeenNthCalledWith(2, ctx, {
+            domain: 'network',
+            ttlMinutes: 30,
+        });
+        expect(state.activateToolNames).not.toHaveBeenCalled();
+        expect(state.routeToolRequest).toHaveBeenNthCalledWith(2, { task: 'inspect requests', context: { autoActivate: false } }, ctx, { kind: 'engine' });
+        expect(response.autoActivated).toBe(true);
+        expect(response.activatedNames).toEqual(['page_navigate', 'network_get_requests']);
+    });
+    it('activates tools individually for recommendations without a domain or already-enabled domains', async () => {
+        const ctx = createCtx({
+            enabledDomains: new Set(['browser']),
+        });
+        state.routeToolRequest
+            .mockResolvedValueOnce({
+            recommendations: [
+                { name: 'page_navigate', domain: 'browser', isActive: false },
+                { name: 'page_navigate', domain: 'browser', isActive: false },
+                { name: 'custom_tool', domain: null, isActive: false },
+            ],
+            nextActions: [],
+        })
+            .mockResolvedValueOnce({
+            recommendations: [
+                { name: 'page_navigate', domain: 'browser', isActive: true },
+                { name: 'custom_tool', domain: null, isActive: true },
+            ],
+            nextActions: [{ step: 1, action: 'call', command: 'custom_tool', description: 'Call it' }],
+        });
+        state.activateToolNames.mockImplementation(async (innerCtx, names) => {
+            for (const name of names)
+                innerCtx.activatedToolNames.add(name);
+            return {
+                activated: names,
+                alreadyActive: [],
+                notFound: [],
+                totalActive: innerCtx.activatedToolNames.size,
+            };
+        });
+        const response = parseResponse(await handleRouteTool(ctx, { task: 'use custom helper' }));
+        expect(state.handleActivateDomain).not.toHaveBeenCalled();
+        expect(state.activateToolNames).toHaveBeenCalledWith(ctx, ['page_navigate', 'custom_tool']);
+        expect(response.autoActivated).toBe(true);
+        expect(response.activatedNames).toEqual(['page_navigate', 'page_navigate', 'custom_tool']);
+    });
+    it('returns the original route response when activation fails and nothing becomes active', async () => {
+        const ctx = createCtx();
+        state.routeToolRequest.mockResolvedValueOnce({
+            recommendations: [{ name: 'page_navigate', domain: 'browser', isActive: false }],
+            nextActions: [],
+        });
+        state.handleActivateDomain.mockRejectedValueOnce(new Error('activate failed'));
+        const response = parseResponse(await handleRouteTool(ctx, { task: 'navigate' }));
+        expect(state.routeToolRequest).toHaveBeenCalledOnce();
+        expect(state.activateToolNames).not.toHaveBeenCalled();
+        expect(response).toEqual({
+            recommendations: [{ name: 'page_navigate', domain: 'browser', isActive: false, callCommand: 'call_tool({ name: "page_navigate", args: {} })' }],
+            nextActions: [],
+        });
+    });
+    it('rejects invalid describe_tool requests', async () => {
+        const ctx = createCtx();
+        expect(parseResponse(await handleDescribeTool(ctx, {}))).toEqual({
+            success: false,
+            error: 'name must be a non-empty string',
+        });
+    });
+    it('returns not found when describe_tool cannot resolve a tool', async () => {
+        const ctx = createCtx();
+        state.describeTool.mockReturnValueOnce(undefined);
+        expect(parseResponse(await handleDescribeTool(ctx, { name: 'missing_tool' }))).toEqual({
+            success: false,
+            error: 'Tool not found: missing_tool',
+        });
+    });
+    it('returns tool details from describe_tool', async () => {
+        const ctx = createCtx();
+        state.describeTool.mockReturnValueOnce({
+            name: 'page_navigate',
+            description: 'Navigate page',
+            inputSchema: { type: 'object', properties: {} },
+        });
+        expect(parseResponse(await handleDescribeTool(ctx, { name: 'page_navigate' }))).toEqual({
+            success: true,
+            tool: {
+                name: 'page_navigate',
+                description: 'Navigate page',
+                inputSchema: { type: 'object', properties: {} },
+            },
+        });
+    });
+});

package/dist/tests/server/MCPServer.search.handlers.search.test.d.ts

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

package/dist/tests/server/MCPServer.search.handlers.search.test.js

@@ -0,0 +1,289 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const state = vi.hoisted(() => ({
+    engine: {
+        search: vi.fn(),
+    },
+    activeNames: new Set(),
+    getSearchEngine: vi.fn(),
+    getActiveToolNames: vi.fn(),
+    handleActivateDomain: vi.fn(),
+    describeTool: vi.fn(),
+    generateExampleArgs: vi.fn(),
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        debug: vi.fn(),
+        error: vi.fn(),
+    },
+}));
+vi.mock('@server/domains/shared/response', () => ({
+    asTextResponse: (text) => ({
+        content: [{ type: 'text', text }],
+    }),
+}));
+vi.mock('@server/MCPServer.search.helpers', () => ({
+    getSearchEngine: state.getSearchEngine,
+    getActiveToolNames: state.getActiveToolNames,
+}));
+vi.mock('@server/MCPServer.search.handlers.domain', () => ({
+    handleActivateDomain: state.handleActivateDomain,
+}));
+vi.mock('@server/ToolRouter', () => ({
+    describeTool: state.describeTool,
+    generateExampleArgs: state.generateExampleArgs,
+}));
+vi.mock('@src/constants', () => ({
+    SEARCH_AUTO_ACTIVATE_DOMAINS: true,
+    ACTIVATION_TTL_MINUTES: 30,
+}));
+vi.mock('@utils/logger', () => ({
+    logger: state.logger,
+}));
+import { handleSearchTools } from '../../src/server/MCPServer.search.handlers.search.js';
+function createCtx(overrides = {}) {
+    return {
+        enabledDomains: new Set(),
+        ...overrides,
+    };
+}
+function parseResponse(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('MCPServer.search.handlers.search', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        state.activeNames = new Set();
+        state.getSearchEngine.mockReturnValue(state.engine);
+        state.getActiveToolNames.mockImplementation(() => new Set(state.activeNames));
+        state.handleActivateDomain.mockResolvedValue({
+            content: [{ type: 'text', text: '{"success":true}' }],
+        });
+        state.describeTool.mockReturnValue({
+            name: 'page_navigate',
+            inputSchema: { type: 'object', properties: {} },
+        });
+        state.generateExampleArgs.mockReturnValue({});
+    });
+    it('uses the default top_k and returns direct call guidance for active top results', async () => {
+        const ctx = createCtx({
+            enabledDomains: new Set(['browser']),
+        });
+        state.activeNames = new Set(['page_navigate']);
+        state.engine.search.mockReturnValue([
+            {
+                name: 'page_navigate',
+                description: 'Navigate page',
+                shortDescription: 'Navigate page',
+                score: 10,
+                domain: 'browser',
+                isActive: true,
+            },
+        ]);
+        const response = parseResponse(await handleSearchTools(ctx, { query: 'navigate' }));
+        expect(state.engine.search).toHaveBeenCalledWith('navigate', 10, new Set(['page_navigate']));
+        expect(response.nextActions).toEqual([
+            {
+                step: 1,
+                action: 'call',
+                command: 'page_navigate',
+                exampleArgs: {},
+                description: 'Call page_navigate directly. Use describe_tool("page_navigate") only if you need the full schema.',
+            },
+        ]);
+    });
+    it('builds activate_tools guidance from the top three inactive results', async () => {
+        const ctx = createCtx({
+            enabledDomains: new Set(['browser', 'network', 'workflow', 'core']),
+        });
+        state.engine.search.mockReturnValue([
+            {
+                name: 'page_navigate',
+                description: 'Navigate page',
+                shortDescription: 'Navigate page',
+                score: 10,
+                domain: 'browser',
+                isActive: false,
+            },
+            {
+                name: 'network_enable',
+                description: 'Enable network',
+                shortDescription: 'Enable network',
+                score: 9,
+                domain: 'network',
+                isActive: false,
+            },
+            {
+                name: 'network_get_requests',
+                description: 'Get requests',
+                shortDescription: 'Get requests',
+                score: 8,
+                domain: 'network',
+                isActive: false,
+            },
+            {
+                name: 'run_extension_workflow',
+                description: 'Run workflow',
+                shortDescription: 'Run workflow',
+                score: 7,
+                domain: 'workflow',
+                isActive: false,
+            },
+        ]);
+        state.describeTool.mockReturnValue({
+            name: 'page_navigate',
+            inputSchema: { type: 'object', properties: { url: { type: 'string' } } },
+        });
+        state.generateExampleArgs.mockReturnValue({ url: 'https://example.com' });
+        const response = parseResponse(await handleSearchTools(ctx, { query: 'inspect' }));
+        expect(response.nextActions).toEqual([
+            {
+                step: 1,
+                action: 'activate_tools',
+                command: 'activate_tools with names: ["page_navigate", "network_enable", "network_get_requests"]',
+                description: 'Activate top 3 result(s)',
+            },
+            {
+                step: 2,
+                action: 'call',
+                command: 'page_navigate',
+                exampleArgs: { url: 'https://example.com' },
+                description: 'Call page_navigate. Use describe_tool("page_navigate") only if you need the full schema.',
+            },
+        ]);
+    });
+    it('auto-activates inactive result domains and re-runs the search with refreshed active names', async () => {
+        const ctx = createCtx();
+        state.activeNames = new Set(['browser_launch']);
+        state.engine.search
+            .mockReturnValueOnce([
+            {
+                name: 'page_navigate',
+                description: 'Navigate page',
+                shortDescription: 'Navigate page',
+                score: 10,
+                domain: 'browser',
+                isActive: false,
+            },
+            {
+                name: 'network_get_requests',
+                description: 'Get requests',
+                shortDescription: 'Get requests',
+                score: 9,
+                domain: 'network',
+                isActive: false,
+            },
+        ])
+            .mockReturnValueOnce([
+            {
+                name: 'page_navigate',
+                description: 'Navigate page',
+                shortDescription: 'Navigate page',
+                score: 10,
+                domain: 'browser',
+                isActive: true,
+            },
+        ]);
+        state.handleActivateDomain.mockImplementation(async (innerCtx, args) => {
+            innerCtx.enabledDomains.add(args.domain);
+            if (args.domain === 'browser')
+                state.activeNames.add('page_navigate');
+            if (args.domain === 'network')
+                state.activeNames.add('network_get_requests');
+            return { content: [{ type: 'text', text: '{"success":true}' }] };
+        });
+        const response = parseResponse(await handleSearchTools(ctx, { query: 'inspect', top_k: 5 }));
+        expect(state.handleActivateDomain).toHaveBeenNthCalledWith(1, ctx, {
+            domain: 'browser',
+            ttlMinutes: 30,
+        });
+        expect(state.handleActivateDomain).toHaveBeenNthCalledWith(2, ctx, {
+            domain: 'network',
+            ttlMinutes: 30,
+        });
+        expect(state.engine.search).toHaveBeenNthCalledWith(1, 'inspect', 5, new Set(['browser_launch']));
+        expect(state.engine.search).toHaveBeenNthCalledWith(2, 'inspect', 5, new Set([
+            'browser_launch',
+            'network_get_requests',
+            'page_navigate',
+        ]));
+        expect(response.autoActivatedDomains).toEqual(['browser', 'network']);
+    });
+    it('warns on activation failures and still keeps successful auto-activations', async () => {
+        const ctx = createCtx();
+        state.engine.search
+            .mockReturnValueOnce([
+            {
+                name: 'page_navigate',
+                description: 'Navigate page',
+                shortDescription: 'Navigate page',
+                score: 10,
+                domain: 'browser',
+                isActive: false,
+            },
+            {
+                name: 'network_get_requests',
+                description: 'Get requests',
+                shortDescription: 'Get requests',
+                score: 9,
+                domain: 'network',
+                isActive: false,
+            },
+        ])
+            .mockReturnValueOnce([
+            {
+                name: 'network_get_requests',
+                description: 'Get requests',
+                shortDescription: 'Get requests',
+                score: 9,
+                domain: 'network',
+                isActive: true,
+            },
+        ]);
+        state.handleActivateDomain.mockImplementation(async (innerCtx, args) => {
+            if (args.domain === 'browser') {
+                throw new Error('browser failed');
+            }
+            innerCtx.enabledDomains.add('network');
+            state.activeNames.add('network_get_requests');
+            return { content: [{ type: 'text', text: '{"success":true}' }] };
+        });
+        const response = parseResponse(await handleSearchTools(ctx, { query: 'inspect' }));
+        expect(response.autoActivatedDomains).toEqual(['network']);
+        expect(state.logger.warn).toHaveBeenCalledWith('[search-auto-activate] Failed to activate domain "browser":', expect.any(Error));
+        expect(state.logger.info).toHaveBeenCalledWith('[search-auto-activate] Activated domain "network" with TTL=30min');
+    });
+    it('skips auto-activation for domains that are already enabled', async () => {
+        const ctx = createCtx({
+            enabledDomains: new Set(['browser']),
+        });
+        state.engine.search.mockReturnValue([
+            {
+                name: 'page_navigate',
+                description: 'Navigate page',
+                shortDescription: 'Navigate page',
+                score: 10,
+                domain: 'browser',
+                isActive: false,
+            },
+        ]);
+        const response = parseResponse(await handleSearchTools(ctx, { query: 'navigate' }));
+        expect(state.handleActivateDomain).not.toHaveBeenCalled();
+        expect(response.autoActivatedDomains).toBeUndefined();
+        expect(state.engine.search).toHaveBeenCalledOnce();
+    });
+    it('returns empty nextActions when no results are found', async () => {
+        const ctx = createCtx();
+        state.engine.search.mockReturnValue([]);
+        const response = parseResponse(await handleSearchTools(ctx, { query: 'missing' }));
+        expect(response).toEqual({
+            query: 'missing',
+            resultCount: 0,
+            results: [],
+            nextActions: [],
+            hint: 'For guided tool discovery with workflow detection, use route_tool instead. ' +
+                'Use activate_tools to enable specific tools, activate_domain for entire domains.',
+        });
+        expect(state.describeTool).not.toHaveBeenCalled();
+        expect(state.generateExampleArgs).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/server/MCPServer.search.helpers.test.d.ts

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