@loop_ouroboros/mcp-hub-lite 1.2.9 → 1.3.1

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-manager-service.test.js

@@ -1,11 +1,10 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { HubManagerService } from '../../../src/services/hub-manager.service.js';
-import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
+import { mcpConnectionManager } from '../../../src/services/connection/index.js';
 import { configManager } from '../../../src/config/config-manager.js';
 // Mock resolveInstanceConfig to return a valid resolved config
 vi.mock('@config/config-migrator.js', () => ({
-    resolveInstanceConfig: vi.fn(),
-    getEnabledInstances: vi.fn()
+    resolveInstanceConfig: vi.fn()
 }));
 // Mock dependencies
 vi.mock('@config/config-manager.js', () => ({
@@ -23,13 +22,13 @@ vi.mock('@config/config-manager.js', () => ({
         removeServerInstance: vi.fn()
     }
 }));
-vi.mock('@services/mcp-connection-manager.js', () => ({
+vi.mock('@services/connection/index.js', () => ({
     mcpConnectionManager: {
         connect: vi.fn(),
         disconnect: vi.fn(() => Promise.resolve())
     }
 }));
-vi.mock('@utils/logger.js', () => ({
+vi.mock('@utils/logger/index.js', () => ({
     logger: {
         info: vi.fn(),
         error: vi.fn(),

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

@@ -1,10 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { HubToolsService } from '../../../src/services/hub-tools.service.js';
 import { hubManager } from '../../../src/services/hub-manager.service.js';
-import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
+import { mcpConnectionManager } from '../../../src/services/connection/index.js';
 // Mock dependencies
 vi.mock('@services/hub-manager.service.js');
-vi.mock('@services/mcp-connection-manager.js');
+vi.mock('@services/connection/index.js');
 describe('HubToolsService', () => {
     let hubToolsService;
     beforeEach(() => {
@@ -320,6 +320,82 @@ describe('HubToolsService', () => {
             });
             expect(servers).not.toHaveProperty('Disconnected Server');
         });
+        it('should include tag-match-unique servers with multiple connected instances', async () => {
+            // Arrange: 4-instance server with tag-match-unique strategy, all connected
+            const mockServers = [
+                {
+                    name: 'multi-instance-server',
+                    config: {
+                        template: {
+                            type: 'stdio',
+                            command: 'test-command',
+                            args: [],
+                            env: {},
+                            headers: {},
+                            aggregatedTools: [],
+                            timeout: 30000,
+                            description: 'Multi-instance test server',
+                            tags: {}
+                        },
+                        instances: [
+                            {
+                                id: 'inst-0',
+                                index: 0,
+                                enabled: false,
+                                args: [],
+                                env: {},
+                                headers: {},
+                                tags: { Env: 'dev' }
+                            },
+                            {
+                                id: 'inst-1',
+                                index: 1,
+                                enabled: false,
+                                args: [],
+                                env: {},
+                                headers: {},
+                                tags: { Env: 'test' }
+                            },
+                            {
+                                id: 'inst-2',
+                                index: 2,
+                                enabled: false,
+                                args: [],
+                                env: {},
+                                headers: {},
+                                tags: { Env: 'prod' }
+                            },
+                            {
+                                id: 'inst-3',
+                                index: 3,
+                                enabled: false,
+                                args: [],
+                                env: {},
+                                headers: {},
+                                tags: { Env: 'staging' }
+                            }
+                        ],
+                        tagDefinitions: [],
+                        instanceSelectionStrategy: 'tag-match-unique'
+                    }
+                }
+            ];
+            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, 1, 2, 3]);
+            vi.mocked(mcpConnectionManager.getStatus).mockReturnValue({
+                connected: true,
+                lastCheck: Date.now(),
+                toolsCount: 1,
+                resourcesCount: 0
+            });
+            // Act
+            const servers = await hubToolsService.listServers();
+            // Assert: tag-match-unique server with multiple connected instances must be included
+            expect(servers).toHaveProperty('multi-instance-server');
+            expect(servers['multi-instance-server']).toBe('Multi-instance test server');
+        });
     });
     describe('listToolsInServer', () => {
         it('should return tool summaries from a specific server (without inputSchema)', async () => {
@@ -700,10 +776,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":""}

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

@@ -0,0 +1,198 @@
+import { describe, it, expect } from 'vitest';
+import { hasDataUriImage, simplifyDataUriImages, simplifyImageContent, isToolsListResponse, formatMcpMessageForLogging } from '../../../src/utils/logger/log-output.js';
+import { setJsonPrettyConfigGetter, setDevModeEnabled } from '../../../src/utils/json-utils.js';
+describe('hasDataUriImage', () => {
+    it('should detect data:image/png;base64 in JSON', () => {
+        const json = JSON.stringify({
+            icons: [{ src: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUg==' }]
+        });
+        expect(hasDataUriImage(json)).toBe(true);
+    });
+    it('should detect data:image/jpeg;base64', () => {
+        const json = JSON.stringify({
+            icon: 'data:image/jpeg;base64,/9j/4AAQSkZJRg=='
+        });
+        expect(hasDataUriImage(json)).toBe(true);
+    });
+    it('should detect data:image/svg+xml;base64', () => {
+        const json = JSON.stringify({
+            icon: 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0i'
+        });
+        expect(hasDataUriImage(json)).toBe(true);
+    });
+    it('should return false for JSON without data:image', () => {
+        const json = JSON.stringify({ name: 'test', value: 123 });
+        expect(hasDataUriImage(json)).toBe(false);
+    });
+    it('should return false for non-base64 data URIs', () => {
+        const json = JSON.stringify({ icon: 'https://example.com/icon.png' });
+        expect(hasDataUriImage(json)).toBe(false);
+    });
+});
+describe('simplifyDataUriImages', () => {
+    it('should replace base64 payload with [Truncated]', () => {
+        const input = JSON.stringify({
+            icons: [{ src: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUg==' }]
+        });
+        const result = simplifyDataUriImages(input);
+        expect(result).toContain('data:image/png;base64,[Truncated]');
+        expect(result).not.toContain('iVBORw0KGgoAAAANSUhEUg==');
+    });
+    it('should handle multiple data URIs in one JSON', () => {
+        const input = JSON.stringify({
+            icons: [{ src: 'data:image/png;base64,AAAA' }, { src: 'data:image/png;base64,BBBB' }]
+        });
+        const result = simplifyDataUriImages(input);
+        expect(result).toContain('data:image/png;base64,[Truncated]');
+        expect(result).not.toContain('AAAA');
+        expect(result).not.toContain('BBBB');
+    });
+    it('should leave non-data-URI strings unchanged', () => {
+        const input = JSON.stringify({ name: 'test', url: 'https://example.com/img.png' });
+        const result = simplifyDataUriImages(input);
+        expect(result).toBe(input);
+    });
+    it('should produce valid JSON after simplification', () => {
+        const input = JSON.stringify({
+            icons: [{ src: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUg==' }]
+        });
+        const result = simplifyDataUriImages(input);
+        expect(() => JSON.parse(result)).not.toThrow();
+    });
+});
+describe('simplifyImageContent', () => {
+    it('should replace MCP image content data with [Truncated]', () => {
+        const message = {
+            jsonrpc: '2.0',
+            id: 1,
+            result: {
+                content: [{ type: 'image', data: 'base64payload', mimeType: 'image/png' }]
+            }
+        };
+        const json = JSON.stringify(message);
+        const result = simplifyImageContent(json);
+        expect(result).toContain('"[Truncated]"');
+        expect(result).not.toContain('base64payload');
+    });
+});
+describe('isToolsListResponse', () => {
+    it('should return true for tools/list response', () => {
+        const json = JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            result: { tools: [{ name: 'tool1' }] }
+        });
+        expect(isToolsListResponse(json)).toBe(true);
+    });
+    it('should return true for resources/list response', () => {
+        const json = JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            result: { resources: [{ uri: 'res1' }] }
+        });
+        expect(isToolsListResponse(json)).toBe(true);
+    });
+    it('should return false for initialize response with capabilities (not result.tools)', () => {
+        const json = JSON.stringify({
+            jsonrpc: '2.0',
+            id: 0,
+            result: {
+                capabilities: { tools: {}, resources: {} },
+                serverInfo: { name: 'test', version: '1.0' }
+            }
+        });
+        expect(isToolsListResponse(json)).toBe(false);
+    });
+});
+describe('formatMcpMessageForLogging', () => {
+    beforeEach(() => {
+        setJsonPrettyConfigGetter(null);
+        setDevModeEnabled(false);
+    });
+    it('should truncate data:image URIs in initialize response with icons', () => {
+        const message = {
+            jsonrpc: '2.0',
+            id: 0,
+            result: {
+                capabilities: {
+                    tools: {},
+                    resources: {}
+                },
+                protocolVersion: '2025-11-25',
+                serverInfo: {
+                    name: 'github-mcp-server',
+                    title: 'GitHub MCP Server',
+                    version: 'github-mcp-server/remote-abc123',
+                    icons: [
+                        {
+                            src: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABmJLR0QA/wD/AP+gvaeTAAADK0lEQVR',
+                            mimeType: 'image/png',
+                            theme: 'light'
+                        },
+                        {
+                            src: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABmJLR0QA/wD/AP+gvaeTAAAB8ElEQVR',
+                            mimeType: 'image/png',
+                            theme: 'dark'
+                        }
+                    ]
+                }
+            }
+        };
+        const result = formatMcpMessageForLogging(message);
+        // Must contain [Truncated] placeholder
+        expect(result).toContain('[Truncated]');
+        // Must NOT contain the raw base64 payload
+        expect(result).not.toContain('iVBORw0KGgoAAAANSUhEUg');
+        // Must still contain server info
+        expect(result).toContain('github-mcp-server');
+    });
+    it('should handle initialize response without icons normally', () => {
+        const message = {
+            jsonrpc: '2.0',
+            id: 0,
+            result: {
+                capabilities: { tools: {} },
+                serverInfo: { name: 'test-server', version: '1.0' }
+            }
+        };
+        const result = formatMcpMessageForLogging(message);
+        // Should be valid JSON (since isToolsListResponse returns null for empty capabilities,
+        // but now hasDataUriImage should be checked first and return false, then
+        // isToolsListResponse returns true and returns null, falling to stringifyForLogging)
+        expect(result).toContain('test-server');
+    });
+    it('should simplify tools/list response to count', () => {
+        const message = {
+            jsonrpc: '2.0',
+            id: 1,
+            result: { tools: [{ name: 't1' }, { name: 't2' }, { name: 't3' }] }
+        };
+        const result = formatMcpMessageForLogging(message);
+        expect(result).toBe('Returned 3 tools');
+    });
+    it('should simplify resources/list response to count', () => {
+        const message = {
+            jsonrpc: '2.0',
+            id: 1,
+            result: { resources: [{ uri: 'r1' }, { uri: 'r2' }] }
+        };
+        const result = formatMcpMessageForLogging(message);
+        expect(result).toBe('Returned 2 resources');
+    });
+    it('should not simplify capabilities response (output full JSON)', () => {
+        const message = {
+            jsonrpc: '2.0',
+            id: 1,
+            result: {
+                capabilities: {
+                    tools: { list: {}, call: {} },
+                    resources: { list: {} }
+                }
+            }
+        };
+        const result = formatMcpMessageForLogging(message);
+        // Capabilities are no longer simplified; expect full JSON output
+        expect(result).toContain('capabilities');
+        expect(result).toContain('list');
+    });
+});

package/dist/server/tests/unit/utils/log-rotator.test.js

@@ -79,21 +79,7 @@ describe('LogRotator', () => {
         const latest = logRotator.getLatestLogFilePath();
         expect(latest).toBeNull();
     });
-    it('should maintain backward compatibility with getCurrentLogFilePath', () => {
-        logRotator = new LogRotator(tempLogDir, 'mcp-hub', undefined, () => originalConfig);
-        // When no files exist, getCurrentLogFilePath will create a new path (but not the file)
-        const path1 = logRotator.getCurrentLogFilePath();
-        expect(path.basename(path1)).toMatch(/^mcp-hub\.\d{8}_\d{9}\.log$/);
-        // Actually create the file on disk
-        fs.writeFileSync(path1, 'test content 1');
-        // Create an older file
-        const oldFile = path.join(tempLogDir, 'mcp-hub.20260301_100000000.log');
-        fs.writeFileSync(oldFile, 'test content 2');
-        // When files exist, getCurrentLogFilePath should return the latest one
-        const path2 = logRotator.getCurrentLogFilePath();
-        expect(path2).toBe(path1); // Should return the newer one we just created
-    });
-    it('should get current log file path with custom base name', () => {
+    it('should create new log file path with custom base name', () => {
         logRotator = new LogRotator(tempLogDir, 'custom-log', undefined, () => originalConfig);
         const currentPath = logRotator.createNewLogFilePath();
         const basename = path.basename(currentPath);

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

@@ -2,7 +2,7 @@ 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 } from '../../../src/utils/logger.js';
+import { Logger } from '../../../src/utils/logger/index.js';
 import { setJsonPrettyConfigGetter, setDevModeEnabled } from '../../../src/utils/json-utils.js';
 import { createColoredLogMessage, createLogMessage, getCallerInfo, formatCallerInfo } from '../../../src/utils/logger/log-formatter.js';
 describe('Logger', () => {

package/dist/server/vitest.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../../vitest.config.ts"],"names":[],"mappings":";AAUA,wBA8CG"}
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../../vitest.config.ts"],"names":[],"mappings":";AAUA,wBA4CG"}

package/dist/server/vitest.config.js

@@ -44,8 +44,6 @@ export default defineConfig({
             'tests/unit/**/*.test.ts',
             'tests/integration/**/*.test.ts',
             'tests/contract/**/*.test.ts',
-            'tests/evaluation/**/*.test.ts',
-            'src/**/*.test.ts',
             'tests/temp/**/*.test.ts'
         ],
         exclude: ['tests/unit/frontend/**/*']

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loop_ouroboros/mcp-hub-lite",
-  "version": "1.2.9",
+  "version": "1.3.1",
   "description": "A lightweight MCP management platform designed for independent developers",
   "license": "MIT",
   "author": "loop_ouroboros",
@@ -68,7 +68,6 @@
     "element-plus": "^2.13.0",
     "eventsource": "^4.1.0",
     "fastify": "^5.6.2",
-    "open": "^11.0.0",
     "pinia": "^3.0.4",
     "undici": "^8.1.0",
     "vue": "^3.5.26",
@@ -96,7 +95,6 @@
     "npm-run-all": "^4.1.5",
     "postcss": "^8.5.6",
     "prettier": "^3.7.4",
-    "rimraf": "^6.1.2",
     "tailwindcss": "^3.4.19",
     "tsc-alias": "^1.8.16",
     "tsx": "^4.21.0",