@jshookmcp/jshook 0.1.8 → 0.1.9

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

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

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

@@ -0,0 +1,218 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(() => {
+    return {
+        mcpInstances: [],
+        getToolsForProfile: vi.fn(),
+        getToolsByDomains: vi.fn(),
+        parseToolDomains: vi.fn(),
+        getToolDomain: vi.fn(),
+        getProfileDomains: vi.fn(),
+        createToolHandlerMap: vi.fn(),
+        allManifests: [],
+        tokenBudget: {
+            recordToolCall: vi.fn(),
+            setTrackingEnabled: vi.fn(),
+        },
+        cacheInit: vi.fn(async () => undefined),
+        detailedShutdown: vi.fn(),
+    };
+});
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => {
+    class BaseMockMcpServer {
+        constructor(..._args) { }
+        tools = [];
+        connect = vi.fn(async () => undefined);
+        close = vi.fn(async () => undefined);
+        sendToolListChanged = vi.fn(async () => undefined);
+        tool(...args) {
+            const name = args[0];
+            const handler = args.at(-1);
+            this.tools.push({ name, handler });
+            return { remove: vi.fn() };
+        }
+        registerTool(name, _config, handler) {
+            this.tools.push({ name, handler });
+            return { remove: vi.fn() };
+        }
+    }
+    return {
+        McpServer: class extends BaseMockMcpServer {
+            constructor(...args) {
+                super(...args);
+                mocks.mcpInstances.push(this);
+            }
+        },
+    };
+});
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
+    StdioServerTransport: class StdioServerTransport {
+    },
+}));
+vi.mock('@modelcontextprotocol/sdk/server/streamableHttp.js', () => ({
+    StreamableHTTPServerTransport: class StreamableHTTPServerTransport {
+        handleRequest = vi.fn();
+    },
+}));
+vi.mock('@src/utils/cache', () => ({
+    CacheManager: class CacheManager {
+        init = mocks.cacheInit;
+    },
+}));
+vi.mock('@src/utils/TokenBudgetManager', () => ({
+    TokenBudgetManager: class {
+        recordToolCall = mocks.tokenBudget.recordToolCall;
+        setTrackingEnabled = mocks.tokenBudget.setTrackingEnabled;
+        setExternalCleanup = vi.fn();
+        getStats = vi.fn(() => ({ usagePercentage: 0, currentUsage: 0, maxTokens: 200000 }));
+        static getInstance = () => mocks.tokenBudget;
+    },
+}));
+vi.mock('@src/utils/UnifiedCacheManager', () => ({
+    UnifiedCacheManager: class {
+        registerCache = vi.fn();
+        static getInstance = () => ({ registerCache: vi.fn() });
+    },
+}));
+vi.mock('@src/utils/DetailedDataManager', () => ({
+    DetailedDataManager: class {
+        shutdown = mocks.detailedShutdown;
+        clear = vi.fn();
+        static getInstance = () => ({ shutdown: mocks.detailedShutdown, clear: vi.fn() });
+    },
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+        setLevel: vi.fn(),
+    },
+}));
+vi.mock('@src/server/ToolCatalog', () => ({
+    getToolsForProfile: mocks.getToolsForProfile,
+    getToolsByDomains: mocks.getToolsByDomains,
+    parseToolDomains: mocks.parseToolDomains,
+    getToolDomain: mocks.getToolDomain,
+    getProfileDomains: mocks.getProfileDomains,
+}));
+vi.mock('@src/server/ToolHandlerMap', () => ({
+    createToolHandlerMap: mocks.createToolHandlerMap,
+}));
+vi.mock('@src/server/registry/index', () => ({
+    ALL_MANIFESTS: mocks.allManifests,
+    ALL_REGISTRATIONS: [],
+    ALL_DOMAINS: new Set(),
+    ALL_TOOL_NAMES: new Set(),
+    getAllManifests: () => mocks.allManifests,
+    getAllRegistrations: () => [],
+    getAllDomains: () => new Set(),
+    getAllToolNames: () => new Set(),
+    initRegistry: async () => { },
+    buildToolGroups: () => ({}),
+    buildToolDomainMap: () => new Map(),
+    buildAllTools: () => [],
+    buildProfileDomains: () => ({ search: [], workflow: [], full: [] }),
+    buildHandlerMapFromRegistry: () => ({}),
+}));
+import { MCPServer } from '../../src/server/MCPServer.js';
+describe('MCPServer', () => {
+    const baseConfig = {
+        llm: {
+            provider: 'primary-provider',
+            primary: { apiKey: '', model: 'x' },
+            secondary: { apiKey: '', model: 'y' },
+        },
+        puppeteer: { headless: true, timeout: 1000 },
+        mcp: { name: 'test-server', version: '1.0.0' },
+        cache: { enabled: true, dir: '.cache', ttl: 60 },
+        performance: { maxConcurrentAnalysis: 1, maxCodeSizeMB: 1 },
+    };
+    beforeEach(() => {
+        mocks.mcpInstances.length = 0;
+        mocks.allManifests.length = 0;
+        vi.clearAllMocks();
+        process.env.MCP_TRANSPORT = 'stdio';
+        delete process.env.MCP_TOOL_PROFILE;
+        delete process.env.MCP_TOOL_DOMAINS;
+        mocks.parseToolDomains.mockImplementation((raw) => (raw ? ['browser'] : null));
+        mocks.getToolsForProfile.mockReturnValue([
+            { name: 'tool_alpha', description: 'alpha', inputSchema: { properties: { x: {} } } },
+            { name: 'tool_beta', description: 'beta', inputSchema: {} },
+        ]);
+        mocks.getToolsByDomains.mockReturnValue([
+            { name: 'domain_tool', description: 'domain', inputSchema: {} },
+        ]);
+        mocks.getToolDomain.mockReturnValue('browser');
+        mocks.getProfileDomains.mockReturnValue(['browser']);
+        mocks.createToolHandlerMap.mockReturnValue({
+            tool_alpha: vi.fn(async (args) => ({
+                content: [{ type: 'text', text: `alpha:${JSON.stringify(args)}` }],
+            })),
+            tool_beta: vi.fn(async () => ({ content: [{ type: 'text', text: 'beta' }] })),
+            domain_tool: vi.fn(async () => ({ content: [{ type: 'text', text: 'domain' }] })),
+        });
+    });
+    afterEach(() => {
+        delete process.env.MCP_TRANSPORT;
+        delete process.env.MCP_TOOL_PROFILE;
+        delete process.env.MCP_TOOL_DOMAINS;
+    });
+    it('registers selected tools plus meta tools on construction', () => {
+        new MCPServer(baseConfig);
+        const mcp = mocks.mcpInstances[0];
+        const names = mcp.tools.map((t) => t.name);
+        expect(names).toContain('tool_alpha');
+        expect(names).toContain('tool_beta');
+        expect(names).toContain('boost_profile');
+        expect(names).toContain('unboost_profile');
+    });
+    it('resolves tool profile from environment when explicitly provided', () => {
+        process.env.MCP_TOOL_PROFILE = 'full';
+        new MCPServer(baseConfig);
+        expect(mocks.getToolsForProfile).toHaveBeenCalledWith('full');
+    });
+    it('registers maintenance secondary handler deps for extension management', () => {
+        mocks.allManifests.push({
+            domain: 'maintenance',
+            depKey: 'coreMaintenanceHandlers',
+            ensure: vi.fn(() => ({ handleGetTokenBudgetStats: vi.fn() })),
+        }, {
+            domain: 'hooks',
+            depKey: 'aiHookHandlers',
+            ensure: vi.fn(() => ({})),
+        });
+        const server = new MCPServer(baseConfig);
+        expect(server.handlerDeps).toHaveProperty('extensionManagementHandlers');
+        expect(server.handlerDeps).toHaveProperty('hookPresetHandlers');
+    });
+    it('starts with stdio transport by default and initializes cache', async () => {
+        const server = new MCPServer(baseConfig);
+        await server.start();
+        const mcp = mocks.mcpInstances[0];
+        expect(mocks.cacheInit).toHaveBeenCalledOnce();
+        expect(mcp.connect).toHaveBeenCalledOnce();
+    });
+    it('enterDegradedMode disables tracking only once', () => {
+        const server = new MCPServer(baseConfig);
+        server.enterDegradedMode('first issue');
+        server.enterDegradedMode('second issue');
+        expect(mocks.tokenBudget.setTrackingEnabled).toHaveBeenCalledTimes(1);
+        expect(mocks.tokenBudget.setTrackingEnabled).toHaveBeenCalledWith(false);
+    });
+    it('registered tool execution records token usage', async () => {
+        new MCPServer(baseConfig);
+        const mcp = mocks.mcpInstances[0];
+        const alpha = mcp.tools.find((t) => t.name === 'tool_alpha');
+        const response = await alpha.handler({ x: 7 });
+        expect(response.content[0].text).toContain('alpha');
+        expect(mocks.tokenBudget.recordToolCall).toHaveBeenCalledWith('tool_alpha', { x: 7 }, response);
+    });
+    it('close shuts down detailed manager and mcp server', async () => {
+        const server = new MCPServer(baseConfig);
+        await server.close();
+        const mcp = mocks.mcpInstances[0];
+        expect(mocks.detailedShutdown).toHaveBeenCalledOnce();
+        expect(mcp.close).toHaveBeenCalledOnce();
+    });
+});

package/dist/tests/server/ToolCallContextGuard.test.d.ts

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

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

@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    },
+}));
+import { ToolCallContextGuard } from '../../src/server/ToolCallContextGuard.js';
+function makeResponse(text, isError = false) {
+    return {
+        isError,
+        content: [{ type: 'text', text }],
+    };
+}
+describe('ToolCallContextGuard', () => {
+    const meta = {
+        url: 'https://vmoranv.github.io/jshookmcp/app',
+        title: 'Example App',
+        tabIndex: 2,
+        pageId: 'page-2',
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('injects tab context into compact JSON responses for context-sensitive tools', () => {
+        const guard = new ToolCallContextGuard(() => ({
+            getContextMeta: () => meta,
+        }));
+        const response = makeResponse('{"success":true}');
+        const enriched = guard.enrichResponse('page_navigate', response);
+        const parsed = JSON.parse(enriched.content[0].text);
+        expect(parsed).toMatchObject({
+            success: true,
+            _tabContext: meta,
+        });
+    });
+    it('injects tab context into pretty JSON responses without breaking parsing', () => {
+        const guard = new ToolCallContextGuard(() => ({
+            getContextMeta: () => meta,
+        }));
+        const response = makeResponse(JSON.stringify({
+            success: true,
+            process: { pid: 1234 },
+        }, null, 2));
+        const enriched = guard.enrichResponse('network_get_requests', response);
+        const parsed = JSON.parse(enriched.content[0].text);
+        expect(enriched.content[0].text).toContain('\n  "_tabContext":');
+        expect(parsed._tabContext).toEqual(meta);
+        expect(parsed.process.pid).toBe(1234);
+    });
+    it('skips enrichment for non-context-sensitive tools', () => {
+        const guard = new ToolCallContextGuard(() => ({
+            getContextMeta: () => meta,
+        }));
+        const response = makeResponse('{"success":true}');
+        const enriched = guard.enrichResponse('activate_tools', response);
+        expect(enriched.content[0].text).toBe('{"success":true}');
+    });
+    it('skips enrichment when the response is an error or there is no active page context', () => {
+        const guard = new ToolCallContextGuard(() => ({
+            getContextMeta: () => ({
+                url: null,
+                title: null,
+                tabIndex: null,
+                pageId: null,
+            }),
+        }));
+        const errorResponse = makeResponse('{"success":false}', true);
+        const noPageResponse = makeResponse('{"success":true}');
+        expect(guard.enrichResponse('page_evaluate', errorResponse).content[0].text).toBe('{"success":false}');
+        expect(guard.enrichResponse('page_evaluate', noPageResponse).content[0].text).toBe('{"success":true}');
+    });
+    it('skips enrichment when there is no provider', () => {
+        const guard = new ToolCallContextGuard(() => null);
+        const response = makeResponse('{"success":true}');
+        expect(guard.enrichResponse('page_evaluate', response).content[0].text).toBe('{"success":true}');
+    });
+    it('skips enrichment when content is not a text array entry', () => {
+        const guard = new ToolCallContextGuard(() => ({
+            getContextMeta: () => meta,
+        }));
+        const nonArray = { isError: false, content: { type: 'text', text: '{}' } };
+        const nonText = {
+            isError: false,
+            content: [{ type: 'image', url: 'https://vmoranv.github.io/jshookmcp/a.png' }, { type: 'text', text: 123 }],
+        };
+        expect(guard.enrichResponse('page_evaluate', nonArray).content).toEqual(nonArray.content);
+        expect(guard.enrichResponse('page_evaluate', nonText).content).toEqual(nonText.content);
+    });
+    it('injects tab context into the smallest JSON object payload', () => {
+        const guard = new ToolCallContextGuard(() => ({
+            getContextMeta: () => meta,
+        }));
+        const response = makeResponse('{}');
+        const enriched = guard.enrichResponse('console_execute', response);
+        const parsed = JSON.parse(enriched.content[0].text);
+        expect(parsed._tabContext).toEqual(meta);
+    });
+    it('leaves malformed or non-object JSON payloads unchanged', () => {
+        const guard = new ToolCallContextGuard(() => ({
+            getContextMeta: () => meta,
+        }));
+        const malformed = makeResponse('{not-valid-json}');
+        const arrayPayload = makeResponse('[{"success":true}]');
+        const plainText = makeResponse('not json at all');
+        const stringPayload = makeResponse('"value"');
+        expect(guard.enrichResponse('console_execute', malformed).content[0].text).toBe('{not-valid-json}');
+        expect(guard.enrichResponse('console_execute', arrayPayload).content[0].text).toBe('[{"success":true}]');
+        expect(guard.enrichResponse('console_execute', plainText).content[0].text).toBe('not json at all');
+        expect(guard.enrichResponse('console_execute', stringPayload).content[0].text).toBe('"value"');
+    });
+});

package/dist/tests/server/ToolCatalog.test.d.ts

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

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

@@ -0,0 +1,154 @@
+import { describe, expect, it } from 'vitest';
+import { allTools, getProfileDomains, getToolDomain, getToolsByDomains, getToolsForProfile, parseToolDomains, TIER_ORDER, TIER_DEFAULT_TTL, getTierIndex, getToolMinimalTier, getMinSatisfyingTier, } from '../../src/server/ToolCatalog.js';
+describe('ToolCatalog', () => {
+    it('parseToolDomains returns null for empty input', () => {
+        expect(parseToolDomains(undefined)).toBeNull();
+        expect(parseToolDomains('   ')).toBeNull();
+    });
+    it('parseToolDomains filters invalid values and deduplicates', () => {
+        const parsed = parseToolDomains('browser,network,invalid,browser,NETWORK');
+        expect(parsed).toEqual(['browser', 'network']);
+    });
+    it('getToolsByDomains returns deduplicated tool definitions', () => {
+        const tools = getToolsByDomains(['browser', 'browser']);
+        const names = tools.map((tool) => tool.name);
+        const unique = new Set(names);
+        expect(names.length).toBe(unique.size);
+        expect(names.length).toBeGreaterThan(0);
+    });
+    it('getToolsForProfile(search) returns a non-empty subset of all tools', () => {
+        const search = getToolsForProfile('search');
+        expect(search.length).toBeGreaterThan(0);
+        expect(search.length).toBeLessThanOrEqual(allTools.length);
+    });
+    it('getToolDomain resolves known tools and returns null for unknown names', () => {
+        expect(getToolDomain('page_navigate')).toBe('browser');
+        expect(getToolDomain('network_get_requests')).toBe('network');
+        expect(getToolDomain('non_existent_tool_name')).toBeNull();
+    });
+    it('representative tools resolve to expected domains', () => {
+        expect(getToolDomain('webpack_enumerate')).toBe('core');
+        expect(getToolDomain('source_map_extract')).toBe('core');
+        expect(getToolDomain('framework_state_extract')).toBe('browser');
+        expect(getToolDomain('indexeddb_dump')).toBe('browser');
+        expect(getToolDomain('electron_attach')).toBe('process');
+    });
+    it('getProfileDomains returns expected domain sets', () => {
+        expect(getProfileDomains('workflow')).toContain('workflow');
+        expect(getProfileDomains('full')).toContain('transform');
+    });
+    it('unknown domains are ignored by discovery and profile domain lists', () => {
+        expect(parseToolDomains('obsolete_domain')).toBeNull();
+        expect(parseToolDomains('browser,obsolete_domain')).toEqual(['browser']);
+        expect(getToolsByDomains(['obsolete_domain'])).toEqual([]);
+        for (const profile of ['search', 'workflow', 'full']) {
+            expect(getProfileDomains(profile)).not.toContain('obsolete_domain');
+        }
+    });
+    it('externalized bridge tools are not present in built-in ToolCatalog', () => {
+        const migratedBridgeTools = [
+            'native_bridge_status',
+            'ghidra_bridge',
+            'ida_bridge',
+            'native_symbol_sync',
+            'frida_bridge',
+            'jadx_bridge',
+        ];
+        const allNames = new Set(allTools.map((tool) => tool.name));
+        for (const toolName of migratedBridgeTools) {
+            expect(allNames.has(toolName)).toBe(false);
+            expect(getToolDomain(toolName)).toBeNull();
+        }
+    });
+});
+describe('Three-Tier Boost Hierarchy', () => {
+    it('TIER_ORDER defines exactly 3 tiers: search → workflow → full', () => {
+        expect(TIER_ORDER).toEqual(['search', 'workflow', 'full']);
+    });
+    it('getTierIndex returns correct indices for tiered profiles', () => {
+        expect(getTierIndex('search')).toBe(0);
+        expect(getTierIndex('workflow')).toBe(1);
+        expect(getTierIndex('full')).toBe(2);
+    });
+    it('getTierIndex returns -1 for unknown profiles', () => {
+        expect(getTierIndex('nonexistent')).toBe(-1);
+    });
+    it('TIER_DEFAULT_TTL has sane values for each profile', () => {
+        expect(TIER_DEFAULT_TTL.search).toBe(0);
+        expect(TIER_DEFAULT_TTL.workflow).toBe(60);
+        expect(TIER_DEFAULT_TTL.full).toBe(30);
+    });
+    it('tiers form a strict subset hierarchy: search ⊂ workflow ⊂ full', () => {
+        const searchDomains = new Set(getProfileDomains('search'));
+        const workflowDomains = new Set(getProfileDomains('workflow'));
+        const fullDomains = new Set(getProfileDomains('full'));
+        for (const domain of searchDomains) {
+            expect(workflowDomains.has(domain)).toBe(true);
+        }
+        expect(workflowDomains.size).toBeGreaterThan(searchDomains.size);
+        for (const domain of workflowDomains) {
+            expect(fullDomains.has(domain)).toBe(true);
+        }
+        expect(fullDomains.size).toBeGreaterThan(workflowDomains.size);
+    });
+    it('tool counts increase with each tier', () => {
+        const searchTools = getToolsForProfile('search');
+        const workflowTools = getToolsForProfile('workflow');
+        const fullTools = getToolsForProfile('full');
+        expect(searchTools.length).toBeGreaterThan(0);
+        expect(workflowTools.length).toBeGreaterThan(searchTools.length);
+        expect(fullTools.length).toBeGreaterThan(workflowTools.length);
+    });
+    it('search tier only has the maintenance domain', () => {
+        const searchDomains = getProfileDomains('search');
+        expect(searchDomains).toEqual(['maintenance']);
+    });
+    it('getToolMinimalTier returns correct tier for known tools', () => {
+        expect(getToolMinimalTier('get_token_budget_stats')).toBe('search');
+        expect(getToolMinimalTier('page_navigate')).toBe('workflow');
+        expect(getToolMinimalTier('electron_attach')).toBe('full');
+    });
+    it('getToolMinimalTier returns null for unknown tools', () => {
+        expect(getToolMinimalTier('non_existent_tool')).toBeNull();
+    });
+    it('getMinSatisfyingTier returns null for empty array', () => {
+        expect(getMinSatisfyingTier([])).toBeNull();
+    });
+    it('getMinSatisfyingTier returns minimal tier covering all tools', () => {
+        expect(getMinSatisfyingTier(['get_token_budget_stats'])).toBe('search');
+        expect(getMinSatisfyingTier(['get_token_budget_stats', 'page_navigate'])).toBe('workflow');
+        expect(getMinSatisfyingTier(['get_token_budget_stats', 'page_navigate', 'electron_attach'])).toBe('full');
+    });
+    it('getMinSatisfyingTier ignores unknown tools', () => {
+        expect(getMinSatisfyingTier(['get_token_budget_stats', 'unknown_tool'])).toBe('search');
+        expect(getMinSatisfyingTier(['unknown_tool', 'another_unknown'])).toBeNull();
+    });
+    it('workflow tier adds core, debugger, network, streaming, encoding, graphql, workflow', () => {
+        const workflowDomains = new Set(getProfileDomains('workflow'));
+        for (const domain of [
+            'core',
+            'debugger',
+            'network',
+            'streaming',
+            'encoding',
+            'graphql',
+            'workflow',
+        ]) {
+            expect(workflowDomains.has(domain)).toBe(true);
+        }
+    });
+    it('full tier adds hooks, process, wasm, antidebug, platform, sourcemap, transform', () => {
+        const fullDomains = new Set(getProfileDomains('full'));
+        for (const domain of [
+            'hooks',
+            'process',
+            'wasm',
+            'antidebug',
+            'platform',
+            'sourcemap',
+            'transform',
+        ]) {
+            expect(fullDomains.has(domain)).toBe(true);
+        }
+    });
+});

package/dist/tests/server/ToolCatalog.tier.test.d.ts

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

package/dist/tests/server/ToolCatalog.tier.test.js

@@ -0,0 +1,97 @@
+import { describe, it, expect } from 'vitest';
+import { getTierIndex, TIER_ORDER, TIER_DEFAULT_TTL, getToolsForProfile, getToolsByDomains, parseToolDomains, getToolDomain, getProfileDomains, } from '../../src/server/ToolCatalog.js';
+describe('ToolCatalog – tier system', () => {
+    it('TIER_ORDER has correct ascending order', () => {
+        expect(TIER_ORDER).toEqual(['search', 'workflow', 'full']);
+    });
+    it('getTierIndex returns correct index for each tier', () => {
+        expect(getTierIndex('search')).toBe(0);
+        expect(getTierIndex('workflow')).toBe(1);
+        expect(getTierIndex('full')).toBe(2);
+    });
+    it('getTierIndex returns -1 for non-tiered profiles', () => {
+        expect(getTierIndex('nonexistent')).toBe(-1);
+    });
+    it('TIER_DEFAULT_TTL has correct values', () => {
+        expect(TIER_DEFAULT_TTL.search).toBe(0);
+        expect(TIER_DEFAULT_TTL.workflow).toBe(60);
+        expect(TIER_DEFAULT_TTL.full).toBe(30);
+    });
+    it('each tier is a strict superset of the previous tier', () => {
+        const searchTools = new Set(getToolsForProfile('search').map((t) => t.name));
+        const workflowTools = new Set(getToolsForProfile('workflow').map((t) => t.name));
+        const fullTools = new Set(getToolsForProfile('full').map((t) => t.name));
+        for (const name of searchTools) {
+            expect(workflowTools.has(name)).toBe(true);
+        }
+        expect(workflowTools.size).toBeGreaterThan(searchTools.size);
+        for (const name of workflowTools) {
+            expect(fullTools.has(name)).toBe(true);
+        }
+        expect(fullTools.size).toBeGreaterThan(workflowTools.size);
+    });
+    it('getToolsForProfile returns non-empty arrays for all profiles', () => {
+        for (const profile of ['search', 'workflow', 'full']) {
+            const tools = getToolsForProfile(profile);
+            expect(tools.length).toBeGreaterThan(0);
+        }
+    });
+    it('getToolsByDomains returns tools for valid domains', () => {
+        const tools = getToolsByDomains(['browser']);
+        expect(tools.length).toBeGreaterThan(0);
+        for (const tool of tools) {
+            expect(getToolDomain(tool.name)).toBe('browser');
+        }
+    });
+    it('getToolsByDomains deduplicates when same domain is listed twice', () => {
+        const tools = getToolsByDomains(['browser', 'browser']);
+        const names = tools.map((t) => t.name);
+        const uniqueNames = [...new Set(names)];
+        expect(names.length).toBe(uniqueNames.length);
+    });
+    it('parseToolDomains parses comma-separated domain string', () => {
+        const result = parseToolDomains('browser,debugger,network');
+        expect(result).toContain('browser');
+        expect(result).toContain('debugger');
+        expect(result).toContain('network');
+    });
+    it('parseToolDomains filters invalid domains', () => {
+        const result = parseToolDomains('browser,fakedom,debugger');
+        expect(result).toContain('browser');
+        expect(result).toContain('debugger');
+        expect(result).not.toContain('fakedom');
+    });
+    it('parseToolDomains returns null for empty input', () => {
+        expect(parseToolDomains('')).toBeNull();
+        expect(parseToolDomains(undefined)).toBeNull();
+        expect(parseToolDomains('  ')).toBeNull();
+    });
+    it('getToolDomain returns correct domain for known tools', () => {
+        expect(getToolDomain('page_navigate')).toBe('browser');
+        expect(getToolDomain('debugger_pause')).toBe('debugger');
+        expect(getToolDomain('nonexistent_tool')).toBeNull();
+    });
+    it('representative tools resolve to expected domains', () => {
+        expect(getToolDomain('webpack_enumerate')).toBe('core');
+        expect(getToolDomain('source_map_extract')).toBe('core');
+        expect(getToolDomain('framework_state_extract')).toBe('browser');
+        expect(getToolDomain('indexeddb_dump')).toBe('browser');
+        expect(getToolDomain('electron_attach')).toBe('process');
+    });
+    it('getProfileDomains returns correct domains for each profile', () => {
+        const searchDomains = getProfileDomains('search');
+        expect(searchDomains).toContain('maintenance');
+        const workflowDomains = getProfileDomains('workflow');
+        expect(workflowDomains).toContain('browser');
+        expect(workflowDomains).toContain('maintenance');
+        const fullDomains = getProfileDomains('full');
+        expect(fullDomains.length).toBeGreaterThan(workflowDomains.length);
+    });
+    it('unknown domains are ignored in parsing and profile outputs', () => {
+        expect(parseToolDomains('obsolete_domain')).toBeNull();
+        expect(parseToolDomains('maintenance,obsolete_domain')).toEqual(['maintenance']);
+        for (const profile of ['search', 'workflow', 'full']) {
+            expect(getProfileDomains(profile)).not.toContain('obsolete_domain');
+        }
+    });
+});

package/dist/tests/server/ToolExecutionRouter.test.d.ts

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

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

@@ -0,0 +1,44 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ToolExecutionRouter } from '../../src/server/ToolExecutionRouter.js';
+describe('ToolExecutionRouter', () => {
+    it('reports whether a tool exists', () => {
+        const router = new ToolExecutionRouter({
+            ping: async () => ({ content: [{ type: 'text', text: 'pong' }] }),
+        });
+        expect(router.has('ping')).toBe(true);
+        expect(router.has('missing')).toBe(false);
+    });
+    it('lists registered tool names', () => {
+        const router = new ToolExecutionRouter({
+            a: async () => ({ content: [] }),
+            b: async () => ({ content: [] }),
+        });
+        expect(router.listToolNames().sort()).toEqual(['a', 'b']);
+    });
+    it('executes mapped handlers with args', async () => {
+        const handler = vi.fn(async (args) => ({ content: [{ type: 'text', text: args.msg }] }));
+        const router = new ToolExecutionRouter({ echo: handler });
+        const out = await router.execute('echo', { msg: 'hello' });
+        expect(out.content[0]?.text).toBe('hello');
+        expect(handler).toHaveBeenCalledWith({ msg: 'hello' });
+    });
+    it('supports adding handlers after construction', async () => {
+        const router = new ToolExecutionRouter({});
+        router.addHandlers({
+            later: async () => ({ content: [{ type: 'text', text: 'added' }] }),
+        });
+        const out = await router.execute('later', {});
+        expect(out.content[0]?.text).toBe('added');
+    });
+    it('removeHandler unregisters tool and execute throws unknown tool error', async () => {
+        const router = new ToolExecutionRouter({
+            tmp: async () => ({ content: [] }),
+        });
+        router.removeHandler('tmp');
+        await expect(router.execute('tmp', {})).rejects.toThrow('Unknown tool: tmp');
+    });
+    it('throws unknown tool error for missing handlers', async () => {
+        const router = new ToolExecutionRouter({});
+        await expect(router.execute('nope', {})).rejects.toThrow('Unknown tool: nope');
+    });
+});

package/dist/tests/server/ToolHandlerMap.test.d.ts

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