@loop_ouroboros/mcp-hub-lite 1.3.0 → 1.3.2

package/dist/server/tests/unit/services/gateway-session-mode.test.js

@@ -0,0 +1,174 @@
+import { describe, test, expect, beforeEach, vi } from 'vitest';
+import { SESSION_MODE_STATEFUL, SESSION_MODE_STATELESS } from '../../../shared/models/constants.js';
+// Mock configManager before importing the module under test
+const mockGetConfig = vi.fn();
+vi.mock('@config/config-manager.js', () => ({
+    configManager: {
+        getConfig: () => mockGetConfig()
+    }
+}));
+// We need to import resolveSessionMode from gateway.ts
+// It's exported from the module, but the module has side-effects (Fastify routes)
+// Use dynamic import after mocks are set up
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let resolveSessionMode;
+beforeEach(async () => {
+    vi.resetModules();
+    mockGetConfig.mockReset();
+    const mod = await import('../../../src/api/mcp/gateway.js');
+    resolveSessionMode = mod.resolveSessionMode;
+});
+function makeRequest(headers = {}) {
+    return { headers };
+}
+describe('resolveSessionMode', () => {
+    describe('request header override (highest priority)', () => {
+        test('x-mcp-session-mode: stateless overrides UA match', () => {
+            mockGetConfig.mockReturnValue({
+                system: {
+                    session: {
+                        sessionModeRules: { stateful: ['claude-code'], stateless: [] },
+                        defaultSessionMode: SESSION_MODE_STATEFUL
+                    }
+                }
+            });
+            const request = makeRequest({
+                'x-mcp-session-mode': SESSION_MODE_STATELESS,
+                'user-agent': 'claude-code/2.1.140 (cli)'
+            });
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATELESS);
+        });
+        test('x-mcp-session-mode: stateful overrides UA match', () => {
+            mockGetConfig.mockReturnValue({
+                system: {
+                    session: {
+                        sessionModeRules: { stateful: [], stateless: ['cherrystudio'] },
+                        defaultSessionMode: SESSION_MODE_STATELESS
+                    }
+                }
+            });
+            const request = makeRequest({
+                'x-mcp-session-mode': SESSION_MODE_STATEFUL,
+                'user-agent': 'CherryStudio/1.9.7'
+            });
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATEFUL);
+        });
+    });
+    describe('UA keyword matching', () => {
+        test('matches stateless pattern (case-insensitive)', () => {
+            mockGetConfig.mockReturnValue({
+                system: {
+                    session: {
+                        sessionModeRules: { stateful: [], stateless: ['cherrystudio'] },
+                        defaultSessionMode: SESSION_MODE_STATEFUL
+                    }
+                }
+            });
+            const request = makeRequest({
+                'user-agent': 'Mozilla/5.0 ... CherryStudio/1.9.7 Chrome/146.0.7680.188 Electron/41.2.1'
+            });
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATELESS);
+        });
+        test('matches stateless pattern with different casing in UA', () => {
+            mockGetConfig.mockReturnValue({
+                system: {
+                    session: {
+                        sessionModeRules: { stateful: [], stateless: ['cherrystudio'] },
+                        defaultSessionMode: SESSION_MODE_STATEFUL
+                    }
+                }
+            });
+            const request = makeRequest({ 'user-agent': 'CHERRYSTUDIO/1.9.7' });
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATELESS);
+        });
+        test('matches stateless pattern with different casing in rule', () => {
+            mockGetConfig.mockReturnValue({
+                system: {
+                    session: {
+                        sessionModeRules: { stateful: [], stateless: ['CherryStudio'] },
+                        defaultSessionMode: SESSION_MODE_STATEFUL
+                    }
+                }
+            });
+            const request = makeRequest({ 'user-agent': 'cherrystudio/1.9.7' });
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATELESS);
+        });
+        test('matches stateful pattern', () => {
+            mockGetConfig.mockReturnValue({
+                system: {
+                    session: {
+                        sessionModeRules: { stateful: ['claude-code'], stateless: [] },
+                        defaultSessionMode: SESSION_MODE_STATELESS
+                    }
+                }
+            });
+            const request = makeRequest({ 'user-agent': 'claude-code/2.1.140 (cli)' });
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATEFUL);
+        });
+        test('stateless rules checked before stateful (stateless wins on conflict)', () => {
+            mockGetConfig.mockReturnValue({
+                system: {
+                    session: {
+                        sessionModeRules: { stateful: ['claude'], stateless: ['claude-code'] },
+                        defaultSessionMode: SESSION_MODE_STATEFUL
+                    }
+                }
+            });
+            // "claude-code" matches both "claude" and "claude-code", but stateless checked first
+            const request = makeRequest({ 'user-agent': 'claude-code/2.1.140' });
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATELESS);
+        });
+    });
+    describe('default fallback', () => {
+        test('no matching UA falls back to defaultSessionMode', () => {
+            mockGetConfig.mockReturnValue({
+                system: {
+                    session: {
+                        sessionModeRules: { stateful: ['claude-code'], stateless: ['cherrystudio'] },
+                        defaultSessionMode: SESSION_MODE_STATEFUL
+                    }
+                }
+            });
+            const request = makeRequest({ 'user-agent': 'SomeUnknownClient/1.0' });
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATEFUL);
+        });
+        test('empty UA falls back to defaultSessionMode', () => {
+            mockGetConfig.mockReturnValue({
+                system: {
+                    session: {
+                        sessionModeRules: { stateful: ['claude-code'], stateless: [] },
+                        defaultSessionMode: SESSION_MODE_STATEFUL
+                    }
+                }
+            });
+            const request = makeRequest({});
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATEFUL);
+        });
+        test('no gateway config falls back to stateful (hardcoded default)', () => {
+            mockGetConfig.mockReturnValue({
+                system: {}
+            });
+            const request = makeRequest({ 'user-agent': 'SomeClient/1.0' });
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATEFUL);
+        });
+        test('no config at all falls back to stateful', () => {
+            mockGetConfig.mockReturnValue(null);
+            const request = makeRequest({ 'user-agent': 'SomeClient/1.0' });
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATEFUL);
+        });
+    });
+    describe('empty rules arrays', () => {
+        test('empty stateful and stateless arrays use default', () => {
+            mockGetConfig.mockReturnValue({
+                system: {
+                    session: {
+                        sessionModeRules: { stateful: [], stateless: [] },
+                        defaultSessionMode: SESSION_MODE_STATELESS
+                    }
+                }
+            });
+            const request = makeRequest({ 'user-agent': 'SomeClient/1.0' });
+            expect(resolveSessionMode(request)).toBe(SESSION_MODE_STATELESS);
+        });
+    });
+});

package/dist/server/tests/unit/services/hub-tools.service.test.js

@@ -698,6 +698,301 @@ describe('HubToolsService', () => {
             expect(allTools['Server 2'].tools).toEqual(expectedToolSummariesServer2);
         });
     });
+    describe('searchTools', () => {
+        it('should return tools matching a single-word query', async () => {
+            const mockServers = [
+                {
+                    name: 'Server 1',
+                    config: {
+                        template: {
+                            type: 'stdio',
+                            command: 'test',
+                            args: [],
+                            env: {},
+                            headers: {},
+                            aggregatedTools: [],
+                            timeout: 30000,
+                            tags: {}
+                        },
+                        instances: [
+                            { id: '1', index: 0, enabled: true, args: [], env: {}, headers: {}, tags: {} }
+                        ],
+                        tagDefinitions: []
+                    }
+                }
+            ];
+            const mockTools = [
+                { name: 'readFile', description: 'Read file contents', serverName: 'Server 1' },
+                { name: 'writeFile', description: 'Write file contents', serverName: 'Server 1' },
+                { name: 'deleteFile', description: 'Delete files', serverName: 'Server 1' }
+            ];
+            vi.mocked(hubManager.getAllServers).mockReturnValue(mockServers);
+            vi.mocked(hubManager.getServerInstancesByName).mockReturnValue(mockServers[0].config.instances);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockServers[0].config);
+            vi.mocked(mcpConnectionManager.getConnectedIndexes).mockReturnValue([0]);
+            vi.mocked(mcpConnectionManager.getToolsByServerName).mockReturnValue(mockTools);
+            const result = await hubToolsService.searchTools('file');
+            expect(result).toHaveProperty('Server 1');
+            expect(result['Server 1'].tools).toHaveLength(3);
+        });
+        it('should match multi-word query by tokenizing and using OR logic', async () => {
+            const mockServers = [
+                {
+                    name: 'Server 1',
+                    config: {
+                        template: {
+                            type: 'stdio',
+                            command: 'test',
+                            args: [],
+                            env: {},
+                            headers: {},
+                            aggregatedTools: [],
+                            timeout: 30000,
+                            tags: {}
+                        },
+                        instances: [
+                            { id: '1', index: 0, enabled: true, args: [], env: {}, headers: {}, tags: {} }
+                        ],
+                        tagDefinitions: []
+                    }
+                }
+            ];
+            const mockTools = [
+                { name: 'readFile', description: 'Read file contents', serverName: 'Server 1' },
+                { name: 'getEnv', description: 'Get environment variables', serverName: 'Server 1' },
+                { name: 'deleteFile', description: 'Delete files', serverName: 'Server 1' }
+            ];
+            vi.mocked(hubManager.getAllServers).mockReturnValue(mockServers);
+            vi.mocked(hubManager.getServerInstancesByName).mockReturnValue(mockServers[0].config.instances);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockServers[0].config);
+            vi.mocked(mcpConnectionManager.getConnectedIndexes).mockReturnValue([0]);
+            vi.mocked(mcpConnectionManager.getToolsByServerName).mockReturnValue(mockTools);
+            const result = await hubToolsService.searchTools('environment variable');
+            expect(result).toHaveProperty('Server 1');
+            // "getEnv" has "environment" in description but "variable" is NOT in "environment" (we need "variables")
+            // Actually: "environment" is in "environment variables", and "variable" is NOT in "environment variables"
+            // But "variable" is a substring of "variables", so it matches!
+            // Both tokens match getEnv, and only "file" matches readFile (but not "environment" or "variable")
+            // Wait: readFile has "file" in name and "Read file contents" in description — no "environment" or "variable" match
+            const toolNames = result['Server 1'].tools.map((t) => t.name);
+            expect(toolNames).toContain('getEnv');
+        });
+        it('should sort results by match count descending', async () => {
+            const mockServers = [
+                {
+                    name: 'Server 1',
+                    config: {
+                        template: {
+                            type: 'stdio',
+                            command: 'test',
+                            args: [],
+                            env: {},
+                            headers: {},
+                            aggregatedTools: [],
+                            timeout: 30000,
+                            tags: {}
+                        },
+                        instances: [
+                            { id: '1', index: 0, enabled: true, args: [], env: {}, headers: {}, tags: {} }
+                        ],
+                        tagDefinitions: []
+                    }
+                }
+            ];
+            const mockTools = [
+                { name: 'envSetter', description: 'Set environment values', serverName: 'Server 1' },
+                { name: 'getEnv', description: 'Get environment variables', serverName: 'Server 1' },
+                { name: 'deleteFile', description: 'Delete environment files', serverName: 'Server 1' }
+            ];
+            vi.mocked(hubManager.getAllServers).mockReturnValue(mockServers);
+            vi.mocked(hubManager.getServerInstancesByName).mockReturnValue(mockServers[0].config.instances);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockServers[0].config);
+            vi.mocked(mcpConnectionManager.getConnectedIndexes).mockReturnValue([0]);
+            vi.mocked(mcpConnectionManager.getToolsByServerName).mockReturnValue(mockTools);
+            const result = await hubToolsService.searchTools('environment variable');
+            expect(result).toHaveProperty('Server 1');
+            const toolNames = result['Server 1'].tools.map((t) => t.name);
+            // All have "environment" in description, but match count varies:
+            // getEnv: desc "Get environment variables" — tokens "environment" matches, "variable" matches "variables" → 2
+            // envSetter: desc "Set environment values" — "environment" matches, "variable" matches... "values"? No, "variable" ≠ "values". So only 1 match.
+            // deleteFile: desc "Delete environment files" — "environment" matches, "variable"? No. Only 1 match.
+            // But both have 1 match. Sort order between them is stable but unspecified.
+            expect(toolNames[0]).toBe('getEnv'); // 2 matches, should be first
+        });
+        it('should apply default limit of 5', async () => {
+            const mockServers = [
+                {
+                    name: 'Server 1',
+                    config: {
+                        template: {
+                            type: 'stdio',
+                            command: 'test',
+                            args: [],
+                            env: {},
+                            headers: {},
+                            aggregatedTools: [],
+                            timeout: 30000,
+                            tags: {}
+                        },
+                        instances: [
+                            { id: '1', index: 0, enabled: true, args: [], env: {}, headers: {}, tags: {} }
+                        ],
+                        tagDefinitions: []
+                    }
+                }
+            ];
+            const mockTools = Array.from({ length: 10 }, (_, i) => ({
+                name: `tool${i}`,
+                description: 'A file handling tool',
+                serverName: 'Server 1'
+            }));
+            vi.mocked(hubManager.getAllServers).mockReturnValue(mockServers);
+            vi.mocked(hubManager.getServerInstancesByName).mockReturnValue(mockServers[0].config.instances);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockServers[0].config);
+            vi.mocked(mcpConnectionManager.getConnectedIndexes).mockReturnValue([0]);
+            vi.mocked(mcpConnectionManager.getToolsByServerName).mockReturnValue(mockTools);
+            const result = await hubToolsService.searchTools('file');
+            expect(result).toHaveProperty('Server 1');
+            expect(result['Server 1'].tools.length).toBeLessThanOrEqual(5);
+        });
+        it('should respect custom limit parameter', async () => {
+            const mockServers = [
+                {
+                    name: 'Server 1',
+                    config: {
+                        template: {
+                            type: 'stdio',
+                            command: 'test',
+                            args: [],
+                            env: {},
+                            headers: {},
+                            aggregatedTools: [],
+                            timeout: 30000,
+                            tags: {}
+                        },
+                        instances: [
+                            { id: '1', index: 0, enabled: true, args: [], env: {}, headers: {}, tags: {} }
+                        ],
+                        tagDefinitions: []
+                    }
+                }
+            ];
+            const mockTools = Array.from({ length: 10 }, (_, i) => ({
+                name: `tool${i}`,
+                description: 'A file handling tool',
+                serverName: 'Server 1'
+            }));
+            vi.mocked(hubManager.getAllServers).mockReturnValue(mockServers);
+            vi.mocked(hubManager.getServerInstancesByName).mockReturnValue(mockServers[0].config.instances);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockServers[0].config);
+            vi.mocked(mcpConnectionManager.getConnectedIndexes).mockReturnValue([0]);
+            vi.mocked(mcpConnectionManager.getToolsByServerName).mockReturnValue(mockTools);
+            const result = await hubToolsService.searchTools('file', 3);
+            expect(result).toHaveProperty('Server 1');
+            expect(result['Server 1'].tools.length).toBeLessThanOrEqual(3);
+        });
+        it('should return empty result when no tools match', async () => {
+            const mockServers = [
+                {
+                    name: 'Server 1',
+                    config: {
+                        template: {
+                            type: 'stdio',
+                            command: 'test',
+                            args: [],
+                            env: {},
+                            headers: {},
+                            aggregatedTools: [],
+                            timeout: 30000,
+                            tags: {}
+                        },
+                        instances: [
+                            { id: '1', index: 0, enabled: true, args: [], env: {}, headers: {}, tags: {} }
+                        ],
+                        tagDefinitions: []
+                    }
+                }
+            ];
+            const mockTools = [
+                { name: 'readFile', description: 'Read file contents', serverName: 'Server 1' }
+            ];
+            vi.mocked(hubManager.getAllServers).mockReturnValue(mockServers);
+            vi.mocked(hubManager.getServerInstancesByName).mockReturnValue(mockServers[0].config.instances);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockServers[0].config);
+            vi.mocked(mcpConnectionManager.getConnectedIndexes).mockReturnValue([0]);
+            vi.mocked(mcpConnectionManager.getToolsByServerName).mockReturnValue(mockTools);
+            const result = await hubToolsService.searchTools('zzznotfound');
+            expect(result).toEqual({});
+        });
+        it('should handle extra whitespace in query', async () => {
+            const mockServers = [
+                {
+                    name: 'Server 1',
+                    config: {
+                        template: {
+                            type: 'stdio',
+                            command: 'test',
+                            args: [],
+                            env: {},
+                            headers: {},
+                            aggregatedTools: [],
+                            timeout: 30000,
+                            tags: {}
+                        },
+                        instances: [
+                            { id: '1', index: 0, enabled: true, args: [], env: {}, headers: {}, tags: {} }
+                        ],
+                        tagDefinitions: []
+                    }
+                }
+            ];
+            const mockTools = [
+                { name: 'readFile', description: 'Read file contents', serverName: 'Server 1' }
+            ];
+            vi.mocked(hubManager.getAllServers).mockReturnValue(mockServers);
+            vi.mocked(hubManager.getServerInstancesByName).mockReturnValue(mockServers[0].config.instances);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockServers[0].config);
+            vi.mocked(mcpConnectionManager.getConnectedIndexes).mockReturnValue([0]);
+            vi.mocked(mcpConnectionManager.getToolsByServerName).mockReturnValue(mockTools);
+            const result = await hubToolsService.searchTools('  read   file  ');
+            expect(result).toHaveProperty('Server 1');
+        });
+        it('should cap limit at 10', async () => {
+            const mockServers = [
+                {
+                    name: 'Server 1',
+                    config: {
+                        template: {
+                            type: 'stdio',
+                            command: 'test',
+                            args: [],
+                            env: {},
+                            headers: {},
+                            aggregatedTools: [],
+                            timeout: 30000,
+                            tags: {}
+                        },
+                        instances: [
+                            { id: '1', index: 0, enabled: true, args: [], env: {}, headers: {}, tags: {} }
+                        ],
+                        tagDefinitions: []
+                    }
+                }
+            ];
+            const mockTools = Array.from({ length: 15 }, (_, i) => ({
+                name: `tool${i}`,
+                description: 'file tool',
+                serverName: 'Server 1'
+            }));
+            vi.mocked(hubManager.getAllServers).mockReturnValue(mockServers);
+            vi.mocked(hubManager.getServerInstancesByName).mockReturnValue(mockServers[0].config.instances);
+            vi.mocked(hubManager.getServerByName).mockReturnValue(mockServers[0].config);
+            vi.mocked(mcpConnectionManager.getConnectedIndexes).mockReturnValue([0]);
+            vi.mocked(mcpConnectionManager.getToolsByServerName).mockReturnValue(mockTools);
+            const result = await hubToolsService.searchTools('file', 100);
+            expect(result['Server 1'].tools.length).toBeLessThanOrEqual(10);
+        });
+    });
     describe('listResources', () => {
         it('should return use-guide resource even when no servers are connected', async () => {
             // Arrange
@@ -776,10 +1071,10 @@ describe('HubToolsService', () => {
             const result = await hubToolsService.readResource('hub://use-guide');
             // Assert
             expect(typeof result).toBe('string');
-            expect(result).toContain('# MCP Hub Lite Use Guide');
-            expect(result).toContain('Getting Started');
-            expect(result).toContain('Progressive Discovery Workflow');
-            expect(result).toContain('System Tools Reference');
+            expect(result).toContain('# MCP Hub Lite');
+            expect(result).toContain('快速上手');
+            expect(result).toContain('渐进式发现工作流');
+            expect(result).toContain('系统工具参考');
         });
         it('should throw error for invalid URI format', async () => {
             // Act & Assert

package/dist/server/tests/unit/utils/config.test.js

@@ -81,7 +81,8 @@ describe('ConfigManager', () => {
                         jsonPretty: true,
                         mcpCommDebug: false,
                         apiDebug: false,
-                        gatewayDebug: false
+                        gatewayDebug: false,
+                        showTraceContext: true
                     }
                 },
                 security: {
@@ -151,7 +152,8 @@ describe('ConfigManager', () => {
                         jsonPretty: true,
                         mcpCommDebug: false,
                         apiDebug: false,
-                        gatewayDebug: false
+                        gatewayDebug: false,
+                        showTraceContext: true
                     }
                 }
             });
@@ -196,7 +198,8 @@ describe('ConfigManager', () => {
                         jsonPretty: true,
                         mcpCommDebug: false,
                         apiDebug: false,
-                        gatewayDebug: false
+                        gatewayDebug: false,
+                        showTraceContext: true
                     }
                 }
             });
@@ -239,7 +242,8 @@ describe('ConfigManager', () => {
                         jsonPretty: true,
                         mcpCommDebug: false,
                         apiDebug: false,
-                        gatewayDebug: false
+                        gatewayDebug: false,
+                        showTraceContext: true
                     }
                 }
             };
@@ -409,7 +413,8 @@ describe('ConfigManager', () => {
                         jsonPretty: true,
                         mcpCommDebug: false,
                         apiDebug: false,
-                        gatewayDebug: false
+                        gatewayDebug: false,
+                        showTraceContext: true
                     }
                 },
                 security: {
@@ -463,7 +468,8 @@ describe('ConfigManager', () => {
                         jsonPretty: true,
                         mcpCommDebug: false,
                         apiDebug: false,
-                        gatewayDebug: false
+                        gatewayDebug: false,
+                        showTraceContext: true
                     }
                 }
             });
@@ -481,7 +487,8 @@ describe('ConfigManager', () => {
                         jsonPretty: true,
                         mcpCommDebug: false,
                         apiDebug: false,
-                        gatewayDebug: false
+                        gatewayDebug: false,
+                        showTraceContext: true
                     }
                 },
                 security: {

package/dist/server/tests/unit/utils/log-output.test.d.ts

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

package/dist/server/tests/unit/utils/log-output.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-output.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/utils/log-output.test.ts"],"names":[],"mappings":""}