@jshookmcp/jshook 0.1.9 → 0.2.1

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

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

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

@@ -0,0 +1,34 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { normalizeToolName, validateToolNameArray, } from '../../src/server/MCPServer.search.validation.js';
+describe('MCPServer.search.validation', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('normalizes namespaced tool names while preserving plain names', () => {
+        expect(normalizeToolName(' page_navigate ')).toBe('page_navigate');
+        expect(normalizeToolName('mcp__jshook__page_navigate')).toBe('page_navigate');
+        expect(normalizeToolName('mcp__invalid')).toBe('mcp__invalid');
+        expect(normalizeToolName('mcp__jshook__tool__with__parts')).toBe('tool__with__parts');
+    });
+    it('validates tool name arrays and normalizes each entry', () => {
+        expect(validateToolNameArray({
+            names: ['page_navigate', 'mcp__jshook__network_get_requests'],
+        })).toEqual({
+            names: ['page_navigate', 'network_get_requests'],
+        });
+    });
+    it('rejects non-array or blank tool names', () => {
+        expect(validateToolNameArray({ names: 'page_navigate' })).toEqual({
+            names: [],
+            error: 'names must be an array',
+        });
+        expect(validateToolNameArray({ names: ['page_navigate', ' '] })).toEqual({
+            names: [],
+            error: 'invalid tool name: expected non-empty string',
+        });
+        expect(validateToolNameArray({ names: ['page_navigate', 1] })).toEqual({
+            names: [],
+            error: 'invalid tool name: expected non-empty string',
+        });
+    });
+});

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

@@ -164,8 +164,8 @@ describe('MCPServer', () => {
         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');
+        expect(names).not.toContain('boost_profile');
+        expect(names).not.toContain('unboost_profile');
     });
     it('resolves tool profile from environment when explicitly provided', () => {
         process.env.MCP_TOOL_PROFILE = 'full';

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

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

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

@@ -0,0 +1,134 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(() => {
+    class MockToolError extends Error {
+    }
+    return {
+        buildZodShape: vi.fn(),
+        toolErrorToResponse: vi.fn((error) => ({
+            content: [{ type: 'text', text: `tool:${error.message}` }],
+        })),
+        asErrorResponse: vi.fn((error) => ({
+            isError: true,
+            content: [{ type: 'text', text: `generic:${error.message}` }],
+        })),
+        logger: {
+            error: vi.fn(),
+        },
+        MockToolError,
+    };
+});
+vi.mock('@server/MCPServer.schema', () => ({
+    buildZodShape: mocks.buildZodShape,
+}));
+vi.mock('@server/domains/shared/response', () => ({
+    toolErrorToResponse: mocks.toolErrorToResponse,
+    asErrorResponse: mocks.asErrorResponse,
+}));
+vi.mock('@utils/logger', () => ({
+    logger: mocks.logger,
+}));
+vi.mock('@errors/ToolError', () => ({
+    ToolError: mocks.MockToolError,
+}));
+import { registerSingleTool } from '../../src/server/MCPServer.tools.js';
+function createCtx(overrides = {}) {
+    const registrations = [];
+    const ctx = {
+        server: {
+            registerTool: vi.fn((name, config, handler) => {
+                const registered = { name, config, handler, remove: vi.fn() };
+                registrations.push(registered);
+                return registered;
+            }),
+        },
+        executeToolWithTracking: vi.fn(async (_name, args) => ({
+            content: [{ type: 'text', text: JSON.stringify(args) }],
+        })),
+        __registrations: registrations,
+        ...overrides,
+    };
+    return ctx;
+}
+describe('MCPServer.tools', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('registers tools with generated zod input schemas and forwards tool args', async () => {
+        mocks.buildZodShape.mockReturnValue({
+            url: { safeParse: vi.fn() },
+        });
+        const ctx = createCtx();
+        const toolDef = {
+            name: 'page_navigate',
+            description: 'Navigate a page',
+            inputSchema: { type: 'object', properties: { url: { type: 'string' } } },
+        };
+        const registered = registerSingleTool(ctx, toolDef);
+        const handler = ctx.__registrations[0].handler;
+        const result = await handler({ url: 'https://example.com' });
+        expect(registered).toBe(ctx.__registrations[0]);
+        expect(ctx.server.registerTool).toHaveBeenCalledWith('page_navigate', {
+            description: 'Navigate a page',
+            inputSchema: { url: { safeParse: expect.any(Function) } },
+        }, expect.any(Function));
+        expect(ctx.executeToolWithTracking).toHaveBeenCalledWith('page_navigate', {
+            url: 'https://example.com',
+        });
+        expect(result).toEqual({
+            content: [{ type: 'text', text: '{"url":"https://example.com"}' }],
+        });
+    });
+    it('registers tools without schemas using the tool name as fallback description', async () => {
+        mocks.buildZodShape.mockReturnValue({});
+        const ctx = createCtx();
+        const toolDef = {
+            name: 'extensions_list',
+            inputSchema: { type: 'object', properties: {} },
+        };
+        registerSingleTool(ctx, toolDef);
+        const handler = ctx.__registrations[0].handler;
+        await handler({ ignored: true });
+        expect(ctx.server.registerTool).toHaveBeenCalledWith('extensions_list', { description: 'extensions_list' }, expect.any(Function));
+        expect(ctx.executeToolWithTracking).toHaveBeenCalledWith('extensions_list', {});
+    });
+    it('converts ToolError failures into structured tool responses', async () => {
+        mocks.buildZodShape.mockReturnValue({});
+        const ctx = createCtx({
+            executeToolWithTracking: vi.fn(async () => {
+                throw new mocks.MockToolError('missing prerequisite');
+            }),
+        });
+        registerSingleTool(ctx, {
+            name: 'page_navigate',
+            description: 'Navigate a page',
+            inputSchema: { type: 'object', properties: {} },
+        });
+        const response = await ctx.__registrations[0].handler();
+        expect(response).toEqual({
+            content: [{ type: 'text', text: 'tool:missing prerequisite' }],
+        });
+        expect(mocks.toolErrorToResponse).toHaveBeenCalledWith(expect.any(mocks.MockToolError));
+        expect(mocks.asErrorResponse).not.toHaveBeenCalled();
+        expect(mocks.logger.error).not.toHaveBeenCalled();
+    });
+    it('converts unknown failures into generic error responses and logs them', async () => {
+        mocks.buildZodShape.mockReturnValue({});
+        const ctx = createCtx({
+            executeToolWithTracking: vi.fn(async () => {
+                throw new Error('boom');
+            }),
+        });
+        registerSingleTool(ctx, {
+            name: 'page_navigate',
+            description: 'Navigate a page',
+            inputSchema: { type: 'object', properties: {} },
+        });
+        const response = await ctx.__registrations[0].handler();
+        expect(response).toEqual({
+            isError: true,
+            content: [{ type: 'text', text: 'generic:boom' }],
+        });
+        expect(mocks.logger.error).toHaveBeenCalledWith('Tool execution failed: page_navigate', expect.any(Error));
+        expect(mocks.asErrorResponse).toHaveBeenCalledWith(expect.any(Error));
+    });
+});

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

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

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

@@ -0,0 +1,334 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(() => {
+    const httpServers = [];
+    const httpTransports = [];
+    const logger = {
+        success: vi.fn(),
+        warn: vi.fn(),
+    };
+    function createMockHttpServer(handler) {
+        const listeners = new Map();
+        const server = {
+            __handler: handler,
+            __listeners: listeners,
+            requestTimeout: 0,
+            headersTimeout: 0,
+            keepAliveTimeout: 0,
+            listen: vi.fn((_, __, cb) => {
+                cb?.();
+            }),
+            on: vi.fn((event, cb) => {
+                const current = listeners.get(event) ?? [];
+                current.push(cb);
+                listeners.set(event, current);
+                return server;
+            }),
+            emit(event, ...args) {
+                for (const cb of listeners.get(event) ?? []) {
+                    cb(...args);
+                }
+            },
+            close: vi.fn((cb) => {
+                cb?.();
+            }),
+        };
+        return server;
+    }
+    return {
+        httpServers,
+        httpTransports,
+        createServer: vi.fn((handler) => {
+            const server = createMockHttpServer(handler);
+            httpServers.push(server);
+            return server;
+        }),
+        randomUUID: vi.fn(() => 'uuid-123'),
+        checkOrigin: vi.fn(() => true),
+        checkAuth: vi.fn(() => true),
+        checkRateLimit: vi.fn(() => true),
+        readBodyWithLimit: vi.fn(async () => '{"ok":true}'),
+        logger,
+        stdioConnects: [],
+    };
+});
+vi.mock('node:http', () => ({
+    createServer: mocks.createServer,
+}));
+vi.mock('node:crypto', () => ({
+    randomUUID: mocks.randomUUID,
+}));
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
+    StdioServerTransport: class MockStdioServerTransport {
+        constructor() {
+            mocks.stdioConnects.push(this);
+        }
+    },
+}));
+vi.mock('@modelcontextprotocol/sdk/server/streamableHttp.js', () => ({
+    StreamableHTTPServerTransport: class MockStreamableHTTPServerTransport {
+        options;
+        handleRequest = vi.fn();
+        constructor(options) {
+            this.options = options;
+            mocks.httpTransports.push(this);
+        }
+    },
+}));
+vi.mock('@server/http/HttpMiddleware', () => ({
+    checkOrigin: mocks.checkOrigin,
+    checkAuth: mocks.checkAuth,
+    checkRateLimit: mocks.checkRateLimit,
+    readBodyWithLimit: mocks.readBodyWithLimit,
+}));
+vi.mock('@utils/logger', () => ({
+    logger: mocks.logger,
+}));
+vi.mock('@src/constants', () => ({
+    MCP_HTTP_REQUEST_TIMEOUT_MS: 1_000,
+    MCP_HTTP_HEADERS_TIMEOUT_MS: 2_000,
+    MCP_HTTP_KEEPALIVE_TIMEOUT_MS: 3_000,
+    MCP_HTTP_FORCE_CLOSE_TIMEOUT_MS: 4_000,
+}));
+import { closeServer, startHttpTransport, startStdioTransport } from '../../src/server/MCPServer.transport.js';
+function createCtx(overrides = {}) {
+    return {
+        server: {
+            connect: vi.fn(async () => undefined),
+            close: vi.fn(async () => undefined),
+        },
+        tokenBudget: {
+            getStats: vi.fn(() => ({
+                usagePercentage: 12,
+                currentUsage: 120,
+                maxTokens: 1_000,
+            })),
+        },
+        detailedData: {
+            shutdown: vi.fn(),
+        },
+        enabledDomains: new Set(['browser']),
+        selectedTools: [{ name: 'browser_launch' }],
+        activatedToolNames: new Set(['network_enable']),
+        baseTier: 'workflow',
+        domainTtlEntries: new Map(),
+        httpSockets: new Set(),
+        ...overrides,
+    };
+}
+function createRes() {
+    const res = {
+        status: undefined,
+        headers: undefined,
+        body: undefined,
+        writeHead: vi.fn((status, headers) => {
+            res.status = status;
+            res.headers = headers;
+            return res;
+        }),
+        end: vi.fn((body) => {
+            res.body = body;
+            return res;
+        }),
+    };
+    return res;
+}
+describe('MCPServer.transport', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+        delete process.env.MCP_PORT;
+        delete process.env.MCP_HOST;
+        delete process.env.MCP_HEALTH_VERBOSE;
+        mocks.httpServers.length = 0;
+        mocks.httpTransports.length = 0;
+        mocks.stdioConnects.length = 0;
+        vi.clearAllMocks();
+        mocks.checkOrigin.mockReturnValue(true);
+        mocks.checkAuth.mockReturnValue(true);
+        mocks.checkRateLimit.mockReturnValue(true);
+        mocks.readBodyWithLimit.mockResolvedValue('{"ok":true}');
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        vi.useRealTimers();
+    });
+    it('starts stdio transport and connects the MCP server', async () => {
+        const ctx = createCtx();
+        await startStdioTransport(ctx);
+        expect(ctx.server.connect).toHaveBeenCalledTimes(1);
+        expect(mocks.stdioConnects).toHaveLength(1);
+        expect(mocks.logger.success).toHaveBeenCalledWith('MCP stdio server started');
+    });
+    it('starts HTTP transport, configures timeouts, and tracks sockets', async () => {
+        process.env.MCP_PORT = '4321';
+        process.env.MCP_HOST = '0.0.0.0';
+        const ctx = createCtx();
+        await startHttpTransport(ctx);
+        const server = mocks.httpServers[0];
+        const transport = mocks.httpTransports[0];
+        expect(ctx.server.connect).toHaveBeenCalledWith(transport);
+        expect(server.listen).toHaveBeenCalledWith(4321, '0.0.0.0', expect.any(Function));
+        expect(server.requestTimeout).toBe(1_000);
+        expect(server.headersTimeout).toBe(2_000);
+        expect(server.keepAliveTimeout).toBe(3_000);
+        const socket = {
+            destroy: vi.fn(),
+            on: vi.fn((event, cb) => {
+                if (event === 'close') {
+                    socket.__close = cb;
+                }
+            }),
+            __close: undefined,
+        };
+        server.emit('connection', socket);
+        expect(ctx.httpSockets.has(socket)).toBe(true);
+        socket.__close?.();
+        expect(ctx.httpSockets.has(socket)).toBe(false);
+        const sessionId = transport.options.sessionIdGenerator;
+        expect(sessionId()).toBe('uuid-123');
+        expect(mocks.logger.success).toHaveBeenCalledWith('MCP Streamable HTTP server listening on http://0.0.0.0:4321/mcp');
+    });
+    it('serves /health without invoking auth middleware and includes verbose details when enabled', async () => {
+        process.env.MCP_HEALTH_VERBOSE = 'true';
+        const ctx = createCtx();
+        await startHttpTransport(ctx);
+        const server = mocks.httpServers[0];
+        const req = { url: '/health', method: 'GET' };
+        const res = createRes();
+        server.__handler(req, res);
+        expect(mocks.checkOrigin).not.toHaveBeenCalled();
+        expect(mocks.checkAuth).not.toHaveBeenCalled();
+        expect(mocks.checkRateLimit).not.toHaveBeenCalled();
+        expect(res.status).toBe(200);
+        expect(JSON.parse(res.body)).toEqual({
+            status: 'ok',
+            uptime: expect.any(Number),
+            tier: 'workflow',
+            baseTier: 'workflow',
+            enabledDomains: ['browser'],
+            registeredTools: 1,
+            activatedTools: 1,
+            tokenBudget: {
+                usagePercentage: 12,
+                currentUsage: 120,
+                maxTokens: 1_000,
+            },
+        });
+    });
+    it('returns 404 for non-MCP paths', async () => {
+        const ctx = createCtx();
+        await startHttpTransport(ctx);
+        const server = mocks.httpServers[0];
+        const res = createRes();
+        server.__handler({ url: '/other', method: 'GET' }, res);
+        expect(res.status).toBe(404);
+        expect(res.body).toBe('Not Found – use POST /mcp or GET /health');
+    });
+    it('stops processing when origin, auth, or rate limit checks fail', async () => {
+        const ctx = createCtx();
+        await startHttpTransport(ctx);
+        const server = mocks.httpServers[0];
+        const res = createRes();
+        mocks.checkOrigin.mockReturnValueOnce(false);
+        server.__handler({ url: '/mcp', method: 'GET' }, res);
+        expect(mocks.checkAuth).not.toHaveBeenCalled();
+        mocks.checkOrigin.mockReturnValue(true);
+        mocks.checkAuth.mockReturnValueOnce(false);
+        server.__handler({ url: '/mcp', method: 'GET' }, createRes());
+        expect(mocks.checkRateLimit).not.toHaveBeenCalled();
+        mocks.checkAuth.mockReturnValue(true);
+        mocks.checkRateLimit.mockReturnValueOnce(false);
+        server.__handler({ url: '/mcp', method: 'GET' }, createRes());
+        expect(mocks.httpTransports[0].handleRequest).not.toHaveBeenCalled();
+    });
+    it('passes GET and DELETE MCP requests directly to the HTTP transport', async () => {
+        const ctx = createCtx();
+        await startHttpTransport(ctx);
+        const server = mocks.httpServers[0];
+        const transport = mocks.httpTransports[0];
+        const getReq = { url: '/mcp', method: 'GET' };
+        const deleteReq = { url: '/mcp', method: 'DELETE' };
+        server.__handler(getReq, createRes());
+        server.__handler(deleteReq, createRes());
+        expect(transport.handleRequest).toHaveBeenNthCalledWith(1, getReq, expect.any(Object));
+        expect(transport.handleRequest).toHaveBeenNthCalledWith(2, deleteReq, expect.any(Object));
+    });
+    it('reads POST bodies before handing requests to the HTTP transport', async () => {
+        const ctx = createCtx();
+        await startHttpTransport(ctx);
+        const server = mocks.httpServers[0];
+        const transport = mocks.httpTransports[0];
+        const req = { url: '/mcp', method: 'POST' };
+        const res = createRes();
+        server.__handler(req, res);
+        await Promise.resolve();
+        expect(mocks.readBodyWithLimit).toHaveBeenCalledWith(req, res);
+        expect(transport.handleRequest).toHaveBeenCalledWith(req, res, '{"ok":true}');
+    });
+    it('returns 405 for unsupported HTTP methods', async () => {
+        const ctx = createCtx();
+        await startHttpTransport(ctx);
+        const server = mocks.httpServers[0];
+        const res = createRes();
+        server.__handler({ url: '/mcp', method: 'PUT' }, res);
+        expect(res.status).toBe(405);
+        expect(res.body).toBe('Method Not Allowed');
+    });
+    it('closes the HTTP server, clears timers, disposes domain instances, and closes the MCP server', async () => {
+        const clearTimeoutSpy = vi.spyOn(globalThis, 'clearTimeout');
+        const timerA = setTimeout(() => undefined, 10);
+        const timerB = setTimeout(() => undefined, 10);
+        const consoleMonitor = { disable: vi.fn(async () => undefined) };
+        const runtimeInspector = {
+            close: vi.fn(async () => {
+                throw new Error('runtime close failed');
+            }),
+        };
+        const debuggerManager = { close: vi.fn(async () => undefined) };
+        const scriptManager = { close: vi.fn(async () => undefined) };
+        const transformHandlers = { close: vi.fn(async () => undefined) };
+        const collector = { close: vi.fn(async () => undefined) };
+        const socket = { destroy: vi.fn() };
+        const httpServer = {
+            close: vi.fn((cb) => {
+                cb?.();
+            }),
+        };
+        const ctx = createCtx({
+            domainTtlEntries: new Map([
+                ['browser', { timer: timerA }],
+                ['network', { timer: timerB }],
+            ]),
+            httpServer,
+            httpSockets: new Set([socket]),
+            consoleMonitor,
+            runtimeInspector,
+            debuggerManager,
+            scriptManager,
+            transformHandlers,
+            collector,
+        });
+        await closeServer(ctx);
+        expect(clearTimeoutSpy).toHaveBeenCalledWith(timerA);
+        expect(clearTimeoutSpy).toHaveBeenCalledWith(timerB);
+        expect(ctx.domainTtlEntries.size).toBe(0);
+        expect(ctx.detailedData.shutdown).toHaveBeenCalledTimes(1);
+        expect(httpServer.close).toHaveBeenCalledTimes(1);
+        expect(ctx.httpSockets.size).toBe(0);
+        expect(consoleMonitor.disable).toHaveBeenCalledTimes(1);
+        expect(runtimeInspector.close).toHaveBeenCalledTimes(1);
+        expect(debuggerManager.close).toHaveBeenCalledTimes(1);
+        expect(scriptManager.close).toHaveBeenCalledTimes(1);
+        expect(transformHandlers.close).toHaveBeenCalledTimes(1);
+        expect(collector.close).toHaveBeenCalledTimes(1);
+        expect(ctx.consoleMonitor).toBeUndefined();
+        expect(ctx.runtimeInspector).toBeUndefined();
+        expect(ctx.debuggerManager).toBeUndefined();
+        expect(ctx.scriptManager).toBeUndefined();
+        expect(ctx.collector).toBeUndefined();
+        expect(ctx.httpServer).toBeUndefined();
+        expect(ctx.server.close).toHaveBeenCalledTimes(1);
+        expect(mocks.logger.warn).toHaveBeenCalledWith('runtimeInspector cleanup failed:', expect.any(Error));
+        expect(mocks.logger.success).toHaveBeenCalledWith('MCP server closed');
+    });
+});

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

@@ -1,5 +1,5 @@
 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';
+import { allTools, getProfileDomains, getToolDomain, getToolsByDomains, getToolsForProfile, parseToolDomains, TIER_ORDER, getTierIndex, getToolMinimalTier, getMinSatisfyingTier, } from '../../src/server/ToolCatalog.js';
 describe('ToolCatalog', () => {
     it('parseToolDomains returns null for empty input', () => {
         expect(parseToolDomains(undefined)).toBeNull();
@@ -73,11 +73,6 @@ describe('Three-Tier Boost Hierarchy', () => {
     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'));

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { getTierIndex, TIER_ORDER, TIER_DEFAULT_TTL, getToolsForProfile, getToolsByDomains, parseToolDomains, getToolDomain, getProfileDomains, } from '../../src/server/ToolCatalog.js';
+import { getTierIndex, TIER_ORDER, 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']);
@@ -12,11 +12,6 @@ describe('ToolCatalog – tier system', () => {
     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));

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

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