@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/tests/unit/cli/server.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as serverModule from '../../../src/cli/server.js';
+// Mock dependencies
+vi.mock('@src/app.js', () => ({
+    buildApp: vi.fn()
+}));
+vi.mock('@pid/manager.js', () => ({
+    PidManager: {
+        writePid: vi.fn(),
+        removePid: vi.fn(),
+        getPid: vi.fn()
+    }
+}));
+vi.mock('@services/hub-manager.service.js', () => ({
+    hubManager: {
+        getAllServers: vi.fn(),
+        getServerInstances: vi.fn()
+    }
+}));
+describe('CLI Server Functions', () => {
+    let originalKill;
+    let mockKill;
+    beforeEach(() => {
+        // Mock process.kill to prevent actual process killing during tests
+        originalKill = process.kill;
+        mockKill = vi.fn();
+        // Use Object.defineProperty to safely override process.kill
+        Object.defineProperty(process, 'kill', {
+            value: mockKill,
+            writable: true,
+            configurable: true
+        });
+    });
+    afterEach(() => {
+        // Restore original methods
+        Object.defineProperty(process, 'kill', {
+            value: originalKill,
+            writable: true,
+            configurable: true
+        });
+        vi.clearAllMocks();
+    });
+    describe('startServer', () => {
+        it('should be defined', () => {
+            expect(serverModule.startServer).toBeDefined();
+        });
+    });
+    describe('stopServer', () => {
+        it('should be defined', () => {
+            expect(serverModule.stopServer).toBeDefined();
+        });
+    });
+    describe('getServerStatus', () => {
+        it('should be defined', () => {
+            expect(serverModule.getServerStatus).toBeDefined();
+        });
+    });
+    describe('restartServer', () => {
+        it('should be defined', () => {
+            expect(serverModule.restartServer).toBeDefined();
+        });
+    });
+    describe('listServers', () => {
+        it('should be defined', () => {
+            expect(serverModule.listServers).toBeDefined();
+        });
+    });
+});

package/dist/server/tests/unit/server/runner.test.d.ts

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

package/dist/server/tests/unit/server/runner.test.d.ts.map

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

package/dist/server/tests/unit/server/runner.test.js

@@ -0,0 +1,488 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { runServer } from '../../../src/server/runner.js';
+import { buildApp } from '../../../src/app.js';
+import { configManager } from '../../../src/config/config-manager.js';
+import { logger } from '../../../src/utils/logger.js';
+import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
+import { gateway } from '../../../src/services/gateway.service.js';
+import { PidManager } from '../../../src/pid/manager.js';
+import { checkPort } from '../../../src/utils/port-checker.js';
+// Mock all dependencies
+vi.mock('@src/app.js', () => ({
+    buildApp: vi.fn()
+}));
+vi.mock('@config/config-manager.js', () => ({
+    configManager: {
+        getConfig: vi.fn(),
+        getServers: vi.fn(),
+        getServerInstanceByName: vi.fn(),
+        addServerInstance: vi.fn()
+    }
+}));
+vi.mock('@utils/logger.js', () => ({
+    logger: {
+        info: vi.fn(),
+        error: vi.fn(),
+        setUseStderr: vi.fn(),
+        enableDevLog: vi.fn(),
+        setLevel: vi.fn()
+    },
+    LOG_MODULES: {
+        SERVER: { module: 'Server' }
+    }
+}));
+vi.mock('@services/mcp-connection-manager.js', () => ({
+    mcpConnectionManager: {
+        connect: vi.fn(),
+        disconnectAll: vi.fn()
+    }
+}));
+vi.mock('@services/gateway.service.js', () => ({
+    gateway: {
+        start: vi.fn()
+    }
+}));
+vi.mock('@pid/manager.js', () => ({
+    PidManager: {
+        writePid: vi.fn(),
+        removePid: vi.fn()
+    }
+}));
+vi.mock('@utils/port-checker.js', () => ({
+    checkPort: vi.fn()
+}));
+describe('Server Runner', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Reset process event listeners
+        process.removeAllListeners('SIGTERM');
+        process.removeAllListeners('SIGINT');
+    });
+    afterEach(() => {
+        // Clean up any remaining listeners
+        process.removeAllListeners('SIGTERM');
+        process.removeAllListeners('SIGINT');
+    });
+    describe('runServer function', () => {
+        it('should start server in HTTP mode successfully', async () => {
+            // Setup mocks
+            const mockApp = {
+                listen: vi.fn().mockResolvedValue(undefined),
+                close: vi.fn().mockResolvedValue(undefined)
+            };
+            vi.mocked(buildApp).mockResolvedValue(mockApp);
+            const mockConfig = {
+                version: '1.0.0',
+                system: {
+                    host: 'localhost',
+                    port: 3000,
+                    language: 'zh',
+                    theme: 'system',
+                    logging: {
+                        level: 'info',
+                        rotationAge: '7d',
+                        jsonPretty: true,
+                        mcpCommDebug: false,
+                        sessionDebug: false
+                    }
+                },
+                security: {
+                    allowedNetworks: ['127.0.0.1'],
+                    maxConcurrentConnections: 50,
+                    connectionTimeout: 30000,
+                    idleConnectionTimeout: 300000,
+                    sessionTimeout: 30 * 60 * 1000,
+                    sessionFlushInterval: 15 * 60 * 1000,
+                    maxConnections: 50
+                },
+                servers: {}
+            };
+            vi.mocked(configManager.getConfig).mockReturnValue(mockConfig);
+            vi.mocked(configManager.getServers).mockReturnValue([]);
+            vi.mocked(checkPort).mockResolvedValue({ inUse: false });
+            // Execute
+            await runServer({ stdio: false, port: 3000, host: 'localhost' });
+            // Verify
+            expect(buildApp).toHaveBeenCalled();
+            expect(mockApp.listen).toHaveBeenCalledWith({ port: 3000, host: 'localhost' });
+            expect(PidManager.writePid).toHaveBeenCalled();
+            expect(logger.info).toHaveBeenCalledWith('MCP Hub Lite Server running at http://localhost:3000', expect.any(Object));
+        });
+        it('should start server in stdio mode successfully', async () => {
+            // Setup mocks
+            const mockConfig = {
+                version: '1.0.0',
+                system: {
+                    host: 'localhost',
+                    port: 3000,
+                    language: 'zh',
+                    theme: 'system',
+                    logging: {
+                        level: 'info',
+                        rotationAge: '7d',
+                        jsonPretty: true,
+                        mcpCommDebug: false,
+                        sessionDebug: false
+                    }
+                },
+                security: {
+                    allowedNetworks: ['127.0.0.1'],
+                    maxConcurrentConnections: 50,
+                    connectionTimeout: 30000,
+                    idleConnectionTimeout: 300000,
+                    sessionTimeout: 30 * 60 * 1000,
+                    sessionFlushInterval: 15 * 60 * 1000,
+                    maxConnections: 50
+                },
+                servers: {}
+            };
+            vi.mocked(configManager.getConfig).mockReturnValue(mockConfig);
+            vi.mocked(configManager.getServers).mockReturnValue([]);
+            // Execute
+            await runServer({ stdio: true });
+            // Verify
+            expect(buildApp).not.toHaveBeenCalled();
+            expect(gateway.start).toHaveBeenCalled();
+            expect(PidManager.writePid).toHaveBeenCalled();
+            expect(logger.setUseStderr).toHaveBeenCalledWith(true);
+            expect(logger.info).toHaveBeenCalledWith('Starting in MCP Gateway mode (stdio)...', expect.any(Object));
+        });
+        it('should handle port already in use by self project', async () => {
+            // Setup mocks
+            const mockApp = { listen: vi.fn(), close: vi.fn() };
+            vi.mocked(buildApp).mockResolvedValue(mockApp);
+            const mockConfig = {
+                version: '1.0.0',
+                system: {
+                    host: 'localhost',
+                    port: 3000,
+                    language: 'zh',
+                    theme: 'system',
+                    logging: {
+                        level: 'info',
+                        rotationAge: '7d',
+                        jsonPretty: true,
+                        mcpCommDebug: false,
+                        sessionDebug: false
+                    }
+                },
+                security: {
+                    allowedNetworks: ['127.0.0.1'],
+                    maxConcurrentConnections: 50,
+                    connectionTimeout: 30000,
+                    idleConnectionTimeout: 300000,
+                    sessionTimeout: 30 * 60 * 1000,
+                    sessionFlushInterval: 15 * 60 * 1000,
+                    maxConnections: 50
+                },
+                servers: {}
+            };
+            vi.mocked(configManager.getConfig).mockReturnValue(mockConfig);
+            vi.mocked(configManager.getServers).mockReturnValue([]);
+            vi.mocked(checkPort).mockResolvedValue({
+                inUse: true,
+                isSelfProject: true,
+                pid: 1234
+            });
+            // Spy on process.exit
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
+                throw new Error('process.exit called');
+            }));
+            // Execute and expect error
+            await expect(runServer({ stdio: false, port: 3000, host: 'localhost' })).rejects.toThrow('process.exit called');
+            // Verify
+            expect(logger.error).toHaveBeenCalledWith('MCP Hub Lite is already running on port 3000 (PID: 1234)');
+            expect(exitSpy).toHaveBeenCalledWith(1);
+            // Restore
+            exitSpy.mockRestore();
+        });
+        it('should handle port already in use by other application', async () => {
+            // Setup mocks
+            const mockApp = { listen: vi.fn(), close: vi.fn() };
+            vi.mocked(buildApp).mockResolvedValue(mockApp);
+            const mockConfig = {
+                version: '1.0.0',
+                system: {
+                    host: 'localhost',
+                    port: 3000,
+                    language: 'zh',
+                    theme: 'system',
+                    logging: {
+                        level: 'info',
+                        rotationAge: '7d',
+                        jsonPretty: true,
+                        mcpCommDebug: false,
+                        sessionDebug: false
+                    }
+                },
+                security: {
+                    allowedNetworks: ['127.0.0.1'],
+                    maxConcurrentConnections: 50,
+                    connectionTimeout: 30000,
+                    idleConnectionTimeout: 300000,
+                    sessionTimeout: 30 * 60 * 1000,
+                    sessionFlushInterval: 15 * 60 * 1000,
+                    maxConnections: 50
+                },
+                servers: {}
+            };
+            vi.mocked(configManager.getConfig).mockReturnValue(mockConfig);
+            vi.mocked(configManager.getServers).mockReturnValue([]);
+            vi.mocked(checkPort).mockResolvedValue({
+                inUse: true,
+                isSelfProject: false,
+                pid: 5678,
+                processName: 'other-app',
+                commandLine: 'node other-app.js'
+            });
+            // Spy on process.exit
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
+                throw new Error('process.exit called');
+            }));
+            // Execute and expect error
+            await expect(runServer({ stdio: false, port: 3000, host: 'localhost' })).rejects.toThrow('process.exit called');
+            // Verify
+            expect(logger.error).toHaveBeenCalledWith('Port 3000 is already in use by another application:');
+            expect(logger.error).toHaveBeenCalledWith('  Process: other-app (PID: 5678)');
+            expect(logger.error).toHaveBeenCalledWith('  Command: node other-app.js');
+            expect(exitSpy).toHaveBeenCalledWith(1);
+            // Restore
+            exitSpy.mockRestore();
+        });
+        it('should auto-connect to enabled servers', async () => {
+            // Setup mocks
+            const mockApp = {
+                listen: vi.fn().mockResolvedValue(undefined),
+                close: vi.fn().mockResolvedValue(undefined)
+            };
+            vi.mocked(buildApp).mockResolvedValue(mockApp);
+            const mockConfig = {
+                version: '1.0.0',
+                system: {
+                    host: 'localhost',
+                    port: 3000,
+                    language: 'zh',
+                    theme: 'system',
+                    logging: {
+                        level: 'info',
+                        rotationAge: '7d',
+                        jsonPretty: true,
+                        mcpCommDebug: false,
+                        sessionDebug: false
+                    }
+                },
+                security: {
+                    allowedNetworks: ['127.0.0.1'],
+                    maxConcurrentConnections: 50,
+                    connectionTimeout: 30000,
+                    idleConnectionTimeout: 300000,
+                    sessionTimeout: 30 * 60 * 1000,
+                    sessionFlushInterval: 15 * 60 * 1000,
+                    maxConnections: 50
+                },
+                servers: {}
+            };
+            vi.mocked(configManager.getConfig).mockReturnValue(mockConfig);
+            vi.mocked(checkPort).mockResolvedValue({ inUse: false });
+            const mockServers = [
+                {
+                    name: 'enabled-server',
+                    config: {
+                        enabled: true,
+                        command: 'test-command',
+                        type: 'stdio',
+                        args: [],
+                        allowedTools: [],
+                        timeout: 30000
+                    }
+                },
+                {
+                    name: 'disabled-server',
+                    config: {
+                        enabled: false,
+                        command: 'test-command',
+                        type: 'stdio',
+                        args: [],
+                        allowedTools: [],
+                        timeout: 30000
+                    }
+                }
+            ];
+            vi.mocked(configManager.getServers).mockReturnValue(mockServers);
+            vi.mocked(configManager.getServerInstanceByName).mockImplementation((name) => {
+                if (name === 'enabled-server')
+                    return [];
+                return [{ id: 'instance-1', timestamp: Date.now(), hash: 'test-hash' }];
+            });
+            vi.mocked(configManager.addServerInstance).mockResolvedValue({
+                id: 'new-instance',
+                timestamp: Date.now(),
+                hash: 'test-hash'
+            });
+            // Execute
+            await runServer({ stdio: false, port: 3000, host: 'localhost' });
+            // Verify
+            // Only enabled server should be connected (1 call expected)
+            expect(mcpConnectionManager.connect).toHaveBeenCalledTimes(1);
+            // Call for enabled server with new instance
+            expect(mcpConnectionManager.connect).toHaveBeenCalledWith(expect.objectContaining({
+                enabled: true,
+                command: 'test-command',
+                id: 'new-instance'
+            }));
+        });
+        it('should handle graceful shutdown on SIGTERM', async () => {
+            // Setup mocks
+            const mockApp = {
+                listen: vi.fn().mockResolvedValue(undefined),
+                close: vi.fn().mockResolvedValue(undefined)
+            };
+            vi.mocked(buildApp).mockResolvedValue(mockApp);
+            const mockConfig = {
+                version: '1.0.0',
+                system: {
+                    host: 'localhost',
+                    port: 3000,
+                    language: 'zh',
+                    theme: 'light',
+                    logging: {
+                        level: 'info',
+                        rotationAge: '7d',
+                        jsonPretty: true,
+                        mcpCommDebug: false,
+                        sessionDebug: false
+                    }
+                },
+                security: {
+                    allowedNetworks: ['127.0.0.1'],
+                    maxConcurrentConnections: 50,
+                    connectionTimeout: 30000,
+                    idleConnectionTimeout: 300000,
+                    sessionTimeout: 30 * 60 * 1000,
+                    sessionFlushInterval: 15 * 60 * 1000,
+                    maxConnections: 50
+                },
+                servers: {}
+            };
+            vi.mocked(configManager.getConfig).mockReturnValue(mockConfig);
+            vi.mocked(configManager.getServers).mockReturnValue([]);
+            vi.mocked(checkPort).mockResolvedValue({ inUse: false });
+            // Spy on process.exit
+            const exitSpy = vi
+                .spyOn(process, 'exit')
+                .mockImplementation((() => { }));
+            // Start server
+            await runServer({ stdio: false, port: 3000, host: 'localhost' });
+            // Trigger SIGTERM
+            process.emit('SIGTERM');
+            // Wait for async operations
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            // Verify
+            expect(mcpConnectionManager.disconnectAll).toHaveBeenCalled();
+            expect(mockApp.close).toHaveBeenCalled();
+            expect(PidManager.removePid).toHaveBeenCalled();
+            expect(logger.info).toHaveBeenCalledWith('Server stopped gracefully', expect.any(Object));
+            expect(exitSpy).toHaveBeenCalledWith(0);
+            // Restore
+            exitSpy.mockRestore();
+        });
+        it('should handle graceful shutdown on SIGINT', async () => {
+            // Setup mocks
+            const mockApp = {
+                listen: vi.fn().mockResolvedValue(undefined),
+                close: vi.fn().mockResolvedValue(undefined)
+            };
+            vi.mocked(buildApp).mockResolvedValue(mockApp);
+            const mockConfig = {
+                version: '1.0.0',
+                system: {
+                    host: 'localhost',
+                    port: 3000,
+                    language: 'zh',
+                    theme: 'light',
+                    logging: {
+                        level: 'info',
+                        rotationAge: '7d',
+                        jsonPretty: true,
+                        mcpCommDebug: false,
+                        sessionDebug: false
+                    }
+                },
+                security: {
+                    allowedNetworks: ['127.0.0.1'],
+                    maxConcurrentConnections: 50,
+                    connectionTimeout: 30000,
+                    idleConnectionTimeout: 300000,
+                    sessionTimeout: 30 * 60 * 1000,
+                    sessionFlushInterval: 15 * 60 * 1000,
+                    maxConnections: 50
+                },
+                servers: {}
+            };
+            vi.mocked(configManager.getConfig).mockReturnValue(mockConfig);
+            vi.mocked(configManager.getServers).mockReturnValue([]);
+            vi.mocked(checkPort).mockResolvedValue({ inUse: false });
+            // Spy on process.exit
+            const exitSpy = vi
+                .spyOn(process, 'exit')
+                .mockImplementation((() => { }));
+            // Start server
+            await runServer({ stdio: false, port: 3000, host: 'localhost' });
+            // Trigger SIGINT
+            process.emit('SIGINT');
+            // Wait for async operations
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            // Verify
+            expect(mcpConnectionManager.disconnectAll).toHaveBeenCalled();
+            expect(mockApp.close).toHaveBeenCalled();
+            expect(PidManager.removePid).toHaveBeenCalled();
+            expect(logger.info).toHaveBeenCalledWith('Server stopped gracefully', expect.any(Object));
+            expect(exitSpy).toHaveBeenCalledWith(0);
+            // Restore
+            exitSpy.mockRestore();
+        });
+        it('should handle startup errors gracefully', async () => {
+            // Setup mocks to throw error
+            vi.mocked(buildApp).mockRejectedValue(new Error('Startup failed'));
+            const mockConfig = {
+                version: '1.0.0',
+                system: {
+                    host: 'localhost',
+                    port: 3000,
+                    language: 'zh',
+                    theme: 'light',
+                    logging: {
+                        level: 'info',
+                        rotationAge: '7d',
+                        jsonPretty: true,
+                        mcpCommDebug: false,
+                        sessionDebug: false
+                    }
+                },
+                security: {
+                    allowedNetworks: ['127.0.0.1'],
+                    maxConcurrentConnections: 50,
+                    connectionTimeout: 30000,
+                    idleConnectionTimeout: 300000,
+                    sessionTimeout: 30 * 60 * 1000,
+                    sessionFlushInterval: 15 * 60 * 1000,
+                    maxConnections: 50
+                },
+                servers: {}
+            };
+            vi.mocked(configManager.getConfig).mockReturnValue(mockConfig);
+            // Spy on process.exit
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
+                throw new Error('process.exit called');
+            }));
+            // Execute and expect error
+            await expect(runServer({ stdio: false, port: 3000, host: 'localhost' })).rejects.toThrow('process.exit called');
+            // Verify
+            expect(logger.error).toHaveBeenCalledWith('Failed to start server:', expect.any(Error), expect.any(Object));
+            expect(PidManager.removePid).toHaveBeenCalled();
+            expect(exitSpy).toHaveBeenCalledWith(1);
+            // Restore
+            exitSpy.mockRestore();
+        });
+    });
+});

package/dist/server/tests/unit/server/setup.d.ts

@@ -0,0 +1,2 @@
+export declare function setupServerTests(): void;
+//# sourceMappingURL=setup.d.ts.map

package/dist/server/tests/unit/server/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/server/setup.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,SAgB/B"}

package/dist/server/tests/unit/server/setup.js

@@ -0,0 +1,21 @@
+// Test setup for server module tests
+import { vi } from 'vitest';
+// Global test setup for server tests
+export function setupServerTests() {
+    // Mock any global dependencies needed for server tests
+    vi.mock('fs', () => ({
+        promises: {
+            readFile: vi.fn(),
+            writeFile: vi.fn(),
+            unlink: vi.fn(),
+            stat: vi.fn()
+        }
+    }));
+    vi.mock('path', () => ({
+        resolve: vi.fn(),
+        join: vi.fn(),
+        dirname: vi.fn()
+    }));
+}
+// Call setup function
+setupServerTests();

package/dist/server/tests/unit/services/gateway-logging.test.d.ts

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

package/dist/server/tests/unit/services/gateway-logging.test.d.ts.map

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

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

@@ -0,0 +1,47 @@
+import { describe, test, expect } from 'vitest';
+import { GatewayService } from '../../../src/services/gateway.service.js';
+describe('GatewayService Logging Helpers', () => {
+    // Access private methods using type assertion for testing
+    const gateway = new GatewayService();
+    test('formatToolArgs should handle simple objects', () => {
+        const args = { foo: 'bar', num: 42 };
+        const result = gateway.formatToolArgs(args);
+        expect(result).toContain('foo');
+        expect(result).toContain('bar');
+        expect(result).toContain('42');
+    });
+    test('formatToolArgs should truncate long strings', () => {
+        const args = { data: 'a'.repeat(1000) };
+        const result = gateway.formatToolArgs(args);
+        expect(result).toContain('... [truncated]');
+        expect(result.length).toBeLessThan(1000);
+    });
+    test('formatToolArgs should handle circular references', () => {
+        // Create object with circular reference for testing
+        const obj = { name: 'test' };
+        obj.self = obj;
+        const result = gateway.formatToolArgs(obj);
+        expect(result).toContain('[Circular Reference]');
+    });
+    test('formatToolArgs should handle formatting errors gracefully', () => {
+        // Create an object with custom toJSON that throws
+        const args = {
+            get bad() {
+                throw new Error('test error');
+            }
+        };
+        const result = gateway.formatToolArgs(args);
+        expect(result).toContain('[Error formatting args:');
+    });
+    test('formatToolResponse should handle valid responses', () => {
+        const response = { content: [{ type: 'text', text: 'Hello' }] };
+        const result = gateway.formatToolResponse(response);
+        expect(result).toContain('Hello');
+    });
+    test('formatToolResponse should truncate large responses', () => {
+        const response = { content: 'a'.repeat(3000) };
+        const result = gateway.formatToolResponse(response);
+        expect(result).toContain('... [truncated]');
+        expect(result.length).toBeLessThan(2500);
+    });
+});

package/dist/server/tests/unit/services/hub-manager-service.test.d.ts

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

package/dist/server/tests/unit/services/hub-manager-service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hub-manager-service.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/services/hub-manager-service.test.ts"],"names":[],"mappings":""}