@jshookmcp/jshook 0.1.7 → 0.1.9

package/dist/tests/server/MCPServer.boost.test.js

@@ -0,0 +1,543 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+function createMockRegisteredTool(name, registry) {
+    return {
+        remove: () => {
+            registry.delete(name);
+        },
+        update: vi.fn(),
+        disable: vi.fn(),
+        enable: vi.fn(),
+    };
+}
+function tool(name) {
+    return { name, description: `desc_${name}`, inputSchema: { type: 'object', properties: {} } };
+}
+const mockToolsByProfile = {
+    search: [tool('search_tools'), tool('activate_tools')],
+    workflow: [
+        tool('search_tools'),
+        tool('activate_tools'),
+        tool('browser_launch'),
+        tool('page_navigate'),
+        tool('page_evaluate'),
+        tool('console_execute'),
+        tool('collect_code'),
+        tool('network_enable'),
+        tool('network_get_requests'),
+        tool('debugger_evaluate_global'),
+    ],
+    full: [
+        tool('search_tools'),
+        tool('activate_tools'),
+        tool('browser_launch'),
+        tool('page_navigate'),
+        tool('page_evaluate'),
+        tool('console_execute'),
+        tool('collect_code'),
+        tool('network_enable'),
+        tool('network_get_requests'),
+        tool('debugger_evaluate_global'),
+        tool('page_inject_script'),
+        tool('hook_generate'),
+        tool('process_list'),
+    ],
+};
+vi.mock('@src/server/ToolCatalog', () => ({
+    TIER_ORDER: ['search', 'workflow', 'full'],
+    TIER_DEFAULT_TTL: { search: 0, workflow: 60, full: 30 },
+    getTierIndex: (profile) => ['search', 'workflow', 'full'].indexOf(profile),
+    getToolsForProfile: (profile) => mockToolsByProfile[profile] ?? [],
+    getProfileDomains: () => ['browser', 'core', 'network', 'debugger'],
+    getToolDomain: (_name) => 'browser',
+}));
+vi.mock('@src/server/ToolHandlerMap', () => ({
+    createToolHandlerMap: (_deps, names) => {
+        const map = {};
+        if (names) {
+            for (const name of names) {
+                map[name] = async () => ({ content: [{ type: 'text', text: name }] });
+            }
+        }
+        return map;
+    },
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), success: vi.fn(), setLevel: vi.fn() },
+}));
+import { switchToTier, boostProfile, refreshBoostTtl } from '../../src/server/MCPServer.boost.js';
+describe('switchToTier – activate_tools collision', () => {
+    let sdkRegistry;
+    function createCtx(overrides) {
+        sdkRegistry = new Set();
+        const baseTier = 'search';
+        const baseTools = mockToolsByProfile.search;
+        for (const t of baseTools)
+            sdkRegistry.add(t.name);
+        return {
+            baseTier,
+            currentTier: baseTier,
+            selectedTools: baseTools,
+            enabledDomains: new Set(['maintenance']),
+            boostedToolNames: new Set(),
+            boostedRegisteredTools: new Map(),
+            boostHistory: [],
+            boostTtlTimer: null,
+            boostTtlMinutes: 0,
+            boostLock: Promise.resolve(),
+            activatedToolNames: new Set(),
+            activatedRegisteredTools: new Map(),
+            absorbedFromActivated: new Set(),
+            extensionToolsByName: new Map(),
+            boostedExtensionToolNames: new Set(),
+            router: {
+                addHandlers: vi.fn(),
+                removeHandler: vi.fn(),
+            },
+            handlerDeps: {},
+            server: {
+                sendToolListChanged: vi.fn(async () => undefined),
+                registerTool: vi.fn(),
+            },
+            resolveEnabledDomains: vi.fn(() => new Set(['maintenance'])),
+            registerSingleTool: vi.fn((toolDef) => {
+                if (sdkRegistry.has(toolDef.name)) {
+                    throw new Error(`Tool ${toolDef.name} is already registered`);
+                }
+                sdkRegistry.add(toolDef.name);
+                return createMockRegisteredTool(toolDef.name, sdkRegistry);
+            }),
+            ...overrides,
+        };
+    }
+    it('reproduces original bug: boost fails when activated tools conflict (before fix)', async () => {
+        const ctx = createCtx();
+        for (const name of ['collect_code', 'browser_launch']) {
+            sdkRegistry.add(name);
+            const rt = createMockRegisteredTool(name, sdkRegistry);
+            ctx.activatedToolNames.add(name);
+            ctx.activatedRegisteredTools.set(name, rt);
+        }
+        await expect(switchToTier(ctx, 'full')).resolves.not.toThrow();
+    });
+    it('absorbs activated tools into boost set on tier switch', async () => {
+        const ctx = createCtx();
+        sdkRegistry.add('collect_code');
+        const rt = createMockRegisteredTool('collect_code', sdkRegistry);
+        ctx.activatedToolNames.add('collect_code');
+        ctx.activatedRegisteredTools.set('collect_code', rt);
+        await switchToTier(ctx, 'full');
+        expect(ctx.activatedToolNames.has('collect_code')).toBe(false);
+        expect(ctx.activatedRegisteredTools.has('collect_code')).toBe(false);
+        expect(ctx.boostedToolNames.has('collect_code')).toBe(true);
+        expect(ctx.boostedRegisteredTools.has('collect_code')).toBe(true);
+    });
+    it('registers all non-conflicting tools from target tier', async () => {
+        const ctx = createCtx();
+        sdkRegistry.add('collect_code');
+        const rt = createMockRegisteredTool('collect_code', sdkRegistry);
+        ctx.activatedToolNames.add('collect_code');
+        ctx.activatedRegisteredTools.set('collect_code', rt);
+        await switchToTier(ctx, 'full');
+        const fullMinusBase = mockToolsByProfile.full.filter((t) => !mockToolsByProfile.search.some((b) => b.name === t.name));
+        for (const t of fullMinusBase) {
+            expect(ctx.boostedToolNames.has(t.name)).toBe(true);
+        }
+    });
+    it('rolls back on unexpected registration failure', async () => {
+        const ctx = createCtx();
+        let callCount = 0;
+        ctx.registerSingleTool = vi.fn((toolDef) => {
+            callCount++;
+            if (callCount > 3) {
+                throw new Error(`Simulated failure at tool ${toolDef.name}`);
+            }
+            sdkRegistry.add(toolDef.name);
+            return createMockRegisteredTool(toolDef.name, sdkRegistry);
+        });
+        await expect(switchToTier(ctx, 'full')).rejects.toThrow('Simulated failure');
+        expect(ctx.boostedToolNames.size).toBe(0);
+        expect(ctx.boostedRegisteredTools.size).toBe(0);
+        for (const name of sdkRegistry) {
+            const isBase = mockToolsByProfile.search.some((t) => t.name === name);
+            expect(isBase).toBe(true);
+        }
+    });
+    it('handlers are NOT added when registration fails (no orphaned tools)', async () => {
+        const ctx = createCtx();
+        let callCount = 0;
+        ctx.registerSingleTool = vi.fn((toolDef) => {
+            callCount++;
+            if (callCount > 2)
+                throw new Error('boom');
+            sdkRegistry.add(toolDef.name);
+            return createMockRegisteredTool(toolDef.name, sdkRegistry);
+        });
+        await expect(switchToTier(ctx, 'full')).rejects.toThrow('boom');
+        expect(ctx.router.addHandlers).not.toHaveBeenCalled();
+    });
+    it('absorbed activated tools are restored on rollback', async () => {
+        const ctx = createCtx();
+        sdkRegistry.add('collect_code');
+        const rt = createMockRegisteredTool('collect_code', sdkRegistry);
+        ctx.activatedToolNames.add('collect_code');
+        ctx.activatedRegisteredTools.set('collect_code', rt);
+        let callCount = 0;
+        ctx.registerSingleTool = vi.fn((toolDef) => {
+            callCount++;
+            if (callCount > 2)
+                throw new Error('late failure');
+            sdkRegistry.add(toolDef.name);
+            return createMockRegisteredTool(toolDef.name, sdkRegistry);
+        });
+        await expect(switchToTier(ctx, 'full')).rejects.toThrow('late failure');
+        expect(ctx.activatedToolNames.has('collect_code')).toBe(true);
+        expect(ctx.boostedToolNames.has('collect_code')).toBe(false);
+    });
+    it('clean boost with no activated tools works normally', async () => {
+        const ctx = createCtx();
+        await switchToTier(ctx, 'full');
+        const fullMinusBase = mockToolsByProfile.full.filter((t) => !mockToolsByProfile.search.some((b) => b.name === t.name));
+        expect(ctx.boostedToolNames.size).toBe(fullMinusBase.length);
+        expect(ctx.router.addHandlers).toHaveBeenCalledOnce();
+    });
+    it('switching to base tier clears all boosted tools', async () => {
+        const ctx = createCtx();
+        await switchToTier(ctx, 'full');
+        expect(ctx.boostedToolNames.size).toBeGreaterThan(0);
+        await switchToTier(ctx, 'search');
+        expect(ctx.boostedToolNames.size).toBe(0);
+        expect(ctx.boostedRegisteredTools.size).toBe(0);
+    });
+});
+describe('switchToTier – search→workflow browser tool scenarios', () => {
+    let sdkRegistry;
+    let routerHandlers;
+    function createCtx(overrides) {
+        sdkRegistry = new Set();
+        routerHandlers = new Map();
+        const baseTier = 'search';
+        const baseTools = mockToolsByProfile.search;
+        for (const t of baseTools)
+            sdkRegistry.add(t.name);
+        return {
+            baseTier,
+            currentTier: baseTier,
+            selectedTools: baseTools,
+            enabledDomains: new Set(['maintenance']),
+            boostedToolNames: new Set(),
+            boostedRegisteredTools: new Map(),
+            boostHistory: [],
+            boostTtlTimer: null,
+            boostTtlMinutes: 0,
+            boostLock: Promise.resolve(),
+            activatedToolNames: new Set(),
+            activatedRegisteredTools: new Map(),
+            absorbedFromActivated: new Set(),
+            extensionToolsByName: new Map(),
+            boostedExtensionToolNames: new Set(),
+            router: {
+                addHandlers: vi.fn((handlers) => {
+                    for (const [name, handler] of Object.entries(handlers)) {
+                        routerHandlers.set(name, handler);
+                    }
+                }),
+                removeHandler: vi.fn((name) => {
+                    routerHandlers.delete(name);
+                }),
+                has: vi.fn((name) => routerHandlers.has(name)),
+            },
+            handlerDeps: {},
+            server: {
+                sendToolListChanged: vi.fn(async () => undefined),
+                registerTool: vi.fn(),
+            },
+            resolveEnabledDomains: vi.fn(() => new Set(['maintenance'])),
+            registerSingleTool: vi.fn((toolDef) => {
+                if (sdkRegistry.has(toolDef.name)) {
+                    throw new Error(`Tool ${toolDef.name} is already registered`);
+                }
+                sdkRegistry.add(toolDef.name);
+                return createMockRegisteredTool(toolDef.name, sdkRegistry);
+            }),
+            ...overrides,
+        };
+    }
+    it('pure search→workflow boost registers all browser tools', async () => {
+        const ctx = createCtx();
+        await switchToTier(ctx, 'workflow');
+        const workflowMinusBase = mockToolsByProfile.workflow.filter((t) => !mockToolsByProfile.search.some((b) => b.name === t.name));
+        for (const t of workflowMinusBase) {
+            expect(ctx.boostedToolNames.has(t.name)).toBe(true);
+        }
+        expect(ctx.boostedToolNames.has('browser_launch')).toBe(true);
+        expect(ctx.boostedToolNames.has('page_navigate')).toBe(true);
+        expect(ctx.boostedToolNames.has('page_evaluate')).toBe(true);
+        expect(routerHandlers.has('browser_launch')).toBe(true);
+        expect(routerHandlers.has('page_navigate')).toBe(true);
+        expect(ctx.enabledDomains.has('browser')).toBe(true);
+        expect(ctx.enabledDomains.has('core')).toBe(true);
+    });
+    it('search→workflow with prior activated browser tools: absorbed tools keep handlers', async () => {
+        const ctx = createCtx();
+        sdkRegistry.add('browser_launch');
+        const rt = createMockRegisteredTool('browser_launch', sdkRegistry);
+        ctx.activatedToolNames.add('browser_launch');
+        ctx.activatedRegisteredTools.set('browser_launch', rt);
+        routerHandlers.set('browser_launch', async () => 'activated_handler');
+        await switchToTier(ctx, 'workflow');
+        expect(ctx.activatedToolNames.has('browser_launch')).toBe(false);
+        expect(ctx.boostedToolNames.has('browser_launch')).toBe(true);
+        expect(routerHandlers.has('browser_launch')).toBe(true);
+        expect(ctx.boostedToolNames.has('page_navigate')).toBe(true);
+        expect(routerHandlers.has('page_navigate')).toBe(true);
+    });
+    it('FIX: activated browser tools restored after boost→unboost cycle', async () => {
+        const ctx = createCtx();
+        sdkRegistry.add('browser_launch');
+        const rt = createMockRegisteredTool('browser_launch', sdkRegistry);
+        ctx.activatedToolNames.add('browser_launch');
+        ctx.activatedRegisteredTools.set('browser_launch', rt);
+        routerHandlers.set('browser_launch', async () => 'activated_handler');
+        await switchToTier(ctx, 'workflow');
+        expect(ctx.boostedToolNames.has('browser_launch')).toBe(true);
+        expect(ctx.activatedToolNames.has('browser_launch')).toBe(false);
+        expect(ctx.absorbedFromActivated.has('browser_launch')).toBe(true);
+        await switchToTier(ctx, 'search');
+        expect(ctx.boostedToolNames.has('browser_launch')).toBe(false);
+        expect(ctx.activatedToolNames.has('browser_launch')).toBe(true);
+        expect(ctx.activatedRegisteredTools.has('browser_launch')).toBe(true);
+        expect(sdkRegistry.has('browser_launch')).toBe(true);
+        expect(routerHandlers.has('browser_launch')).toBe(true);
+    });
+    it('search→workflow boost does NOT absorb extension tools (not in target profile)', async () => {
+        const ctx = createCtx();
+        sdkRegistry.add('my_extension_tool');
+        const rt = createMockRegisteredTool('my_extension_tool', sdkRegistry);
+        ctx.activatedToolNames.add('my_extension_tool');
+        ctx.activatedRegisteredTools.set('my_extension_tool', rt);
+        routerHandlers.set('my_extension_tool', async () => 'extension_handler');
+        await switchToTier(ctx, 'workflow');
+        expect(ctx.activatedToolNames.has('my_extension_tool')).toBe(true);
+        expect(ctx.activatedRegisteredTools.has('my_extension_tool')).toBe(true);
+        expect(routerHandlers.has('my_extension_tool')).toBe(true);
+    });
+    it('enabledDomains includes browser after search→workflow boost', async () => {
+        const ctx = createCtx();
+        expect(ctx.enabledDomains.has('browser')).toBe(false);
+        await switchToTier(ctx, 'workflow');
+        expect(ctx.enabledDomains.has('browser')).toBe(true);
+        expect(ctx.enabledDomains.has('core')).toBe(true);
+        expect(ctx.enabledDomains.has('network')).toBe(true);
+        expect(ctx.enabledDomains.has('debugger')).toBe(true);
+    });
+    it('enabledDomains includes activated tool domains after unboost', async () => {
+        const ctx = createCtx();
+        sdkRegistry.add('browser_launch');
+        const rt = createMockRegisteredTool('browser_launch', sdkRegistry);
+        ctx.activatedToolNames.add('browser_launch');
+        ctx.activatedRegisteredTools.set('browser_launch', rt);
+        routerHandlers.set('browser_launch', async () => 'handler');
+        await switchToTier(ctx, 'workflow');
+        await switchToTier(ctx, 'search');
+        expect(ctx.enabledDomains.has('browser')).toBe(true);
+    });
+});
+describe('refreshBoostTtl', () => {
+    let sdkRegistry;
+    function createCtx(overrides) {
+        sdkRegistry = new Set();
+        const baseTier = 'search';
+        const baseTools = mockToolsByProfile.search;
+        for (const t of baseTools)
+            sdkRegistry.add(t.name);
+        return {
+            baseTier,
+            currentTier: baseTier,
+            selectedTools: baseTools,
+            enabledDomains: new Set(['maintenance']),
+            boostedToolNames: new Set(),
+            boostedRegisteredTools: new Map(),
+            boostHistory: [],
+            boostTtlTimer: null,
+            boostTtlMinutes: 0,
+            boostLock: Promise.resolve(),
+            activatedToolNames: new Set(),
+            activatedRegisteredTools: new Map(),
+            absorbedFromActivated: new Set(),
+            extensionToolsByName: new Map(),
+            boostedExtensionToolNames: new Set(),
+            router: {
+                addHandlers: vi.fn(),
+                removeHandler: vi.fn(),
+            },
+            handlerDeps: {},
+            server: {
+                sendToolListChanged: vi.fn(async () => undefined),
+                registerTool: vi.fn(),
+            },
+            resolveEnabledDomains: vi.fn(() => new Set(['maintenance'])),
+            registerSingleTool: vi.fn((toolDef) => {
+                if (sdkRegistry.has(toolDef.name)) {
+                    throw new Error(`Tool ${toolDef.name} is already registered`);
+                }
+                sdkRegistry.add(toolDef.name);
+                return createMockRegisteredTool(toolDef.name, sdkRegistry);
+            }),
+            ...overrides,
+        };
+    }
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('refreshBoostTtl resets the TTL timer', () => {
+        const ctx = createCtx();
+        ctx.currentTier = 'workflow';
+        ctx.boostTtlMinutes = 60;
+        ctx.boostedToolNames.add('collect_code');
+        refreshBoostTtl(ctx);
+        expect(ctx.boostTtlTimer).not.toBeNull();
+        const firstTimer = ctx.boostTtlTimer;
+        vi.advanceTimersByTime(30 * 60 * 1000);
+        refreshBoostTtl(ctx);
+        expect(ctx.boostTtlTimer).not.toBeNull();
+        expect(ctx.boostTtlTimer).not.toBe(firstTimer);
+    });
+    it('refreshBoostTtl does nothing when TTL is disabled', () => {
+        const ctx = createCtx();
+        ctx.currentTier = 'workflow';
+        ctx.boostTtlMinutes = 0;
+        refreshBoostTtl(ctx);
+        expect(ctx.boostTtlTimer).toBeNull();
+    });
+    it('refreshBoostTtl does nothing at base tier', () => {
+        const ctx = createCtx();
+        ctx.boostTtlMinutes = 60;
+        refreshBoostTtl(ctx);
+        expect(ctx.boostTtlTimer).toBeNull();
+    });
+    it('boostProfileInner stores ttlMinutes on context', async () => {
+        const ctx = createCtx();
+        await boostProfile(ctx, 'workflow', 45);
+        expect(ctx.boostTtlMinutes).toBe(45);
+    });
+});
+describe('extension tool boost tier management', () => {
+    let sdkRegistry;
+    let routerHandlers;
+    function createCtx(overrides) {
+        sdkRegistry = new Set();
+        routerHandlers = new Map();
+        const baseTier = 'search';
+        const baseTools = mockToolsByProfile.search;
+        for (const t of baseTools)
+            sdkRegistry.add(t.name);
+        return {
+            baseTier,
+            currentTier: baseTier,
+            selectedTools: baseTools,
+            enabledDomains: new Set(['maintenance']),
+            boostedToolNames: new Set(),
+            boostedRegisteredTools: new Map(),
+            boostHistory: [],
+            boostTtlTimer: null,
+            boostTtlMinutes: 0,
+            boostLock: Promise.resolve(),
+            activatedToolNames: new Set(),
+            activatedRegisteredTools: new Map(),
+            absorbedFromActivated: new Set(),
+            extensionToolsByName: new Map(),
+            boostedExtensionToolNames: new Set(),
+            router: {
+                addHandlers: vi.fn((handlers) => {
+                    for (const [k, v] of Object.entries(handlers))
+                        routerHandlers.set(k, v);
+                }),
+                removeHandler: vi.fn((name) => {
+                    routerHandlers.delete(name);
+                }),
+            },
+            handlerDeps: {},
+            server: {
+                sendToolListChanged: vi.fn(async () => undefined),
+                registerTool: vi.fn(),
+            },
+            resolveEnabledDomains: vi.fn(() => new Set(['maintenance'])),
+            registerSingleTool: vi.fn((toolDef) => {
+                if (sdkRegistry.has(toolDef.name)) {
+                    throw new Error(`Tool ${toolDef.name} is already registered`);
+                }
+                sdkRegistry.add(toolDef.name);
+                return createMockRegisteredTool(toolDef.name, sdkRegistry);
+            }),
+            ...overrides,
+        };
+    }
+    it('deferred extension tools are auto-registered when boosting to their tier', async () => {
+        const ctx = createCtx();
+        const mockHandler = vi.fn();
+        ctx.extensionToolsByName.set('ext_tool_a', {
+            name: 'ext_tool_a',
+            domain: 'external',
+            source: 'test-plugin',
+            tool: tool('ext_tool_a'),
+            boostTier: 'workflow',
+            handler: mockHandler,
+        });
+        await switchToTier(ctx, 'workflow');
+        expect(ctx.boostedExtensionToolNames.has('ext_tool_a')).toBe(true);
+        expect(sdkRegistry.has('ext_tool_a')).toBe(true);
+        expect(routerHandlers.has('ext_tool_a')).toBe(true);
+    });
+    it('boost-registered extension tools are deregistered on unboost', async () => {
+        const ctx = createCtx();
+        const mockHandler = vi.fn();
+        ctx.extensionToolsByName.set('ext_tool_b', {
+            name: 'ext_tool_b',
+            domain: 'external',
+            source: 'test-plugin',
+            tool: tool('ext_tool_b'),
+            boostTier: 'workflow',
+            handler: mockHandler,
+        });
+        await switchToTier(ctx, 'workflow');
+        expect(ctx.boostedExtensionToolNames.has('ext_tool_b')).toBe(true);
+        await switchToTier(ctx, 'search');
+        expect(ctx.boostedExtensionToolNames.has('ext_tool_b')).toBe(false);
+        expect(sdkRegistry.has('ext_tool_b')).toBe(false);
+    });
+    it('extension tools with boostTier=full are NOT registered at workflow tier', async () => {
+        const ctx = createCtx();
+        ctx.extensionToolsByName.set('ext_tool_full', {
+            name: 'ext_tool_full',
+            domain: 'external',
+            source: 'test-plugin',
+            tool: tool('ext_tool_full'),
+            boostTier: 'full',
+            handler: vi.fn(),
+        });
+        await switchToTier(ctx, 'workflow');
+        expect(ctx.boostedExtensionToolNames.has('ext_tool_full')).toBe(false);
+        expect(sdkRegistry.has('ext_tool_full')).toBe(false);
+    });
+    it('manually activated extension tools are not re-registered by boost', async () => {
+        const ctx = createCtx();
+        sdkRegistry.add('ext_tool_manual');
+        const rt = createMockRegisteredTool('ext_tool_manual', sdkRegistry);
+        ctx.activatedToolNames.add('ext_tool_manual');
+        ctx.activatedRegisteredTools.set('ext_tool_manual', rt);
+        ctx.extensionToolsByName.set('ext_tool_manual', {
+            name: 'ext_tool_manual',
+            domain: 'external',
+            source: 'test-plugin',
+            tool: tool('ext_tool_manual'),
+            registeredTool: rt,
+            boostTier: 'workflow',
+            handler: vi.fn(),
+        });
+        await switchToTier(ctx, 'workflow');
+        expect(ctx.boostedExtensionToolNames.has('ext_tool_manual')).toBe(false);
+    });
+});

package/dist/tests/server/MCPServer.schema.test.d.ts

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

package/dist/tests/server/MCPServer.schema.test.js

@@ -0,0 +1,124 @@
+import { describe, it, expect } from 'vitest';
+import { buildZodShape } from '../../src/server/MCPServer.schema.js';
+describe('MCPServer.schema – buildZodShape', () => {
+    it('converts basic string property', () => {
+        const shape = buildZodShape({
+            properties: {
+                name: { type: 'string', description: 'The name' },
+            },
+            required: ['name'],
+        });
+        expect(shape.name).toBeDefined();
+        const result = shape.name.safeParse('hello');
+        expect(result.success).toBe(true);
+    });
+    it('converts string enum property', () => {
+        const shape = buildZodShape({
+            properties: {
+                mode: { type: 'string', enum: ['fast', 'slow'] },
+            },
+        });
+        const valid = shape.mode.safeParse('fast');
+        expect(valid.success).toBe(true);
+        const invalid = shape.mode.safeParse('medium');
+        expect(invalid.success).toBe(false);
+    });
+    it('converts number with min/max constraints', () => {
+        const shape = buildZodShape({
+            properties: {
+                count: { type: 'number', minimum: 1, maximum: 100 },
+            },
+            required: ['count'],
+        });
+        expect(shape.count.safeParse(50).success).toBe(true);
+        expect(shape.count.safeParse(0).success).toBe(false);
+        expect(shape.count.safeParse(101).success).toBe(false);
+    });
+    it('converts integer type', () => {
+        const shape = buildZodShape({
+            properties: {
+                port: { type: 'integer', minimum: 1, maximum: 65535 },
+            },
+            required: ['port'],
+        });
+        expect(shape.port.safeParse(8080).success).toBe(true);
+        expect(shape.port.safeParse(3.14).success).toBe(false);
+    });
+    it('converts boolean property', () => {
+        const shape = buildZodShape({
+            properties: {
+                enabled: { type: 'boolean' },
+            },
+        });
+        expect(shape.enabled.safeParse(true).success).toBe(true);
+        expect(shape.enabled.safeParse('yes').success).toBe(false);
+    });
+    it('converts array of strings', () => {
+        const shape = buildZodShape({
+            properties: {
+                tags: { type: 'array', items: { type: 'string' } },
+            },
+        });
+        expect(shape.tags.safeParse(['a', 'b']).success).toBe(true);
+        expect(shape.tags.safeParse('not-array').success).toBe(false);
+    });
+    it('converts nested object', () => {
+        const shape = buildZodShape({
+            properties: {
+                config: {
+                    type: 'object',
+                    properties: {
+                        host: { type: 'string' },
+                        port: { type: 'number' },
+                    },
+                    required: ['host'],
+                },
+            },
+        });
+        expect(shape.config.safeParse({ host: 'localhost' }).success).toBe(true);
+        expect(shape.config.safeParse({ port: 3000 }).success).toBe(false);
+    });
+    it('marks required vs optional fields correctly', () => {
+        const shape = buildZodShape({
+            properties: {
+                required_field: { type: 'string' },
+                optional_field: { type: 'string' },
+            },
+            required: ['required_field'],
+        });
+        expect(shape.required_field.safeParse(undefined).success).toBe(false);
+        expect(shape.optional_field.safeParse(undefined).success).toBe(true);
+    });
+    it('handles string with pattern constraint', () => {
+        const shape = buildZodShape({
+            properties: {
+                hex: { type: 'string', pattern: '^[0-9a-f]+$' },
+            },
+        });
+        expect(shape.hex.safeParse('deadbeef').success).toBe(true);
+        expect(shape.hex.safeParse('xyz').success).toBe(false);
+    });
+    it('preserves description on generated zod type', () => {
+        const shape = buildZodShape({
+            properties: {
+                url: { type: 'string', description: 'Target URL to navigate to' },
+            },
+            required: ['url'],
+        });
+        expect(shape.url).toBeDefined();
+        expect(shape.url.description).toBe('Target URL to navigate to');
+    });
+    it('handles empty schema gracefully', () => {
+        const shape = buildZodShape({});
+        expect(Object.keys(shape).length).toBe(0);
+    });
+    it('handles unknown type as z.unknown', () => {
+        const shape = buildZodShape({
+            properties: {
+                weird: { type: 'custom_type' },
+            },
+        });
+        expect(shape.weird.safeParse('anything').success).toBe(true);
+        expect(shape.weird.safeParse(42).success).toBe(true);
+    });
+});

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

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