@jshookmcp/jshook 0.2.0 → 0.2.2

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

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

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

@@ -1,218 +0,0 @@
-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

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

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

@@ -1,114 +0,0 @@
-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

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

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

@@ -1,154 +0,0 @@
-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

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

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

@@ -1,97 +0,0 @@
-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

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

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

@@ -1,44 +0,0 @@
-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

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