@loop_ouroboros/mcp-hub-lite 1.0.0

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

@@ -0,0 +1,102 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+/**
+ * MCP Evaluation Tests - Verify the integrity and format correctness of evaluation test files
+ *
+ * These tests ensure that evaluation test files comply with the requirements of the MCP evaluation guidelines
+ */
+describe('MCP Evaluation Tests', () => {
+    const evaluationFile = path.resolve(__dirname, 'evaluation.xml');
+    it('should have evaluation.xml file', () => {
+        expect(fs.existsSync(evaluationFile)).toBe(true);
+    });
+    it('should have valid XML format', () => {
+        const content = fs.readFileSync(evaluationFile, 'utf-8');
+        expect(content).toContain('<evaluation>');
+        expect(content).toContain('</evaluation>');
+    });
+    it('should have exactly 10 QA pairs', () => {
+        const content = fs.readFileSync(evaluationFile, 'utf-8');
+        const qaPairCount = (content.match(/<qa_pair>/g) || []).length;
+        expect(qaPairCount).toBe(10);
+    });
+    it('should have valid question and answer fields', () => {
+        const content = fs.readFileSync(evaluationFile, 'utf-8');
+        const qaPairs = content.match(/<qa_pair>([\s\S]*?)<\/qa_pair>/g) || [];
+        qaPairs.forEach((qaPair) => {
+            expect(qaPair).toContain('<question>');
+            expect(qaPair).toContain('</question>');
+            expect(qaPair).toContain('<answer>');
+            expect(qaPair).toContain('</answer>');
+            // Check that question and answer content are not empty
+            const question = qaPair.match(/<question>([\s\S]*?)<\/question>/)?.[1].trim();
+            const answer = qaPair.match(/<answer>([\s\S]*?)<\/answer>/)?.[1].trim();
+            expect(question).toBeTruthy();
+            expect(answer).toBeTruthy();
+            if (question && answer) {
+                // Check that question length is reasonable
+                expect(question.length).toBeGreaterThan(10);
+                expect(question.length).toBeLessThan(500);
+                // Check that answer length is reasonable
+                expect(answer.length).toBeGreaterThan(10);
+                expect(answer.length).toBeLessThan(500);
+            }
+        });
+    });
+    it('should have independent and complex questions', () => {
+        const content = fs.readFileSync(evaluationFile, 'utf-8');
+        const questions = (content.match(/<question>([\s\S]*?)<\/question>/g) || []).map((match) => match.replace(/<\/?question>/g, '').trim());
+        // Check if questions contain keywords that require multiple tool calls
+        const complexQuestionIndicators = [
+            'List',
+            'Count',
+            'Find',
+            'Get',
+            'Distributed',
+            'Calculate',
+            'Group',
+            'Total number',
+            'Average',
+            'Filter'
+        ];
+        questions.forEach((question, index) => {
+            const hasComplexIndicator = complexQuestionIndicators.some((indicator) => question.includes(indicator));
+            expect(hasComplexIndicator, `Question ${index + 1} does not appear to be complex enough: "${question}"`).toBe(true);
+        });
+    });
+    it('should have read-only operations', () => {
+        const content = fs.readFileSync(evaluationFile, 'utf-8');
+        const answers = (content.match(/<answer>([\s\S]*?)<\/answer>/g) || []).map((match) => match.replace(/<\/?answer>/g, '').trim());
+        // Check if answers contain keywords for destructive operations
+        const destructiveIndicators = [
+            'Create',
+            'Delete',
+            'Update',
+            'Modify',
+            'Add',
+            'Remove',
+            'Execute',
+            'Run'
+        ];
+        answers.forEach((answer, index) => {
+            const hasDestructiveIndicator = destructiveIndicators.some((indicator) => answer.includes(indicator));
+            expect(hasDestructiveIndicator, `Answer ${index + 1} may contain destructive operations: "${answer}"`).toBe(false);
+        });
+    });
+    it('should reference valid tools', () => {
+        const validTools = [
+            'list-servers',
+            'find-servers',
+            'list-all-tools-in-server',
+            'find-tools-in-server',
+            'get-tool',
+            'call-tool',
+            'find-tools'
+        ];
+        const content = fs.readFileSync(evaluationFile, 'utf-8');
+        validTools.forEach((tool) => {
+            expect(content).toContain(tool);
+        });
+    });
+});

package/dist/server/tests/helpers/sdk-test-helpers.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Create a mock MCP server for testing
+ */
+export declare class MockMcpServer {
+    private config;
+    private server;
+    constructor(config: {
+        name: string;
+        version: string;
+        tools?: Array<{
+            name: string;
+            description?: string;
+            inputSchema?: unknown;
+            handler: (args: unknown) => Promise<unknown>;
+        }>;
+    });
+    private setupHandlers;
+    getConnectConfig(): {
+        command: string;
+        args: string[];
+        type: "stdio";
+    };
+    private getServerScript;
+}
+/**
+ * In-memory test server using memory transport
+ * More efficient, no need to spawn child processes
+ */
+export declare class InMemoryMcpServer {
+    constructor();
+}
+//# sourceMappingURL=sdk-test-helpers.d.ts.map

package/dist/server/tests/helpers/sdk-test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-test-helpers.d.ts","sourceRoot":"","sources":["../../../../tests/helpers/sdk-test-helpers.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,qBAAa,aAAa;IAItB,OAAO,CAAC,MAAM;IAHhB,OAAO,CAAC,MAAM,CAAY;gBAGhB,MAAM,EAAE;QACd,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,KAAK,CAAC;YACZ,IAAI,EAAE,MAAM,CAAC;YACb,WAAW,CAAC,EAAE,MAAM,CAAC;YACrB,WAAW,CAAC,EAAE,OAAO,CAAC;YACtB,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;SAC9C,CAAC,CAAC;KACJ;IAUH,OAAO,CAAC,aAAa;IAgDrB,gBAAgB;;;;;IAShB,OAAO,CAAC,eAAe;CAOxB;AAED;;;GAGG;AACH,qBAAa,iBAAiB;;CAI7B"}

package/dist/server/tests/helpers/sdk-test-helpers.js

@@ -0,0 +1,82 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Create a mock MCP server for testing
+ */
+export class MockMcpServer {
+    config;
+    server;
+    constructor(config) {
+        this.config = config;
+        this.server = new McpServer({ name: config.name, version: config.version }, { capabilities: { tools: {} } });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        // Register handler for each tool
+        if (this.config.tools) {
+            for (const tool of this.config.tools) {
+                const schema = {
+                    method: 'tools/call',
+                    params: {
+                        name: tool.name,
+                        arguments: tool.inputSchema || {}
+                    },
+                    id: '1',
+                    jsonrpc: '2.0'
+                };
+                // @ts-expect-error - Test helper schema doesn't need full type safety
+                this.server.server.setRequestHandler(schema, async (request) => {
+                    // Safely extract arguments from request params
+                    let args = undefined;
+                    if (request.params &&
+                        typeof request.params === 'object' &&
+                        'arguments' in request.params) {
+                        args = request.params.arguments;
+                    }
+                    const result = await tool.handler(args);
+                    // For test purposes, wrap the result in a valid CallToolResult structure
+                    if (typeof result === 'object' && result !== null) {
+                        return {
+                            content: [],
+                            ...result
+                        };
+                    }
+                    else {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: String(result)
+                                }
+                            ]
+                        };
+                    }
+                });
+            }
+        }
+    }
+    // Get connection configuration
+    getConnectConfig() {
+        return {
+            command: 'node',
+            args: ['-e', this.getServerScript()],
+            type: 'stdio'
+        };
+    }
+    // Generate executable server script
+    getServerScript() {
+        // Return an inline MCP server script
+        // Using SDK's StdioServerTransport
+        return `
+      // Inline server code...
+    `;
+    }
+}
+/**
+ * In-memory test server using memory transport
+ * More efficient, no need to spawn child processes
+ */
+export class InMemoryMcpServer {
+    constructor() {
+        // Memory transport not implemented yet
+    }
+}

package/dist/server/tests/integration/api/gateway.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gateway.test.d.ts.map

package/dist/server/tests/integration/api/gateway.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.test.d.ts","sourceRoot":"","sources":["../../../../../tests/integration/api/gateway.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/integration/api/gateway.test.js

@@ -0,0 +1,366 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Define mocks first
+const mocks = vi.hoisted(() => {
+    const mockToolCache = new Map();
+    return {
+        setRequestHandler: vi.fn(),
+        setNotificationHandler: vi.fn(),
+        request: vi.fn(),
+        connect: vi.fn(),
+        getAllTools: vi.fn(),
+        callTool: vi.fn(),
+        getServerById: vi.fn(),
+        listAllToolsInServer: vi.fn(),
+        findToolsInServer: vi.fn(),
+        getTool: vi.fn(),
+        callToolDirect: vi.fn(),
+        listAllTools: vi.fn(),
+        findTools: vi.fn(),
+        listServers: vi.fn(),
+        findServers: vi.fn(),
+        getSystemTools: vi.fn().mockReturnValue([]),
+        updateClientRoots: vi.fn(),
+        getClientContext: vi.fn().mockReturnValue({ sessionId: 'test-session' }),
+        mockToolCache
+    };
+});
+// Mock dependencies
+vi.mock('@services/client-tracker.service.js', () => ({
+    clientTrackerService: {
+        updateClientRoots: mocks.updateClientRoots,
+        getClients: vi.fn().mockReturnValue([])
+    }
+}));
+vi.mock('@utils/request-context.js', () => ({
+    getClientContext: mocks.getClientContext,
+    getClientCwd: vi.fn()
+}));
+vi.mock('@utils/logger.js', () => ({
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn()
+    },
+    LOG_MODULES: {
+        SYSTEM_TOOL: { module: 'SystemTool' },
+        GATEWAY: { module: 'Gateway' }
+    }
+}));
+vi.mock('@services/mcp-connection-manager.js', () => ({
+    mcpConnectionManager: {
+        getAllTools: mocks.getAllTools,
+        callTool: mocks.callTool,
+        toolCache: mocks.mockToolCache,
+        // Add method to access the mock toolCache
+        getToolCache: () => mocks.mockToolCache
+    }
+}));
+vi.mock('@services/hub-manager.service.js', () => ({
+    hubManager: {
+        getServerById: mocks.getServerById,
+        getAllServers: vi.fn().mockReturnValue([{ id: 'server1', name: 'Test Server' }])
+    }
+}));
+vi.mock('@services/hub-tools.service.js', () => ({
+    hubToolsService: {
+        listAllToolsInServer: mocks.listAllToolsInServer,
+        findToolsInServer: mocks.findToolsInServer,
+        getTool: mocks.getTool,
+        callTool: mocks.callToolDirect,
+        listAllTools: mocks.listAllTools,
+        findTools: mocks.findTools,
+        listServers: mocks.listServers,
+        findServers: mocks.findServers,
+        getSystemTools: mocks.getSystemTools
+    }
+}));
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => {
+    return {
+        McpServer: class {
+            server = {
+                setRequestHandler: mocks.setRequestHandler,
+                setNotificationHandler: mocks.setNotificationHandler,
+                request: mocks.request
+            };
+            connect = mocks.connect;
+        }
+    };
+});
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => {
+    return {
+        StdioServerTransport: class {
+        }
+    };
+});
+// Import after mocks
+import { GatewayService } from '../../../src/services/gateway.service.js';
+describe('GatewayService', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        new GatewayService();
+    });
+    it('should register handlers on initialization', () => {
+        // Check call arguments by type (zod schema)
+        const calls = mocks.setRequestHandler.mock.calls;
+        // We now register multiple handlers: initialize, ping, search, list servers, find servers, etc.
+        expect(calls.length).toBeGreaterThanOrEqual(10);
+    });
+    it('should list tools with prefixed names', async () => {
+        // Setup mock data
+        const mockTools = [
+            { name: 'testTool', description: 'desc', inputSchema: {}, serverId: 'server1' }
+        ];
+        vi.mocked(mocks.getAllTools).mockReturnValue(mockTools);
+        vi.mocked(mocks.getServerById).mockReturnValue({
+            name: 'Test Server',
+            id: 'server1',
+            config: { allowedTools: ['testTool'] },
+            instance: { id: 'server1', timestamp: Date.now(), hash: 'abc123' }
+        });
+        // Populate toolCache for the test
+        mocks.mockToolCache.set('server1', mockTools);
+        // Find the registered handler for ListTools
+        // We can identify ListTools handler by checking if the schema has 'method' literal 'tools/list'
+        // Since ListToolsRequestSchema is from @modelcontextprotocol/sdk, we can stringify schemas for comparison
+        let listToolsHandler;
+        for (const call of mocks.setRequestHandler.mock.calls) {
+            const schema = call[0];
+            const handler = call[1];
+            // Convert schema to string for identification
+            const schemaStr = JSON.stringify(schema);
+            // Look for schema that has the method: 'tools/list' which is characteristic of ListTools
+            if (schemaStr.includes('"tools/list"')) {
+                listToolsHandler = handler;
+                break;
+            }
+        }
+        expect(listToolsHandler).toBeDefined();
+        const result = await listToolsHandler({
+            params: {},
+            id: 'test-id',
+            jsonrpc: '2.0',
+            method: 'tools/list'
+        });
+        // We expect 1 tool: 1 from mockTools
+        // The name should be 'testTool' because it's unique
+        expect(result.tools).toHaveLength(1);
+        const testTool = result.tools.find((t) => t.name === 'testTool');
+        expect(testTool).toBeDefined();
+        expect(testTool.description).toContain('[From Test Server]');
+    });
+    it('should route callTool to correct server', async () => {
+        // Setup mock data for mapping (simulate listTools call first)
+        const mockTools = [
+            { name: 'testTool', description: 'desc', inputSchema: {}, serverId: 'server1' }
+        ];
+        vi.mocked(mocks.getAllTools).mockReturnValue(mockTools);
+        vi.mocked(mocks.getServerById).mockReturnValue({
+            name: 'Test Server',
+            id: 'server1',
+            config: { allowedTools: ['testTool'] },
+            instance: { id: 'server1', timestamp: Date.now(), hash: 'abc123' }
+        });
+        // Find list tools handler to populate tool map
+        let listToolsHandler;
+        for (const call of mocks.setRequestHandler.mock.calls) {
+            const schemaStr = JSON.stringify(call[0]);
+            if (schemaStr.includes('"tools/list"')) {
+                listToolsHandler = call[1];
+                break;
+            }
+        }
+        expect(listToolsHandler).toBeDefined();
+        await listToolsHandler({
+            params: {},
+            id: 'test-id',
+            jsonrpc: '2.0',
+            method: 'tools/list'
+        }); // This populates the internal map
+        // Find call tool handler by checking if schema has 'method' literal 'tools/call'
+        let callToolHandler;
+        for (const call of mocks.setRequestHandler.mock.calls) {
+            const schemaStr = JSON.stringify(call[0]);
+            if (schemaStr.includes('"tools/call"')) {
+                callToolHandler = call[1];
+                break;
+            }
+        }
+        expect(callToolHandler).toBeDefined();
+        vi.mocked(mocks.callTool).mockResolvedValue({ content: [] });
+        // Use the correct tool name (testTool)
+        await callToolHandler({
+            params: {
+                name: 'testTool',
+                arguments: { arg: 1 }
+            },
+            id: 'test-id',
+            jsonrpc: '2.0',
+            method: 'tools/call'
+        });
+        expect(mocks.callTool).toHaveBeenCalledWith('server1', 'testTool', { arg: 1 });
+    });
+    it('should list system tools', async () => {
+        // Setup mock data
+        const mockTools = [];
+        vi.mocked(mocks.getAllTools).mockReturnValue(mockTools);
+        vi.mocked(mocks.getSystemTools).mockReturnValue([
+            { name: 'list_servers', description: 'List all servers', inputSchema: {} },
+            { name: 'find_servers', description: 'Find servers matching a pattern', inputSchema: {} },
+            {
+                name: 'list_all_tools_in_server',
+                description: 'List all tools from a specific server',
+                inputSchema: {}
+            },
+            {
+                name: 'find_tools_in_server',
+                description: 'Find tools matching a pattern in a specific server',
+                inputSchema: {}
+            },
+            {
+                name: 'get_tool',
+                description: 'Get complete schema for a specific tool from a specific server',
+                inputSchema: {}
+            },
+            {
+                name: 'call_tool',
+                description: 'Call a specific tool from a specific server',
+                inputSchema: {}
+            },
+            {
+                name: 'find_tools',
+                description: 'Find tools matching a pattern across all connected servers',
+                inputSchema: {}
+            },
+            {
+                name: 'list_resources',
+                description: 'List all Hub resources (servers, tools, and resources metadata)',
+                inputSchema: {}
+            },
+            {
+                name: 'read_resource',
+                description: 'Read content from a specific Hub resource URI',
+                inputSchema: {}
+            }
+        ]);
+        // Clear toolCache to ensure only system tools are returned
+        mocks.mockToolCache.clear();
+        // Find list tools handler
+        let listToolsHandler;
+        for (const call of mocks.setRequestHandler.mock.calls) {
+            const schemaStr = JSON.stringify(call[0]);
+            if (schemaStr.includes('"tools/list"')) {
+                listToolsHandler = call[1];
+                break;
+            }
+        }
+        expect(listToolsHandler).toBeDefined();
+        const result = await listToolsHandler({
+            params: {},
+            id: 'test-id',
+            jsonrpc: '2.0',
+            method: 'tools/list'
+        });
+        // Expect 9 system tools
+        expect(result.tools).toHaveLength(9);
+        expect(result.tools.some((t) => t.name === 'list_servers')).toBe(true);
+    });
+    // it('should fetch roots on initialized notification', async () => {
+    //   // Find initialized notification handler
+    //   let initializedHandler: Function | undefined;
+    //   for (const call of mocks.setNotificationHandler.mock.calls) {
+    //       const schemaStr = JSON.stringify(call[0]);
+    //       if (schemaStr.includes('"notifications/initialized"')) {
+    //           initializedHandler = call[1];
+    //           break;
+    //       }
+    //   }
+    //   expect(initializedHandler).toBeDefined();
+    //
+    //   // Mock server.request returning roots
+    //   vi.mocked(mocks.request).mockResolvedValue({ roots: [{ uri: 'file:///test/path' }] });
+    //
+    //   // Call the handler
+    //   await initializedHandler!();
+    //
+    //   // Verify request was made
+    //   expect(mocks.request).toHaveBeenCalledWith(
+    //       expect.objectContaining({ method: 'roots/list' }),
+    //       expect.anything()
+    //   );
+    //
+    //   // Verify client tracker was updated
+    //   expect(mocks.updateClientRoots).toHaveBeenCalledWith('test-session', [{ uri: 'file:///test/path' }]);
+    // });
+    it('should call system tools', async () => {
+        // Find call tool handler
+        let callToolHandler;
+        for (const call of mocks.setRequestHandler.mock.calls) {
+            const schemaStr = JSON.stringify(call[0]);
+            if (schemaStr.includes('"tools/call"')) {
+                callToolHandler = call[1];
+                break;
+            }
+        }
+        expect(callToolHandler).toBeDefined();
+        vi.mocked(mocks.listServers).mockResolvedValue(['server1']);
+        const result = await callToolHandler({
+            params: {
+                name: 'list_servers',
+                arguments: {}
+            },
+            id: 'test-id',
+            jsonrpc: '2.0',
+            method: 'tools/call'
+        });
+        expect(mocks.listServers).toHaveBeenCalled();
+        expect(result.content[0].text).toContain('server1');
+    });
+    it('should call call_tool system tool with undefined serverName', async () => {
+        // Find call tool handler
+        let callToolHandler;
+        for (const call of mocks.setRequestHandler.mock.calls) {
+            const schemaStr = JSON.stringify(call[0]);
+            if (schemaStr.includes('"tools/call"')) {
+                callToolHandler = call[1];
+                break;
+            }
+        }
+        expect(callToolHandler).toBeDefined();
+        // Mock the actual listServers implementation to return expected result
+        // Note: listServers returns server names, not server IDs
+        vi.mocked(mocks.listServers).mockImplementation(async () => ['Test Server']);
+        // Mock callToolDirect to return the expected result format
+        vi.mocked(mocks.callToolDirect).mockImplementation(async (args) => {
+            if (args.toolName === 'list_servers') {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(['Test Server'], null, 2)
+                        }
+                    ]
+                };
+            }
+            return { content: [] };
+        });
+        const result = await callToolHandler({
+            params: {
+                name: 'call_tool',
+                arguments: {
+                    serverName: undefined,
+                    toolName: 'list_servers',
+                    toolArgs: {}
+                }
+            },
+            id: 'test-id',
+            jsonrpc: '2.0',
+            method: 'tools/call'
+        });
+        // Verify the result contains the expected content
+        expect(result).toBeDefined();
+        expect(result.content).toBeDefined();
+        expect(result.content[0]).toBeDefined();
+        expect(result.content[0].text).toContain('Test Server');
+    });
+});

package/dist/server/tests/integration/gateway/fault-tolerance.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fault-tolerance.test.d.ts.map

package/dist/server/tests/integration/gateway/fault-tolerance.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fault-tolerance.test.d.ts","sourceRoot":"","sources":["../../../../../tests/integration/gateway/fault-tolerance.test.ts"],"names":[],"mappings":""}