@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

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

@@ -2,6 +2,11 @@ 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 { 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()
+}));
 // Mock dependencies
 vi.mock('@config/config-manager.js', () => ({
     ConfigManager: vi.fn(),
@@ -13,7 +18,7 @@ vi.mock('@config/config-manager.js', () => ({
         updateServer: vi.fn(),
         removeServer: vi.fn(),
         addServerInstance: vi.fn(),
-        getServerInstanceByName: vi.fn(),
+        getServerInstancesByName: vi.fn(),
         updateServerInstance: vi.fn(),
         removeServerInstance: vi.fn()
     }
@@ -32,6 +37,12 @@ vi.mock('@utils/logger.js', () => ({
     },
     LOG_MODULES: {}
 }));
+vi.mock('@services/event-bus.service.js', () => ({
+    eventBus: {
+        publish: vi.fn()
+    },
+    EventTypes: {}
+}));
 describe('HubManagerService', () => {
     let service;
     beforeEach(() => {
@@ -39,86 +50,138 @@ describe('HubManagerService', () => {
         service = new HubManagerService(configManager);
     });
     it('should auto-connect when adding an enabled server instance', async () => {
+        // Import the mocked module
+        const { resolveInstanceConfig } = await import('../../../src/config/config-migrator.js');
         const serverName = 'Test Server';
         const serverBaseConfig = {
-            type: 'stdio',
-            command: 'node',
-            args: [],
-            enabled: true,
-            allowedTools: [],
-            timeout: 30000
+            template: {
+                type: 'stdio',
+                command: 'node',
+                args: [],
+                env: {},
+                headers: {},
+                aggregatedTools: [],
+                timeout: 30000
+            },
+            instances: [],
+            tagDefinitions: []
         };
         const serverInstanceConfig = {
             id: 'test-server',
-            timestamp: Date.now(),
-            hash: 'test-hash'
+            enabled: true,
+            args: [],
+            env: {},
+            headers: {},
+            tags: {}
         };
         vi.mocked(configManager.addServer).mockResolvedValue(serverBaseConfig);
         vi.mocked(configManager.addServerInstance).mockResolvedValue(serverInstanceConfig);
         vi.mocked(configManager.getServerByName).mockReturnValue(serverBaseConfig);
-        await service.addServer(serverName, serverBaseConfig);
+        // Mock resolveInstanceConfig to return enabled = true
+        vi.mocked(resolveInstanceConfig).mockReturnValue({
+            command: 'node',
+            args: [],
+            type: 'stdio',
+            timeout: 30000,
+            aggregatedTools: [],
+            tags: {},
+            enabled: true
+        });
+        await service.addServer(serverName, serverBaseConfig.template);
         await service.addServerInstance(serverName, serverInstanceConfig);
-        expect(configManager.addServer).toHaveBeenCalledWith(serverName, serverBaseConfig);
-        expect(configManager.addServerInstance).toHaveBeenCalledWith(serverName, serverInstanceConfig);
+        expect(configManager.addServer).toHaveBeenCalled();
+        expect(configManager.addServerInstance).toHaveBeenCalled();
         expect(mcpConnectionManager.connect).toHaveBeenCalled();
     });
     it('should NOT auto-connect when adding a disabled server instance', async () => {
+        // Import the mocked module
+        const { resolveInstanceConfig } = await import('../../../src/config/config-migrator.js');
         const serverName = 'Disabled Server';
         const serverBaseConfig = {
-            type: 'stdio',
-            command: 'node',
-            args: [],
-            enabled: false,
-            allowedTools: [],
-            timeout: 30000
+            template: {
+                type: 'stdio',
+                command: 'node',
+                args: [],
+                env: {},
+                headers: {},
+                aggregatedTools: [],
+                timeout: 30000
+            },
+            instances: [],
+            tagDefinitions: []
         };
         const serverInstanceConfig = {
             id: 'test-server-disabled',
-            name: serverName,
-            timestamp: Date.now(),
-            hash: 'test-hash'
+            enabled: false,
+            args: [],
+            env: {},
+            headers: {},
+            tags: {}
         };
         vi.mocked(configManager.addServer).mockResolvedValue(serverBaseConfig);
         vi.mocked(configManager.addServerInstance).mockResolvedValue(serverInstanceConfig);
         vi.mocked(configManager.getServerByName).mockReturnValue(serverBaseConfig);
-        await service.addServer(serverName, serverBaseConfig);
+        // Mock resolveInstanceConfig to return enabled = false
+        vi.mocked(resolveInstanceConfig).mockReturnValue({
+            command: 'node',
+            args: [],
+            type: 'stdio',
+            timeout: 30000,
+            aggregatedTools: [],
+            tags: {},
+            enabled: false
+        });
+        await service.addServer(serverName, serverBaseConfig.template);
         await service.addServerInstance(serverName, serverInstanceConfig);
-        expect(configManager.addServer).toHaveBeenCalledWith(serverName, serverBaseConfig);
-        expect(configManager.addServerInstance).toHaveBeenCalledWith(serverName, serverInstanceConfig);
+        expect(configManager.addServer).toHaveBeenCalled();
+        expect(configManager.addServerInstance).toHaveBeenCalled();
         expect(mcpConnectionManager.connect).not.toHaveBeenCalled();
     });
     it('should call disconnect when removing a server', async () => {
         const serverName = 'Test Server';
         const serverConfig = {
-            type: 'stdio',
-            command: 'node',
-            args: [],
-            enabled: true,
-            allowedTools: [],
-            timeout: 30000
+            template: {
+                type: 'stdio',
+                command: 'node',
+                args: [],
+                env: {},
+                headers: {},
+                aggregatedTools: [],
+                timeout: 30000
+            },
+            instances: [],
+            tagDefinitions: []
         };
         vi.mocked(configManager.getServerByName).mockReturnValue(serverConfig);
-        vi.mocked(configManager.removeServer).mockResolvedValue();
-        vi.mocked(configManager.getServerInstanceByName).mockReturnValue([
+        vi.mocked(configManager.removeServer).mockResolvedValue(true);
+        vi.mocked(configManager.getServerInstancesByName).mockReturnValue([
             {
                 id: 'test-server-instance',
-                timestamp: Date.now(),
-                hash: 'test-hash'
+                enabled: true,
+                args: [],
+                env: {},
+                headers: {},
+                tags: {}
             }
         ]);
         await service.removeServer(serverName);
         expect(configManager.removeServer).toHaveBeenCalledWith(serverName);
-        expect(mcpConnectionManager.disconnect).toHaveBeenCalledWith('test-server-instance');
+        expect(mcpConnectionManager.disconnect).toHaveBeenCalledWith(serverName, 0);
     });
     it('should get server by name', async () => {
         const serverName = 'Test Server';
         const serverBaseConfig = {
-            type: 'stdio',
-            command: 'test',
-            args: [],
-            enabled: true,
-            allowedTools: [],
-            timeout: 30000
+            template: {
+                type: 'stdio',
+                command: 'test',
+                args: [],
+                env: {},
+                headers: {},
+                aggregatedTools: [],
+                timeout: 30000
+            },
+            instances: [],
+            tagDefinitions: []
         };
         vi.mocked(configManager.getServerByName).mockReturnValue(serverBaseConfig);
         const server = service.getServerByName(serverName);
@@ -129,12 +192,15 @@ describe('HubManagerService', () => {
         const serverName = 'Test Server';
         const serverInstanceConfig = {
             id: 'test-instance',
-            timestamp: Date.now(),
-            hash: 'test-hash'
+            enabled: true,
+            args: [],
+            env: {},
+            headers: {},
+            tags: {}
         };
-        vi.mocked(configManager.getServerInstanceByName).mockReturnValue([serverInstanceConfig]);
-        const instances = service.getServerInstanceByName(serverName);
+        vi.mocked(configManager.getServerInstancesByName).mockReturnValue([serverInstanceConfig]);
+        const instances = service.getServerInstancesByName(serverName);
         expect(instances).toEqual([serverInstanceConfig]);
-        expect(configManager.getServerInstanceByName).toHaveBeenCalledWith(serverName);
+        expect(configManager.getServerInstancesByName).toHaveBeenCalledWith(serverName);
     });
 });

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

@@ -9,7 +9,7 @@ vi.mock('@services/hub-manager.service.js', () => ({
         getServerById: vi.fn(),
         getServerByName: vi.fn(),
         getServerInstances: vi.fn(),
-        getServerInstanceByName: vi.fn(),
+        getServerInstancesByName: vi.fn(),
         addServer: vi.fn(),
         addServerInstance: vi.fn(),
         updateServer: vi.fn(),
@@ -35,12 +35,18 @@ describe('Server API Routes', () => {
                 id: '1',
                 name: 'test',
                 config: {
-                    type: 'stdio',
-                    command: 'test',
-                    args: [],
-                    enabled: true,
-                    allowedTools: [],
-                    timeout: 30000
+                    template: {
+                        type: 'stdio',
+                        command: 'test',
+                        args: [],
+                        env: {},
+                        headers: {},
+                        aggregatedTools: [],
+                        timeout: 30000,
+                        tags: {}
+                    },
+                    instances: [],
+                    tagDefinitions: []
                 }
             }
         ];
@@ -59,17 +65,21 @@ describe('Server API Routes', () => {
                 command: 'node',
                 args: [],
                 env: {},
-                enabled: true
+                headers: {}
             }
         };
         const createdServer = {
-            type: 'stdio',
-            command: 'node',
-            args: [],
-            env: {},
-            enabled: true,
-            allowedTools: [],
-            timeout: 30000
+            template: {
+                type: 'stdio',
+                command: 'node',
+                args: [],
+                env: {},
+                headers: {},
+                aggregatedTools: [],
+                timeout: 30000
+            },
+            instances: [],
+            tagDefinitions: []
         };
         vi.mocked(hubManager.addServer).mockReturnValue(Promise.resolve(createdServer));
         const response = await app.inject({

package/dist/server/tests/unit/services/hub-tools/instance-selector.test.d.ts

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

package/dist/server/tests/unit/services/hub-tools/instance-selector.test.d.ts.map

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

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

@@ -0,0 +1,195 @@
+import { describe, it, expect } from 'vitest';
+import { InstanceSelector } from '../../../../src/services/hub-tools/instance-selector.js';
+describe('InstanceSelector', () => {
+    const baseTemplate = {
+        type: 'stdio',
+        command: 'test-command',
+        args: [],
+        env: {},
+        headers: {},
+        timeout: 60000,
+        aggregatedTools: []
+    };
+    const baseInstance = {
+        enabled: true,
+        args: [],
+        env: {},
+        headers: {},
+        tags: {}
+    };
+    describe('random strategy', () => {
+        it('should select random instance from enabled instances', () => {
+            const config = {
+                template: {
+                    ...baseTemplate,
+                    instanceSelectionStrategy: 'random'
+                },
+                instances: [
+                    { ...baseInstance, id: '1', index: 0, enabled: true },
+                    { ...baseInstance, id: '2', index: 1, enabled: true },
+                    { ...baseInstance, id: '3', index: 2, enabled: false }
+                ],
+                tagDefinitions: []
+            };
+            const selected = InstanceSelector.selectInstance('test-server', config);
+            expect(selected).toBeDefined();
+            expect(['1', '2']).toContain(selected.id);
+        });
+        it('should return undefined when no enabled instances', () => {
+            const config = {
+                template: {
+                    ...baseTemplate,
+                    instanceSelectionStrategy: 'random'
+                },
+                instances: [
+                    { ...baseInstance, id: '1', index: 0, enabled: false },
+                    { ...baseInstance, id: '2', index: 1, enabled: false }
+                ],
+                tagDefinitions: []
+            };
+            const selected = InstanceSelector.selectInstance('test-server', config);
+            expect(selected).toBeUndefined();
+        });
+    });
+    describe('round-robin strategy', () => {
+        it('should cycle through enabled instances', () => {
+            const config = {
+                template: {
+                    ...baseTemplate,
+                    instanceSelectionStrategy: 'round-robin'
+                },
+                instances: [
+                    { ...baseInstance, id: '1', index: 0, enabled: true },
+                    { ...baseInstance, id: '2', index: 1, enabled: true },
+                    { ...baseInstance, id: '3', index: 2, enabled: true }
+                ],
+                tagDefinitions: []
+            };
+            const selected1 = InstanceSelector.selectInstance('test-server-rr', config);
+            const selected2 = InstanceSelector.selectInstance('test-server-rr', config);
+            const selected3 = InstanceSelector.selectInstance('test-server-rr', config);
+            const selected4 = InstanceSelector.selectInstance('test-server-rr', config);
+            expect(selected1.id).toBe('1');
+            expect(selected2.id).toBe('2');
+            expect(selected3.id).toBe('3');
+            expect(selected4.id).toBe('1');
+        });
+    });
+    describe('tag-match-unique strategy', () => {
+        it('should select instance that uniquely matches tags', () => {
+            const config = {
+                template: {
+                    ...baseTemplate,
+                    instanceSelectionStrategy: 'tag-match-unique'
+                },
+                instances: [
+                    { ...baseInstance, id: '1', index: 0, tags: { env: 'dev', region: 'us' } },
+                    { ...baseInstance, id: '2', index: 1, tags: { env: 'prod', region: 'us' } },
+                    { ...baseInstance, id: '3', index: 2, tags: { env: 'prod', region: 'eu' } }
+                ],
+                tagDefinitions: []
+            };
+            const selected = InstanceSelector.selectInstance('test-server', config, {
+                tags: { env: 'prod', region: 'us' }
+            });
+            expect(selected).toBeDefined();
+            expect(selected.id).toBe('2');
+        });
+        it('should throw error when no instance matches tags', () => {
+            const config = {
+                template: {
+                    ...baseTemplate,
+                    instanceSelectionStrategy: 'tag-match-unique'
+                },
+                instances: [
+                    { ...baseInstance, id: '1', index: 0, tags: { env: 'dev' } },
+                    { ...baseInstance, id: '2', index: 1, tags: { env: 'prod' } }
+                ],
+                tagDefinitions: []
+            };
+            expect(() => {
+                InstanceSelector.selectInstance('test-server', config, {
+                    tags: { env: 'staging' }
+                });
+            }).toThrow('No instance found matching tags');
+        });
+        it('should throw error when multiple instances match tags', () => {
+            const config = {
+                template: {
+                    ...baseTemplate,
+                    instanceSelectionStrategy: 'tag-match-unique'
+                },
+                instances: [
+                    { ...baseInstance, id: '1', index: 0, tags: { env: 'prod' } },
+                    { ...baseInstance, id: '2', index: 1, tags: { env: 'prod' } }
+                ],
+                tagDefinitions: []
+            };
+            expect(() => {
+                InstanceSelector.selectInstance('test-server', config, {
+                    tags: { env: 'prod' }
+                });
+            }).toThrow('Multiple instances match tags');
+        });
+        it('should return the single instance when no tags provided and only one instance exists', () => {
+            const config = {
+                template: {
+                    ...baseTemplate,
+                    instanceSelectionStrategy: 'tag-match-unique'
+                },
+                instances: [{ ...baseInstance, id: '1', index: 0 }],
+                tagDefinitions: []
+            };
+            const selected = InstanceSelector.selectInstance('test-server', config);
+            expect(selected).toBeDefined();
+            expect(selected.id).toBe('1');
+        });
+        it('should throw error when no tags provided with multiple instances', () => {
+            const config = {
+                template: {
+                    ...baseTemplate,
+                    instanceSelectionStrategy: 'tag-match-unique'
+                },
+                instances: [
+                    { ...baseInstance, id: '1', index: 0 },
+                    { ...baseInstance, id: '2', index: 1 }
+                ],
+                tagDefinitions: []
+            };
+            expect(() => {
+                InstanceSelector.selectInstance('test-server', config);
+            }).toThrow('No tags provided for tag-match-unique strategy with 2 instances. Available: [0:{}, 1:{}]. Pass matching tags to select.');
+        });
+    });
+    describe('single instance', () => {
+        it('should return the single instance regardless of strategy', () => {
+            const config = {
+                template: {
+                    ...baseTemplate,
+                    instanceSelectionStrategy: 'round-robin'
+                },
+                instances: [{ ...baseInstance, id: '1', index: 0 }],
+                tagDefinitions: []
+            };
+            const selected = InstanceSelector.selectInstance('test-server', config);
+            expect(selected).toBeDefined();
+            expect(selected.id).toBe('1');
+        });
+    });
+    describe('default strategy', () => {
+        it('should use random strategy when no strategy specified', () => {
+            const config = {
+                template: baseTemplate,
+                instances: [
+                    { ...baseInstance, id: '1', index: 0 },
+                    { ...baseInstance, id: '2', index: 1 }
+                ],
+                tagDefinitions: []
+                // No instanceSelectionStrategy field
+            };
+            const selected = InstanceSelector.selectInstance('test-server', config);
+            expect(selected).toBeDefined();
+            expect(['1', '2']).toContain(selected.id);
+        });
+    });
+});

package/dist/server/tests/unit/services/hub-tools/server-selector.test.d.ts

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

package/dist/server/tests/unit/services/hub-tools/server-selector.test.d.ts.map

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