@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

package/dist/server/tests/unit/config/config-loader-automatic-migration.test.js

@@ -0,0 +1,199 @@
+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 { loadConfig } from '../../../src/config/config-loader.js';
+import { SystemConfigSchema, isV1Config, isV1_1Config } from '../../../src/config/config.schema.js';
+import { migrateConfig, checkMigrationStatus } from '../../../src/config/config-migrator.js';
+describe('Config Loader Automatic Migration (Backward Compatible)', () => {
+    let tempDir;
+    let testConfigPath;
+    beforeEach(() => {
+        // Create temporary directory
+        const testId = `auto-migration-test-${Date.now()}-${Math.random().toString(36).substr(2, 5)}`;
+        tempDir = path.join(os.tmpdir(), testId);
+        fs.mkdirSync(tempDir, { recursive: true });
+        testConfigPath = path.join(tempDir, '.mcp-hub.json');
+    });
+    afterEach(() => {
+        // Clean up temporary directory
+        if (fs.existsSync(tempDir)) {
+            let retries = 3;
+            while (retries > 0) {
+                try {
+                    fs.rmSync(tempDir, { recursive: true, force: true });
+                    break;
+                }
+                catch {
+                    retries--;
+                    if (retries > 0) {
+                        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+                    }
+                }
+            }
+        }
+        vi.restoreAllMocks();
+    });
+    const createV1Config = () => ({
+        version: '1.0.0',
+        system: {
+            host: 'localhost',
+            port: 7788,
+            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: 1800000,
+            sessionFlushInterval: 900000,
+            maxConnections: 50
+        },
+        servers: {
+            'test-server-1': {
+                command: 'npx test-server-1',
+                args: ['--verbose'],
+                env: { NODE_ENV: 'development' },
+                enabled: true,
+                tags: { environment: 'dev' },
+                type: 'stdio',
+                timeout: 60000,
+                allowedTools: ['tool1', 'tool2'],
+                description: 'Test server 1'
+            }
+        },
+        tagDefinitions: []
+    });
+    const writeV1Config = () => {
+        const config = createV1Config();
+        fs.writeFileSync(testConfigPath, JSON.stringify(config, null, 2));
+    };
+    describe('Backward Compatible Loading (Default Behavior)', () => {
+        it('should load v1.0 config without migration by default', () => {
+            writeV1Config();
+            const originalContent = fs.readFileSync(testConfigPath, 'utf-8');
+            // Load config with default settings (no auto-migration)
+            const loadedConfig = loadConfig(testConfigPath);
+            // Verify loaded config is still v1.0 format
+            expect(loadedConfig.version).toBe('1.0.0');
+            expect(isV1Config(loadedConfig)).toBe(true);
+            expect(loadedConfig.servers).toBeDefined();
+            expect(loadedConfig.servers['test-server-1']).toBeDefined();
+            // Verify file was not modified
+            const currentContent = fs.readFileSync(testConfigPath, 'utf-8');
+            expect(currentContent).toBe(originalContent);
+        });
+        it('should validate loaded config with v1.0 schema', () => {
+            writeV1Config();
+            const loadedConfig = loadConfig(testConfigPath);
+            // Validate with Zod schema
+            const validation = SystemConfigSchema.safeParse(loadedConfig);
+            expect(validation.success).toBe(true);
+        });
+        it('should sort servers by name when loading', () => {
+            const v1Config = createV1Config();
+            v1Config.servers = {
+                'zebra-server': {
+                    enabled: true,
+                    type: 'stdio',
+                    args: [],
+                    timeout: 60000,
+                    allowedTools: []
+                },
+                'alpha-server': {
+                    enabled: true,
+                    type: 'stdio',
+                    args: [],
+                    timeout: 60000,
+                    allowedTools: []
+                },
+                'mike-server': {
+                    enabled: true,
+                    type: 'stdio',
+                    args: [],
+                    timeout: 60000,
+                    allowedTools: []
+                }
+            };
+            fs.writeFileSync(testConfigPath, JSON.stringify(v1Config, null, 2));
+            const loadedConfig = loadConfig(testConfigPath);
+            // Check that servers are sorted
+            const serverNames = Object.keys(loadedConfig.servers);
+            expect(serverNames).toEqual(['alpha-server', 'mike-server', 'zebra-server']);
+        });
+    });
+    describe('Optional Auto-Migration', () => {
+        it('should migrate v1.0 to v1.1 when autoMigrate=true', () => {
+            writeV1Config();
+            const originalContent = fs.readFileSync(testConfigPath, 'utf-8');
+            // Load config with auto-migration enabled
+            const loadedConfig = loadConfig(testConfigPath, true);
+            // Even though migration happened, the returned config should be v1.0 compatible
+            expect(loadedConfig.version).toBe('1.0.0');
+            expect(isV1Config(loadedConfig)).toBe(true);
+            // But the file on disk should be migrated to v1.1
+            const newContent = fs.readFileSync(testConfigPath, 'utf-8');
+            expect(newContent).not.toBe(originalContent);
+            const newParsed = JSON.parse(newContent);
+            expect(isV1_1Config(newParsed)).toBe(true);
+            expect(newParsed.version).toBe('1.1.0');
+        });
+        it('should create backup when migrating with autoMigrate=true', () => {
+            writeV1Config();
+            // Load config with auto-migration enabled
+            loadConfig(testConfigPath, true);
+            // Check for backup files in the same directory
+            const files = fs.readdirSync(tempDir);
+            const backupFiles = files.filter((f) => f.includes('.backup.'));
+            expect(backupFiles.length).toBeGreaterThan(0);
+            // Verify backup file contains original v1.0 config
+            const backupPath = path.join(tempDir, backupFiles[0]);
+            const backupContent = fs.readFileSync(backupPath, 'utf-8');
+            const backupParsed = JSON.parse(backupContent);
+            expect(isV1Config(backupParsed)).toBe(true);
+            expect(backupParsed.version).toBe('1.0.0');
+        });
+        it('should return v1.0 compatible config even when file is v1.1', () => {
+            // First, create a v1.1 file by migrating
+            writeV1Config();
+            loadConfig(testConfigPath, true);
+            // Now load again - file is already v1.1 but should return v1.0 compatible
+            const loadedConfig = loadConfig(testConfigPath);
+            expect(loadedConfig.version).toBe('1.0.0');
+            expect(isV1Config(loadedConfig)).toBe(true);
+            expect(loadedConfig.servers).toBeDefined();
+        });
+    });
+    describe('Direct Migration Functions', () => {
+        it('should check migration status correctly', () => {
+            writeV1Config();
+            const status = checkMigrationStatus(testConfigPath);
+            expect(status.exists).toBe(true);
+            expect(status.version).toBe('v1');
+            expect(status.canMigrate).toBe(true);
+        });
+        it('should perform dry run migration without modifying files', () => {
+            writeV1Config();
+            const originalContent = fs.readFileSync(testConfigPath, 'utf-8');
+            const result = migrateConfig(testConfigPath, {
+                dryRun: true,
+                createBackup: false,
+                validateAfterMigration: true
+            });
+            expect(result.success).toBe(true);
+            expect(result.migratedConfig).toBeDefined();
+            // Verify file wasn't modified
+            const currentContent = fs.readFileSync(testConfigPath, 'utf-8');
+            expect(currentContent).toBe(originalContent);
+        });
+    });
+});

package/dist/server/tests/unit/config/config-migrator.test.d.ts

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

package/dist/server/tests/unit/config/config-migrator.test.d.ts.map

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

package/dist/server/tests/unit/config/config-migrator.test.js

@@ -0,0 +1,316 @@
+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 { dryRunMigration, checkMigrationStatus, migrateConfig, rollbackMigration, resolveInstanceConfig, getEnabledInstances } from '../../../src/config/config-migrator.js';
+import { SystemConfigSchema, isLegacyV1Config } from '../../../src/config/config.schema.js';
+describe('Config Migrator', () => {
+    let tempDir;
+    let testConfigPath;
+    beforeEach(() => {
+        // Create temporary directory
+        const testId = `migration-test-${Date.now()}-${Math.random().toString(36).substr(2, 5)}`;
+        tempDir = path.join(os.tmpdir(), testId);
+        fs.mkdirSync(tempDir, { recursive: true });
+        testConfigPath = path.join(tempDir, '.mcp-hub.json');
+    });
+    afterEach(() => {
+        // Clean up temporary directory
+        if (fs.existsSync(tempDir)) {
+            let retries = 3;
+            while (retries > 0) {
+                try {
+                    fs.rmSync(tempDir, { recursive: true, force: true });
+                    break;
+                }
+                catch {
+                    retries--;
+                    if (retries > 0) {
+                        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+                    }
+                }
+            }
+        }
+        vi.restoreAllMocks();
+    });
+    const createLegacyV1Config = () => ({
+        version: '1.0.0',
+        system: {
+            host: 'localhost',
+            port: 7788,
+            language: 'zh',
+            theme: 'system',
+            logging: {
+                level: 'info',
+                rotationAge: '7d',
+                jsonPretty: true,
+                mcpCommDebug: false,
+                apiDebug: false
+            }
+        },
+        security: {
+            allowedNetworks: ['127.0.0.1'],
+            maxConcurrentConnections: 50,
+            connectionTimeout: 30000,
+            idleConnectionTimeout: 300000,
+            maxConnections: 50
+        },
+        servers: {
+            'test-server-1': {
+                command: 'npx test-server-1',
+                args: ['--verbose'],
+                env: { NODE_ENV: 'development' },
+                enabled: true,
+                tags: { environment: 'dev' },
+                type: 'stdio',
+                timeout: 60000,
+                aggregatedTools: ['tool1', 'tool2'],
+                description: 'Test server 1'
+            },
+            'test-server-2': {
+                command: 'npx test-server-2',
+                args: [],
+                enabled: false,
+                type: 'sse',
+                url: 'http://localhost:8080',
+                timeout: 60000,
+                aggregatedTools: [],
+                description: 'Test server 2'
+            }
+        },
+        tagDefinitions: []
+    });
+    const writeLegacyV1Config = () => {
+        const config = createLegacyV1Config();
+        fs.writeFileSync(testConfigPath, JSON.stringify(config, null, 2));
+    };
+    describe('checkMigrationStatus', () => {
+        it('should return "not found" for non-existent file', () => {
+            const result = checkMigrationStatus(testConfigPath);
+            expect(result.exists).toBe(false);
+            expect(result.version).toBe('unknown');
+            expect(result.canMigrate).toBe(false);
+        });
+        it('should detect v1.0 configuration', () => {
+            writeLegacyV1Config();
+            const result = checkMigrationStatus(testConfigPath);
+            expect(result.exists).toBe(true);
+            expect(result.version).toBe('v1');
+            expect(result.canMigrate).toBe(true);
+        });
+        it('should detect v1.1 configuration', () => {
+            const v1_1Config = {
+                version: '1.1.0',
+                system: {
+                    host: 'localhost',
+                    port: 7788,
+                    language: 'zh',
+                    theme: 'system',
+                    logging: {
+                        level: 'info',
+                        rotationAge: '7d',
+                        jsonPretty: true,
+                        mcpCommDebug: false,
+                        apiDebug: false
+                    }
+                },
+                security: {
+                    allowedNetworks: ['127.0.0.1'],
+                    maxConcurrentConnections: 50,
+                    connectionTimeout: 30000,
+                    idleConnectionTimeout: 300000,
+                    maxConnections: 50
+                },
+                servers: {},
+                tagDefinitions: []
+            };
+            fs.writeFileSync(testConfigPath, JSON.stringify(v1_1Config, null, 2));
+            const result = checkMigrationStatus(testConfigPath);
+            expect(result.exists).toBe(true);
+            expect(result.version).toBe('v1.1');
+            expect(result.canMigrate).toBe(false);
+        });
+    });
+    describe('dryRunMigration', () => {
+        it('should perform migration without modifying files', () => {
+            writeLegacyV1Config();
+            const originalContent = fs.readFileSync(testConfigPath, 'utf8');
+            const result = dryRunMigration(testConfigPath);
+            expect(result.success).toBe(true);
+            expect(result.migratedConfig).toBeDefined();
+            expect(result.backupPath).toBeUndefined();
+            // Verify file wasn't modified
+            const currentContent = fs.readFileSync(testConfigPath, 'utf8');
+            expect(currentContent).toBe(originalContent);
+        });
+        it('should convert servers to servers correctly', () => {
+            writeLegacyV1Config();
+            const result = dryRunMigration(testConfigPath);
+            expect(result.success).toBe(true);
+            expect(result.migratedConfig).toBeDefined();
+            const migrated = result.migratedConfig;
+            expect(migrated.version).toBe('1.1.0');
+            expect(migrated.servers).toBeDefined();
+            expect(Object.keys(migrated.servers)).toHaveLength(2);
+            expect(migrated.servers['test-server-1']).toBeDefined();
+            expect(migrated.servers['test-server-2']).toBeDefined();
+            // Check server 1
+            const server1 = migrated.servers['test-server-1'];
+            expect(server1.template.command).toBe('npx test-server-1');
+            expect(server1.template.args).toEqual(['--verbose']);
+            expect(server1.template.env).toEqual({ NODE_ENV: 'development' });
+            expect(server1.template.type).toBe('stdio');
+            expect(server1.instances[0].tags).toEqual({ environment: 'dev' });
+            expect(server1.instances).toHaveLength(1);
+            expect(server1.instances[0].id).toMatch(/test-server-1-[0-9a-f]{8}/);
+            expect(server1.instances[0].enabled).toBe(true);
+        });
+        it('should preserve system and security config', () => {
+            writeLegacyV1Config();
+            const v1Config = createLegacyV1Config();
+            const result = dryRunMigration(testConfigPath);
+            expect(result.success).toBe(true);
+            const migrated = result.migratedConfig;
+            expect(migrated.system).toEqual(v1Config.system);
+            expect(migrated.security).toEqual(v1Config.security);
+        });
+    });
+    describe('migrateConfig (actual migration)', () => {
+        it('should perform actual migration and validate the result', () => {
+            writeLegacyV1Config();
+            const originalContent = fs.readFileSync(testConfigPath, 'utf8');
+            const result = migrateConfig(testConfigPath, {
+                createBackup: true,
+                validateAfterMigration: true
+            });
+            expect(result.success).toBe(true);
+            expect(result.migratedConfig).toBeDefined();
+            expect(result.backupPath).toBeDefined();
+            // Verify file was modified to v1.1
+            const newContent = fs.readFileSync(testConfigPath, 'utf8');
+            expect(newContent).not.toBe(originalContent);
+            const migratedConfig = JSON.parse(newContent);
+            expect(isLegacyV1Config(migratedConfig)).toBe(false);
+            expect(migratedConfig.version).toBe('1.1.0');
+        });
+        it('should validate migrated config with v1.1 schema', () => {
+            writeLegacyV1Config();
+            const result = migrateConfig(testConfigPath, {
+                createBackup: false,
+                validateAfterMigration: true
+            });
+            expect(result.success).toBe(true);
+            expect(result.migratedConfig).toBeDefined();
+            // Validate with Zod schema
+            const validation = SystemConfigSchema.safeParse(result.migratedConfig);
+            expect(validation.success).toBe(true);
+        });
+    });
+    describe('rollbackMigration', () => {
+        it('should rollback to v1.0 using backup', () => {
+            writeLegacyV1Config();
+            const originalContent = fs.readFileSync(testConfigPath, 'utf8');
+            // Perform migration first
+            const migrationResult = migrateConfig(testConfigPath, {
+                createBackup: true,
+                validateAfterMigration: true
+            });
+            expect(migrationResult.success).toBe(true);
+            expect(migrationResult.backupPath).toBeDefined();
+            // Verify file is v1.1
+            const migratedContent = fs.readFileSync(testConfigPath, 'utf8');
+            expect(migratedContent).not.toBe(originalContent);
+            // Rollback
+            const rollbackResult = rollbackMigration(testConfigPath, migrationResult.backupPath);
+            expect(rollbackResult.success).toBe(true);
+            // Verify file is back to original
+            const rolledBackContent = fs.readFileSync(testConfigPath, 'utf8');
+            expect(rolledBackContent).toBe(originalContent);
+        });
+        it('should fail rollback for non-existent backup', () => {
+            writeLegacyV1Config();
+            const nonExistentBackup = path.join(tempDir, 'non-existent-backup.json');
+            const result = rollbackMigration(testConfigPath, nonExistentBackup);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('not found');
+        });
+    });
+    describe('v1.1 Configuration Helpers', () => {
+        describe('resolveInstanceConfig', () => {
+            it('should resolve instance configuration by merging template and instance', () => {
+                writeLegacyV1Config();
+                const migrationResult = dryRunMigration(testConfigPath);
+                expect(migrationResult.success).toBe(true);
+                const serverConfig = migrationResult.migratedConfig.servers['test-server-1'];
+                const resolved = resolveInstanceConfig(serverConfig);
+                expect(resolved).not.toBeNull();
+                expect(resolved.command).toBe('npx test-server-1');
+                expect(resolved.args).toEqual(['--verbose']);
+                expect(resolved.env).toEqual({ NODE_ENV: 'development' });
+                expect(resolved.type).toBe('stdio');
+                expect(resolved.tags).toEqual({ environment: 'dev' });
+                expect(resolved.enabled).toBe(true);
+            });
+            it('should resolve specific instance by ID', () => {
+                writeLegacyV1Config();
+                const migrationResult = dryRunMigration(testConfigPath);
+                expect(migrationResult.success).toBe(true);
+                const serverConfig = migrationResult.migratedConfig.servers['test-server-1'];
+                const instanceId = serverConfig.instances[0].id;
+                const resolved = resolveInstanceConfig(serverConfig, instanceId);
+                expect(resolved).not.toBeNull();
+                expect(resolved.command).toBe('npx test-server-1');
+            });
+            it('should return null for non-existent instance ID', () => {
+                writeLegacyV1Config();
+                const migrationResult = dryRunMigration(testConfigPath);
+                expect(migrationResult.success).toBe(true);
+                const serverConfig = migrationResult.migratedConfig.servers['test-server-1'];
+                const resolved = resolveInstanceConfig(serverConfig, 'non-existent-id');
+                expect(resolved).toBeNull();
+            });
+        });
+        describe('getEnabledInstances', () => {
+            it('should return only enabled instances', () => {
+                writeLegacyV1Config();
+                const migrationResult = dryRunMigration(testConfigPath);
+                expect(migrationResult.success).toBe(true);
+                const serverConfig = migrationResult.migratedConfig.servers['test-server-1'];
+                const enabledInstances = getEnabledInstances(serverConfig);
+                expect(enabledInstances).toHaveLength(1);
+                expect(enabledInstances[0].instance.enabled).toBe(true);
+                expect(enabledInstances[0].resolved).not.toBeNull();
+            });
+        });
+    });
+    describe('Migration Edge Cases', () => {
+        it('should handle empty servers list', () => {
+            const emptyV1Config = {
+                ...createLegacyV1Config(),
+                servers: {}
+            };
+            fs.writeFileSync(testConfigPath, JSON.stringify(emptyV1Config, null, 2));
+            const result = dryRunMigration(testConfigPath);
+            expect(result.success).toBe(true);
+            expect(result.migratedConfig.servers).toEqual({});
+        });
+        it('should handle server with minimal configuration', () => {
+            const minimalV1Config = {
+                ...createLegacyV1Config(),
+                servers: {
+                    'minimal-server': {
+                        enabled: true,
+                        type: 'stdio',
+                        args: [],
+                        timeout: 30000,
+                        aggregatedTools: []
+                    }
+                }
+            };
+            fs.writeFileSync(testConfigPath, JSON.stringify(minimalV1Config, null, 2));
+            const result = dryRunMigration(testConfigPath);
+            expect(result.success).toBe(true);
+            expect(result.migratedConfig.servers['minimal-server']).toBeDefined();
+        });
+    });
+});

package/dist/server/tests/unit/config/config-saver.test.d.ts

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

package/dist/server/tests/unit/config/config-saver.test.d.ts.map

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