@loop_ouroboros/mcp-hub-lite 1.0.0

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

@@ -0,0 +1,462 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { Logger, logWithColor } from '../../../src/utils/logger.js';
+import { setJsonPrettyConfigGetter, setDevModeEnabled } from '../../../src/utils/json-utils.js';
+describe('Logger', () => {
+    let logger;
+    let tempLogDir;
+    beforeEach(() => {
+        // Create temporary log directory
+        tempLogDir = path.join(os.tmpdir(), `logger-test-${Date.now()}`);
+        fs.mkdirSync(tempLogDir, { recursive: true });
+        // Reset config getter
+        setJsonPrettyConfigGetter(null);
+        // Reset dev mode flag
+        setDevModeEnabled(false);
+    });
+    afterEach(() => {
+        // Clean up temporary directory
+        if (fs.existsSync(tempLogDir)) {
+            fs.rmSync(tempLogDir, { recursive: true, force: true });
+        }
+        // Clean up mocks
+        vi.restoreAllMocks();
+    });
+    it('should create logger with default level', () => {
+        logger = new Logger();
+        expect(logger).toBeDefined();
+        // Note: Since logger is a private property, we cannot access it directly, but we can test through behavior
+    });
+    it('should create logger with specified level', () => {
+        logger = new Logger('debug');
+        expect(logger).toBeDefined();
+    });
+    it('should set log level correctly', () => {
+        logger = new Logger('info');
+        logger.setLevel('debug');
+        // Verify level setting (via internal method simulation)
+        const shouldLogSpy = vi.spyOn(logger, 'shouldLog');
+        logger.shouldLog('debug');
+        expect(shouldLogSpy).toHaveBeenCalledWith('debug');
+    });
+    it('should format timestamp correctly', () => {
+        logger = new Logger();
+        const testDate = new Date('2025-12-01T10:30:45.123Z');
+        const formatted = logger.formatTimestamp(testDate);
+        // Verify format is correct, but don't hardcode specific time values (timezone may affect)
+        expect(formatted).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}$/);
+    });
+    it('should format log level correctly', () => {
+        logger = new Logger();
+        expect(logger.formatLogLevel('debug')).toBe('DBG');
+        expect(logger.formatLogLevel('info')).toBe('INF');
+        expect(logger.formatLogLevel('warn')).toBe('WRN');
+        expect(logger.formatLogLevel('error')).toBe('ERR');
+    });
+    it('should format PID correctly', () => {
+        logger = new Logger();
+        expect(logger.formatPid(123)).toBe('PID:     123');
+        expect(logger.formatPid(123456)).toBe('PID:  123456');
+        expect(logger.formatPid(123456789)).toBe('PID:12345678'); // Test long PID truncation
+    });
+    it('should determine if message should be logged based on level', () => {
+        logger = new Logger('info');
+        // info level should log info, warn, error
+        expect(logger.shouldLog('info')).toBe(true);
+        expect(logger.shouldLog('warn')).toBe(true);
+        expect(logger.shouldLog('error')).toBe(true);
+        expect(logger.shouldLog('debug')).toBe(false);
+        // debug level should log all
+        logger.setLevel('debug');
+        expect(logger.shouldLog('debug')).toBe(true);
+    });
+    it('should create colored log message with server name', () => {
+        logger = new Logger();
+        const message = logger.createColoredLogMessage('info', 'test message', {
+            pid: 123,
+            serverName: 'test-server'
+        });
+        // Verify message contains correct components (don't verify specific timestamp)
+        expect(message).toMatch(/\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}\]/);
+        expect(message).toContain('[INF]');
+        expect(message).toContain('[PID:     123]');
+        expect(message).toContain('[test-server]');
+        expect(message).toContain('test message');
+    });
+    it('should create plain log message without server name', () => {
+        logger = new Logger();
+        const message = logger.createLogMessage('info', 'test message', {
+            pid: 123
+        });
+        // Verify message contains correct components (don't verify specific timestamp)
+        expect(message).toMatch(/\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}\]/);
+        expect(message).toContain('[INF]');
+        expect(message).toContain('[PID:     123]');
+        expect(message).toContain('[mcp-hub]');
+        expect(message).toContain('test message');
+    });
+    it('should format error objects correctly', () => {
+        logger = new Logger();
+        // Test Error object
+        const error = new Error('Test error');
+        error.stack = 'Error: Test error\n    at test (test.js:1:1)\n    at another (test.js:2:2)';
+        const formatted = logger.formatError(error);
+        expect(formatted).toContain('Test error');
+        expect(formatted).toContain('at test (test.js:1:1)');
+        // Test non-Error object
+        const stringError = 'string error';
+        const formattedString = logger.formatError(stringError);
+        expect(formattedString).toBe('string error');
+    });
+    it('should enable dev log when DEV_LOG_FILE environment variable is "true"', () => {
+        try {
+            // Set DEV_LOG_FILE environment variable
+            process.env.DEV_LOG_FILE = 'true';
+            // Mock fs and path modules to avoid file system operations
+            const mkdirSyncSpy = vi.spyOn(fs, 'mkdirSync').mockImplementation(() => undefined);
+            vi.spyOn(fs, 'existsSync').mockImplementation(() => false);
+            const createWriteStreamSpy = vi.spyOn(fs, 'createWriteStream').mockImplementation(() => {
+                return {
+                    write: vi.fn(),
+                    end: vi.fn(),
+                    close: vi.fn(),
+                    bytesWritten: 0,
+                    path: '',
+                    pending: false,
+                    writable: true,
+                    writableEnded: false,
+                    writableFinished: false,
+                    writableHighWaterMark: 16384,
+                    writableLength: 0,
+                    writableObjectMode: false,
+                    writableCorked: 0,
+                    destroyed: false
+                    // Add other necessary properties...
+                };
+            });
+            logger = new Logger();
+            expect(logger.logFileStream).toBeDefined();
+            // Verify file system operations were called
+            expect(mkdirSyncSpy).toHaveBeenCalled();
+            expect(createWriteStreamSpy).toHaveBeenCalled();
+        }
+        finally {
+            // Restore environment variable and mocks
+            delete process.env.DEV_LOG_FILE;
+            vi.restoreAllMocks();
+        }
+    });
+    it('should enable dev log when DEV_LOG_FILE environment variable is "1"', () => {
+        try {
+            // Set DEV_LOG_FILE environment variable to "1"
+            process.env.DEV_LOG_FILE = '1';
+            // Mock fs and path modules to avoid file system operations
+            vi.spyOn(fs, 'mkdirSync').mockImplementation(() => undefined);
+            vi.spyOn(fs, 'existsSync').mockImplementation(() => false);
+            vi.spyOn(fs, 'createWriteStream').mockImplementation(() => {
+                return {
+                    write: vi.fn(),
+                    end: vi.fn(),
+                    close: vi.fn(),
+                    destroyed: false
+                };
+            });
+            logger = new Logger();
+            expect(logger.logFileStream).toBeDefined();
+        }
+        finally {
+            // Restore environment variable and mocks
+            delete process.env.DEV_LOG_FILE;
+            vi.restoreAllMocks();
+        }
+    });
+    it('should NOT enable dev log when DEV_LOG_FILE environment variable is not set', () => {
+        try {
+            // Ensure DEV_LOG_FILE is not set
+            delete process.env.DEV_LOG_FILE;
+            logger = new Logger();
+            expect(logger.logFileStream).toBeNull();
+        }
+        finally {
+            // Restore mocks
+            vi.restoreAllMocks();
+        }
+    });
+    it('should NOT enable dev log when DEV_LOG_FILE environment variable is other values', () => {
+        try {
+            // Set DEV_LOG_FILE to a value that should not enable
+            process.env.DEV_LOG_FILE = 'false';
+            logger = new Logger();
+            expect(logger.logFileStream).toBeNull();
+        }
+        finally {
+            // Restore environment variable
+            delete process.env.DEV_LOG_FILE;
+            vi.restoreAllMocks();
+        }
+    });
+    it('should handle multiple arguments in log methods', () => {
+        logger = new Logger('debug');
+        // Mock console methods
+        const consoleDebugSpy = vi.spyOn(console, 'debug').mockImplementation(() => { });
+        const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+        const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        // Test debug method
+        logger.debug('test', 'arg1', 'arg2');
+        expect(consoleDebugSpy).toHaveBeenCalled();
+        // Test info method
+        logger.info('test', 'arg1', 'arg2');
+        expect(consoleInfoSpy).toHaveBeenCalled();
+        // Test warn method
+        logger.warn('test', 'arg1', 'arg2');
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        // Test error method
+        logger.error('test', 'arg1', 'arg2');
+        expect(consoleErrorSpy).toHaveBeenCalled();
+        // Restore console methods
+        consoleDebugSpy.mockRestore();
+        consoleInfoSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+    });
+    it('should respect log level filtering', () => {
+        logger = new Logger('warn');
+        const consoleDebugSpy = vi.spyOn(console, 'debug').mockImplementation(() => { });
+        const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+        const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        // debug and info should not be called
+        logger.debug('debug message');
+        logger.info('info message');
+        // warn and error should be called
+        logger.warn('warn message');
+        logger.error('error message');
+        expect(consoleDebugSpy).not.toHaveBeenCalled();
+        expect(consoleInfoSpy).not.toHaveBeenCalled();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(consoleErrorSpy).toHaveBeenCalled();
+        // Restore console methods
+        consoleDebugSpy.mockRestore();
+        consoleInfoSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+    });
+    it('should include traceId and spanId in log messages when provided', () => {
+        logger = new Logger();
+        // Test colored log message
+        const coloredMessage = logger.createColoredLogMessage('info', 'test message', {
+            pid: 123,
+            serverName: 'test-server',
+            traceId: '1234567890abcdef1234567890abcdef',
+            spanId: 'abcdef1234567890'
+        });
+        expect(coloredMessage).toContain('[TID:1234567890abcdef1234567890abcdef]');
+        expect(coloredMessage).toContain('[SID:abcdef1234567890]');
+        // Test plain text log message
+        const plainMessage = logger.createLogMessage('info', 'test message', {
+            pid: 123,
+            serverName: 'test-server',
+            traceId: '1234567890abcdef1234567890abcdef',
+            spanId: 'abcdef1234567890'
+        });
+        expect(plainMessage).toContain('[TID:1234567890abcdef1234567890abcdef]');
+        expect(plainMessage).toContain('[SID:abcdef1234567890]');
+    });
+    it('should handle log messages without traceId and spanId', () => {
+        logger = new Logger();
+        // Test colored log message
+        const coloredMessage = logger.createColoredLogMessage('info', 'test message', {
+            pid: 123,
+            serverName: 'test-server'
+        });
+        expect(coloredMessage).not.toContain('traceId');
+        expect(coloredMessage).not.toContain('spanId');
+        // Test plain text log message
+        const plainMessage = logger.createLogMessage('info', 'test message', {
+            pid: 123,
+            serverName: 'test-server'
+        });
+        expect(plainMessage).not.toContain('traceId');
+        expect(plainMessage).not.toContain('spanId');
+    });
+    it('should include traceId and spanId in serverLog', () => {
+        logger = new Logger('info');
+        const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+        logger.serverLog('info', 'test-server', 'server message', {
+            pid: 456,
+            traceId: '1234567890abcdef1234567890abcdef',
+            spanId: 'abcdef1234567890'
+        });
+        expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('[TID:1234567890abcdef1234567890abcdef]'));
+        expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('[SID:abcdef1234567890]'));
+        // Restore console methods
+        consoleInfoSpy.mockRestore();
+    });
+    it('should respect log level filtering in serverLog method', () => {
+        logger = new Logger('info');
+        const consoleDebugSpy = vi.spyOn(console, 'debug').mockImplementation(() => { });
+        const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+        const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        // debug should not be called (because level is info)
+        logger.serverLog('debug', 'test-server', 'debug message');
+        // info, warn, error should be called
+        logger.serverLog('info', 'test-server', 'info message');
+        logger.serverLog('warn', 'test-server', 'warn message');
+        logger.serverLog('error', 'test-server', 'error message');
+        expect(consoleDebugSpy).not.toHaveBeenCalled();
+        expect(consoleInfoSpy).toHaveBeenCalled();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(consoleErrorSpy).toHaveBeenCalled();
+        // Restore console methods
+        consoleDebugSpy.mockRestore();
+        consoleInfoSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+    });
+    it('should split multi-line messages in serverLog and log each line individually', () => {
+        logger = new Logger('info');
+        const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+        const multiLineMessage = 'line 1\nline 2\r\nline 3\n\n  \nline 4 (after empty lines)';
+        logger.serverLog('info', 'test-server', multiLineMessage);
+        // Should log 4 non-empty lines (empty lines and whitespace-only lines should be skipped)
+        expect(consoleInfoSpy).toHaveBeenCalledTimes(4);
+        expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('line 1'));
+        expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('line 2'));
+        expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('line 3'));
+        expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('line 4 (after empty lines)'));
+        consoleInfoSpy.mockRestore();
+    });
+    it('should handle single-line messages normally in serverLog', () => {
+        logger = new Logger('info');
+        const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+        logger.serverLog('info', 'test-server', 'single line message');
+        expect(consoleInfoSpy).toHaveBeenCalledTimes(1);
+        expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('single line message'));
+        consoleInfoSpy.mockRestore();
+    });
+    it('should write multi-line messages to file stream individually', () => {
+        logger = new Logger('info');
+        // Enable dev log to get a file stream
+        vi.spyOn(fs, 'mkdirSync').mockImplementation(() => undefined);
+        vi.spyOn(fs, 'existsSync').mockImplementation(() => false);
+        const writeSpy = vi.fn();
+        vi.spyOn(fs, 'createWriteStream').mockImplementation(() => {
+            return {
+                write: writeSpy,
+                end: vi.fn(),
+                close: vi.fn(),
+                destroyed: false
+            };
+        });
+        logger.enableDevLog();
+        const multiLineMessage = 'file line 1\nfile line 2\nfile line 3';
+        logger.serverLog('info', 'test-server', multiLineMessage);
+        // Should write 3 lines to the file stream
+        expect(writeSpy).toHaveBeenCalledTimes(3);
+        expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('file line 1'));
+        expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('file line 2'));
+        expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('file line 3'));
+        vi.restoreAllMocks();
+    });
+    it('should handle logWithColor function with traceId and spanId', () => {
+        // Reset logger instance to avoid interference between tests
+        const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+        logWithColor('colored message', 'plain message', {
+            pid: 123,
+            serverName: 'test-server',
+            traceId: '1234567890abcdef1234567890abcdef',
+            spanId: 'abcdef1234567890'
+        });
+        expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('[TID:1234567890abcdef1234567890abcdef]'));
+        expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('[SID:abcdef1234567890]'));
+        // Restore console methods
+        consoleInfoSpy.mockRestore();
+    });
+    it('should handle logWithColor function without context', () => {
+        // Reset logger instance to avoid interference between tests
+        const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+        logWithColor('colored message', 'plain message');
+        expect(consoleInfoSpy).toHaveBeenCalled();
+        // Restore console methods
+        consoleInfoSpy.mockRestore();
+    });
+    describe('dev log rotation', () => {
+        it('should create devLogRotator when enableDevLog is called', () => {
+            // Mock fs modules to avoid file system operations
+            vi.spyOn(fs, 'mkdirSync').mockImplementation(() => undefined);
+            vi.spyOn(fs, 'existsSync').mockImplementation(() => false);
+            const createWriteStreamSpy = vi.spyOn(fs, 'createWriteStream').mockImplementation(() => {
+                return {
+                    write: vi.fn(),
+                    end: vi.fn(),
+                    close: vi.fn(),
+                    destroyed: false
+                };
+            });
+            logger = new Logger();
+            logger.enableDevLog();
+            expect(logger.devLogRotator).toBeDefined();
+            createWriteStreamSpy.mockRestore();
+        });
+        it('should use timestamp-based log file naming for dev logs', () => {
+            // Mock fs modules
+            vi.spyOn(fs, 'mkdirSync').mockImplementation(() => undefined);
+            vi.spyOn(fs, 'existsSync').mockImplementation(() => false);
+            let capturedLogPath = '';
+            const createWriteStreamSpy = vi.spyOn(fs, 'createWriteStream').mockImplementation((path) => {
+                capturedLogPath = path;
+                return {
+                    write: vi.fn(),
+                    end: vi.fn(),
+                    close: vi.fn(),
+                    destroyed: false
+                };
+            });
+            logger = new Logger();
+            logger.enableDevLog();
+            // Verify the log path uses the new timestamp format: dev-server.YYYYMMDD_HHmmSSZZZ.log
+            expect(capturedLogPath).toMatch(/dev-server\.\d{8}_\d{9}\.log$/);
+            createWriteStreamSpy.mockRestore();
+        });
+        it('should accept custom rotator config in enableDevLog', () => {
+            // Mock fs modules
+            vi.spyOn(fs, 'mkdirSync').mockImplementation(() => undefined);
+            vi.spyOn(fs, 'existsSync').mockImplementation(() => false);
+            const createWriteStreamSpy = vi.spyOn(fs, 'createWriteStream').mockImplementation(() => {
+                return {
+                    write: vi.fn(),
+                    end: vi.fn(),
+                    close: vi.fn(),
+                    destroyed: false
+                };
+            });
+            logger = new Logger();
+            logger.enableDevLog({ rotationAge: '14d' });
+            expect(logger.devLogRotator).toBeDefined();
+            createWriteStreamSpy.mockRestore();
+        });
+        it('should not create multiple log streams when enableDevLog is called multiple times', () => {
+            // Mock fs modules
+            vi.spyOn(fs, 'mkdirSync').mockImplementation(() => undefined);
+            vi.spyOn(fs, 'existsSync').mockImplementation(() => false);
+            const createWriteStreamSpy = vi.spyOn(fs, 'createWriteStream').mockImplementation(() => {
+                return {
+                    write: vi.fn(),
+                    end: vi.fn(),
+                    close: vi.fn(),
+                    destroyed: false
+                };
+            });
+            logger = new Logger();
+            logger.enableDevLog();
+            logger.enableDevLog(); // Call again
+            // createWriteStream should only be called once
+            expect(createWriteStreamSpy).toHaveBeenCalledTimes(1);
+            createWriteStreamSpy.mockRestore();
+        });
+    });
+});

package/dist/server/tests/unit/utils/mcp-error-handler.test.d.ts

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

package/dist/server/tests/unit/utils/mcp-error-handler.test.d.ts.map

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

package/dist/server/tests/unit/utils/mcp-error-handler.test.js

@@ -0,0 +1,163 @@
+import { describe, it, expect } from 'vitest';
+import { MCPErrorHandler, MCPHubLiteErrorMap, MCPErrorsMiddleware } from '../../../src/utils/mcp-error-handler.js';
+describe('MCPErrorHandler', () => {
+    describe('toMCPError', () => {
+        it('should convert Error instance to MCPError', () => {
+            const error = new Error('Test error');
+            error.stack = 'Error: Test error\n    at test (test.js:1:1)';
+            error.name = 'TestError';
+            const mcpError = MCPErrorHandler.toMCPError(error);
+            expect(mcpError).toMatchObject({
+                code: -32001,
+                message: 'Test error',
+                data: {
+                    originalError: 'Test error',
+                    timestamp: expect.any(String)
+                }
+            });
+            expect(mcpError['x-mcp']).toMatchObject({
+                details: {
+                    stack: 'Error: Test error\n    at test (test.js:1:1)',
+                    name: 'TestError'
+                },
+                suggestedActions: ['Check server status', 'Retry request']
+            });
+        });
+        it('should convert CMDError to MCPError with proper mapping', () => {
+            const cmdError = {
+                code: 6001,
+                message: 'Gateway internal error',
+                data: null,
+                timestamp: '2025-12-01T10:30:00.000Z',
+                requestId: 'req-123',
+                error: {
+                    category: 'SYSTEM',
+                    severity: 'ERROR',
+                    context: { serverId: 'server-1' }
+                }
+            };
+            const mcpError = MCPErrorHandler.toMCPError(cmdError);
+            expect(mcpError.code).toBe(-32001); // mapped from 6001
+            expect(mcpError.message).toBe('Gateway internal error');
+            expect(mcpError.data).toBeNull();
+            expect(mcpError['x-mcp']).toMatchObject({
+                details: { serverId: 'server-1' },
+                suggestedActions: ['Refer to error details', 'Retry or contact administrator']
+            });
+        });
+        it('should handle unknown error type', () => {
+            // Test with a string that is not an Error or CMDError
+            const unknownError = 'unknown error string';
+            const mcpError = MCPErrorHandler.toMCPError(unknownError);
+            expect(mcpError).toMatchObject({
+                code: -32001,
+                message: 'Unknown error'
+            });
+            expect(mcpError['x-mcp']).toMatchObject({
+                suggestedActions: ['Retry request']
+            });
+        });
+    });
+    describe('mapCMDToMCPErrorCode', () => {
+        it('should map system errors (1000-1999) to -32001', () => {
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](1001)).toBe(-32001);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](1500)).toBe(-32001);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](1999)).toBe(-32001);
+        });
+        it('should map security errors (2000-2999) to -32806', () => {
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](2001)).toBe(-32806);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](2500)).toBe(-32806);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](2999)).toBe(-32806);
+        });
+        it('should map business errors (3000-3999) to -32602', () => {
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](3001)).toBe(-32602);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](3500)).toBe(-32602);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](3999)).toBe(-32602);
+        });
+        it('should map MCP Hub Lite gateway errors (6000-6999)', () => {
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](6001)).toBe(-32001);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](6002)).toBe(-32002);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](6003)).toBe(-32801);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](6004)).toBe(-32802);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](6005)).toBe(-32001); // default for unmapped codes
+        });
+        it('should return default -32001 for unknown error codes', () => {
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](9999)).toBe(-32001);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](0)).toBe(-32001);
+            expect(MCPErrorHandler['mapCMDToMCPErrorCode'](-1)).toBe(-32001);
+        });
+    });
+    describe('MCPHubLiteErrorMap', () => {
+        it('should have correct error code mappings', () => {
+            expect(MCPHubLiteErrorMap[6001]).toBe(-32001);
+            expect(MCPHubLiteErrorMap[6002]).toBe(-32002);
+            expect(MCPHubLiteErrorMap[6003]).toBe(-32801);
+            expect(MCPHubLiteErrorMap[6004]).toBe(-32802);
+            expect(MCPHubLiteErrorMap[6005]).toBe(-32803);
+        });
+    });
+    describe('MCPErrorsMiddleware', () => {
+        it('should handle backend MCP errors and convert non-standard errors', () => {
+            const response = {
+                jsonrpc: '2.0',
+                id: 'test-id',
+                error: new Error('Backend error')
+            };
+            const result = MCPErrorsMiddleware.handleBackendMCPErrors(response);
+            expect(result.jsonrpc).toBe('2.0');
+            expect(result.id).toBe('test-id');
+            expect(result.error).toBeDefined();
+            expect(result.error.code).toBe(-32001);
+            expect(result.error.message).toBe('Backend error');
+        });
+        it('should return standard MCP errors unchanged', () => {
+            const standardMCPError = {
+                code: -32801,
+                message: 'Tool not found',
+                data: { toolName: 'non-existent-tool' }
+            };
+            const response = {
+                jsonrpc: '2.0',
+                id: 'test-id',
+                error: standardMCPError
+            };
+            const result = MCPErrorsMiddleware.handleBackendMCPErrors(response);
+            expect(result).toBe(response); // should be the same object
+        });
+        it('should return response unchanged when no error', () => {
+            const response = {
+                jsonrpc: '2.0',
+                id: 'test-id',
+                result: { success: true }
+            };
+            const result = MCPErrorsMiddleware.handleBackendMCPErrors(response);
+            expect(result).toBe(response); // should be the same object
+        });
+    });
+    describe('isStandardMCPError', () => {
+        it('should identify standard MCP errors', () => {
+            const standardError = {
+                code: -32801,
+                message: 'Tool not found'
+            };
+            const isStandard = MCPErrorsMiddleware['isStandardMCPError'](standardError);
+            expect(isStandard).toBe(true);
+        });
+        it('should reject non-standard errors', () => {
+            const nonStandardError = {
+                code: 'invalid-code', // not a number
+                message: 'Invalid error'
+            };
+            const isStandard = MCPErrorsMiddleware['isStandardMCPError'](nonStandardError);
+            expect(isStandard).toBe(false);
+        });
+        it('should reject errors without message', () => {
+            const invalidError = {
+                code: -32801
+                // missing message
+            };
+            const isStandard = MCPErrorsMiddleware['isStandardMCPError'](invalidError);
+            expect(isStandard).toBe(false);
+        });
+    });
+});

package/dist/server/tests/unit/utils/request-context.test.d.ts

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

package/dist/server/tests/unit/utils/request-context.test.d.ts.map

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