@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.0

package/dist/server/tests/integration/gateway/fault-tolerance.test.js

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
 import { hubManager } from '../../../src/services/hub-manager.service.js';
+import { resolveInstanceConfig } from '../../../src/config/config-migrator.js';
 // Mock MCP SDK Client
 const mockConnect = vi.fn();
 const mockClose = vi.fn();
@@ -33,28 +34,41 @@ describe('Gateway Fault Tolerance', () => {
     beforeEach(async () => {
         // Clear all mocks
         vi.clearAllMocks();
-        // Add test server
+        // Add test server (v1.1 format)
         await hubManager.addServer('test-server', {
             command: 'node',
             args: [],
-            enabled: true,
             type: 'stdio',
             timeout: 60000,
-            allowedTools: []
+            aggregatedTools: []
         });
         // Add server instance
-        mockServerInstance = await hubManager.addServerInstance('test-server', {});
+        const instance = (await hubManager.addServerInstance('test-server', {}));
+        mockServerInstance = {
+            id: instance.id,
+            index: instance.index,
+            timestamp: instance.timestamp || Date.now()
+        };
     });
     it('should handle connection failure gracefully', async () => {
         mockConnect.mockRejectedValueOnce(new Error('Connection failed'));
         // Directly use hubManager.getServerById to get complete server configuration
         const serverInfo = hubManager.getServerById(mockServerInstance.id);
-        const success = await mcpConnectionManager.connect({
-            ...serverInfo.config,
-            ...serverInfo.instance
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        // Resolve the complete configuration using v1.1 resolveInstanceConfig
+        const resolvedConfig = resolveInstanceConfig(serverInfo.config, mockServerInstance.id);
+        if (!resolvedConfig) {
+            throw new Error('Failed to resolve server configuration');
+        }
+        const success = await mcpConnectionManager.connect(serverInfo.name, mockServerInstance.index, {
+            ...resolvedConfig,
+            id: mockServerInstance.id,
+            timestamp: Date.now()
         });
         expect(success).toBe(false);
-        const status = mcpConnectionManager.getStatus(mockServerInstance.id);
+        const status = mcpConnectionManager.getStatus(serverInfo.name, mockServerInstance.index);
         expect(status?.connected).toBe(false);
         expect(status?.error).toContain('Connection failed');
     });
@@ -63,46 +77,72 @@ describe('Gateway Fault Tolerance', () => {
         mockListTools.mockRejectedValueOnce(new Error('List tools failed'));
         // Directly use hubManager.getServerById to get complete server configuration
         const serverInfo = hubManager.getServerById(mockServerInstance.id);
-        const success = await mcpConnectionManager.connect({
-            ...serverInfo.config,
-            ...serverInfo.instance
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        // Resolve the complete configuration using v1.1 resolveInstanceConfig
+        const resolvedConfig = resolveInstanceConfig(serverInfo.config, mockServerInstance.id);
+        if (!resolvedConfig) {
+            throw new Error('Failed to resolve server configuration');
+        }
+        const success = await mcpConnectionManager.connect(serverInfo.name, mockServerInstance.index, {
+            ...resolvedConfig,
+            id: mockServerInstance.id,
+            timestamp: Date.now()
         });
         expect(success).toBe(false);
-        const status = mcpConnectionManager.getStatus(mockServerInstance.id);
+        const status = mcpConnectionManager.getStatus(serverInfo.name, mockServerInstance.index);
         expect(status?.connected).toBe(false);
         expect(status?.error).toContain('List tools failed');
     });
     it('should not affect other servers when one fails', async () => {
-        // Add second server
+        // Add second server (v1.1 format)
         await hubManager.addServer('working-server', {
             command: 'node',
             args: [],
-            enabled: true,
             type: 'stdio',
             timeout: 60000,
-            allowedTools: []
+            aggregatedTools: []
         });
-        const workingInstance = await hubManager.addServerInstance('working-server', {});
+        const workingInstance = (await hubManager.addServerInstance('working-server', {}));
         // Simulate first server failure, second server success
         mockConnect
             .mockImplementationOnce(() => Promise.reject(new Error('First server failed')))
             .mockImplementationOnce(() => Promise.resolve());
-        mockListTools.mockImplementationOnce(() => Promise.resolve({ tools: [] }));
+        mockListTools
+            .mockImplementationOnce(() => Promise.resolve({ tools: [] })) // First server
+            .mockImplementationOnce(() => Promise.resolve({ tools: [] })); // Second server
         // Connect first server (should fail)
         const serverInfo1 = hubManager.getServerById(mockServerInstance.id);
-        await mcpConnectionManager.connect({
-            ...serverInfo1.config,
-            ...serverInfo1.instance
+        if (!serverInfo1) {
+            throw new Error('Server 1 not found');
+        }
+        const resolvedConfig1 = resolveInstanceConfig(serverInfo1.config, mockServerInstance.id);
+        if (!resolvedConfig1) {
+            throw new Error('Failed to resolve server 1 configuration');
+        }
+        await mcpConnectionManager.connect(serverInfo1.name, mockServerInstance.index, {
+            ...resolvedConfig1,
+            id: mockServerInstance.id,
+            timestamp: Date.now()
         });
         // Connect second server (should succeed)
         const serverInfo2 = hubManager.getServerById(workingInstance.id);
-        const success2 = await mcpConnectionManager.connect({
-            ...serverInfo2.config,
-            ...serverInfo2.instance
+        if (!serverInfo2) {
+            throw new Error('Server 2 not found');
+        }
+        const resolvedConfig2 = resolveInstanceConfig(serverInfo2.config, workingInstance.id);
+        if (!resolvedConfig2) {
+            throw new Error('Failed to resolve server 2 configuration');
+        }
+        const success2 = await mcpConnectionManager.connect(serverInfo2.name, workingInstance.index, {
+            ...resolvedConfig2,
+            id: workingInstance.id,
+            timestamp: Date.now()
         });
         expect(success2).toBe(true);
-        const status1 = mcpConnectionManager.getStatus(mockServerInstance.id);
-        const status2 = mcpConnectionManager.getStatus(workingInstance.id);
+        const status1 = mcpConnectionManager.getStatus(serverInfo1.name, mockServerInstance.index);
+        const status2 = mcpConnectionManager.getStatus(serverInfo2.name, workingInstance.index);
         expect(status1?.connected).toBe(false);
         expect(status2?.connected).toBe(true);
     });

package/dist/server/tests/integration/gateway/mcp-connection.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
 import { hubManager } from '../../../src/services/hub-manager.service.js';
-import { simpleSearchService } from '../../../src/services/simple-search.service.js';
+import { resolveInstanceConfig } from '../../../src/config/config-migrator.js';
 // Mock MCP SDK Client
 const mockConnect = vi.fn();
 const mockClose = vi.fn();
@@ -32,118 +32,110 @@ vi.mock('@utils/transports/transport-factory.js', () => {
 describe('MCP Connection Integration', () => {
     const serverName = 'test-mcp-server';
     let serverId;
+    let serverIndex;
     beforeEach(async () => {
         // Clear all mocks
         vi.clearAllMocks();
-        // Add test server
+        // Add test server (v1.1 format)
         await hubManager.addServer(serverName, {
             command: 'node',
             args: [],
-            enabled: true,
             type: 'stdio',
             timeout: 60000,
-            allowedTools: []
+            aggregatedTools: []
         });
         // Add server instance
-        const instance = await hubManager.addServerInstance(serverName, {});
+        const instance = (await hubManager.addServerInstance(serverName, {}));
         serverId = instance.id;
+        serverIndex = instance.index;
     });
     afterEach(async () => {
-        await mcpConnectionManager.disconnect(serverId);
+        await mcpConnectionManager.disconnect(serverName, serverIndex);
         hubManager.removeServer(serverName);
     });
     it('should establish MCP connection successfully', async () => {
         mockConnect.mockResolvedValueOnce(undefined);
         mockListTools.mockResolvedValueOnce({ tools: [] });
         const serverInfo = hubManager.getServerById(serverId);
-        const success = await mcpConnectionManager.connect({
-            ...serverInfo.config,
-            ...serverInfo.instance
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        const resolvedConfig = resolveInstanceConfig(serverInfo.config, serverId);
+        if (!resolvedConfig) {
+            throw new Error('Failed to resolve server configuration');
+        }
+        const success = await mcpConnectionManager.connect(serverInfo.name, serverIndex, {
+            ...resolvedConfig,
+            id: serverId,
+            timestamp: Date.now()
         });
         expect(success).toBe(true);
-        const status = mcpConnectionManager.getStatus(serverId);
+        const status = mcpConnectionManager.getStatus(serverInfo.name, serverIndex);
         expect(status?.connected).toBe(true);
     });
     it('should handle connection errors properly', async () => {
         mockConnect.mockRejectedValueOnce(new Error('Connection refused'));
         const serverInfo = hubManager.getServerById(serverId);
-        const success = await mcpConnectionManager.connect({
-            ...serverInfo.config,
-            ...serverInfo.instance
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        const resolvedConfig = resolveInstanceConfig(serverInfo.config, serverId);
+        if (!resolvedConfig) {
+            throw new Error('Failed to resolve server configuration');
+        }
+        const success = await mcpConnectionManager.connect(serverInfo.name, serverIndex, {
+            ...resolvedConfig,
+            id: serverId,
+            timestamp: Date.now()
         });
         expect(success).toBe(false);
-        const status = mcpConnectionManager.getStatus(serverId);
+        const status = mcpConnectionManager.getStatus(serverInfo.name, serverIndex);
         expect(status?.connected).toBe(false);
         expect(status?.error).toContain('Connection refused');
     });
     it('should support concurrent connections', async () => {
-        // Add second server
+        // Add second server (v1.1 format)
         const server2Name = 'test-mcp-server-2';
         await hubManager.addServer(server2Name, {
             command: 'node',
             args: [],
-            enabled: true,
             type: 'stdio',
             timeout: 60000,
-            allowedTools: []
+            aggregatedTools: []
         });
-        const instance2 = await hubManager.addServerInstance(server2Name, {});
+        const instance2 = (await hubManager.addServerInstance(server2Name, {}));
         mockConnect.mockResolvedValue(undefined);
         mockListTools.mockResolvedValue({ tools: [] });
         const serverInfo1 = hubManager.getServerById(serverId);
         const serverInfo2 = hubManager.getServerById(instance2.id);
+        if (!serverInfo1 || !serverInfo2) {
+            throw new Error('Server not found');
+        }
+        const resolvedConfig1 = resolveInstanceConfig(serverInfo1.config, serverId);
+        const resolvedConfig2 = resolveInstanceConfig(serverInfo2.config, instance2.id);
+        if (!resolvedConfig1 || !resolvedConfig2) {
+            throw new Error('Failed to resolve server configuration');
+        }
         const [success1, success2] = await Promise.all([
-            mcpConnectionManager.connect({
-                ...serverInfo1.config,
-                ...serverInfo1.instance
+            mcpConnectionManager.connect(serverInfo1.name, serverIndex, {
+                ...resolvedConfig1,
+                id: serverId,
+                timestamp: Date.now()
             }),
-            mcpConnectionManager.connect({
-                ...serverInfo2.config,
-                ...serverInfo2.instance
+            mcpConnectionManager.connect(serverInfo2.name, instance2.index, {
+                ...resolvedConfig2,
+                id: instance2.id,
+                timestamp: Date.now()
             })
         ]);
         expect(success1).toBe(true);
         expect(success2).toBe(true);
-        const status1 = mcpConnectionManager.getStatus(serverId);
-        const status2 = mcpConnectionManager.getStatus(instance2.id);
+        const status1 = mcpConnectionManager.getStatus(serverInfo1.name, serverIndex);
+        const status2 = mcpConnectionManager.getStatus(serverInfo2.name, instance2.index);
         expect(status1?.connected).toBe(true);
         expect(status2?.connected).toBe(true);
         // Clean up
-        await mcpConnectionManager.disconnect(instance2.id);
+        await mcpConnectionManager.disconnect(serverInfo2.name, instance2.index);
         await hubManager.removeServer(server2Name);
     });
-    it('should integrate with search service', async () => {
-        // Set up mock tool data
-        mockConnect.mockResolvedValue(undefined);
-        mockListTools.mockResolvedValue({
-            tools: [
-                {
-                    name: 'test-tool',
-                    description: 'A test tool for searching',
-                    inputSchema: { type: 'object', properties: { query: { type: 'string' } } }
-                }
-            ]
-        });
-        const searchServerName = 'search-test-server';
-        await hubManager.addServer(searchServerName, {
-            command: 'node',
-            args: [],
-            enabled: true,
-            type: 'stdio',
-            timeout: 60000,
-            allowedTools: []
-        });
-        const searchServerInstance = await hubManager.addServerInstance(searchServerName, {});
-        const serverInfo = hubManager.getServerById(searchServerInstance.id);
-        await mcpConnectionManager.connect({
-            ...serverInfo.config,
-            ...serverInfo.instance
-        });
-        const results = simpleSearchService.search('test');
-        expect(results.length).toBeGreaterThan(0);
-        expect(results[0].tool.name).toBe('test-tool');
-        // Clean up
-        await mcpConnectionManager.disconnect(searchServerInstance.id);
-        await hubManager.removeServer(searchServerName);
-    });
 });

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

@@ -12,7 +12,7 @@ vi.mock('@services/hub-manager.service.js', () => ({
         updateServer: vi.fn(),
         removeServer: vi.fn(),
         addServerInstance: vi.fn().mockResolvedValue({}),
-        getServerInstanceByName: vi.fn()
+        getServerInstancesByName: vi.fn()
     }
 }));
 describe('Server API Routes', () => {
@@ -31,12 +31,18 @@ describe('Server API Routes', () => {
             {
                 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: []
                 }
             }
         ];
@@ -55,18 +61,23 @@ describe('Server API Routes', () => {
                 command: 'node',
                 args: [],
                 env: {},
-                enabled: true,
-                allowedTools: []
+                headers: {},
+                aggregatedTools: []
             }
         };
         const createdServer = {
-            type: 'stdio',
-            command: 'node',
-            args: [],
-            env: {},
-            enabled: true,
-            allowedTools: [],
-            timeout: 30000
+            template: {
+                type: 'stdio',
+                command: 'node',
+                args: [],
+                env: {},
+                headers: {},
+                aggregatedTools: [],
+                timeout: 30000,
+                tags: {}
+            },
+            instances: [],
+            tagDefinitions: []
         };
         vi.mocked(hubManager.addServer).mockReturnValue(Promise.resolve(createdServer));
         const response = await app.inject({

package/dist/server/tests/temp/temp-run-docling.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=temp-run-docling.d.ts.map

package/dist/server/tests/temp/temp-run-docling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temp-run-docling.d.ts","sourceRoot":"","sources":["../../../../tests/temp/temp-run-docling.ts"],"names":[],"mappings":""}

package/dist/server/tests/temp/temp-run-docling.js

@@ -0,0 +1,53 @@
+import { spawn } from 'child_process';
+import { createWriteStream, existsSync, mkdirSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const LOG_FILE = join(__dirname, '../../docs/temp/uvx-docling.log');
+console.log('Starting docling-mcp-server...');
+console.log(`Logging to: ${LOG_FILE}`);
+// Ensure log directory exists
+const logDir = dirname(LOG_FILE);
+if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+}
+const logStream = createWriteStream(LOG_FILE, { flags: 'a' });
+const child = spawn('uvx', ['--from=docling-mcp', 'docling-mcp-server'], {
+    shell: true,
+    stdio: ['inherit', 'pipe', 'pipe']
+});
+// Log stdout
+child.stdout?.on('data', (data) => {
+    const output = data.toString();
+    process.stdout.write(output);
+    logStream.write(output);
+});
+// Log stderr
+child.stderr?.on('data', (data) => {
+    const output = data.toString();
+    process.stderr.write(output);
+    logStream.write(output);
+});
+child.on('error', (error) => {
+    console.error(`Failed to start process: ${error.message}`);
+    logStream.write(`ERROR: ${error.message}\n`);
+    logStream.end();
+    process.exit(1);
+});
+child.on('exit', (code, signal) => {
+    const message = `Process exited with code ${code}, signal ${signal}`;
+    console.log(message);
+    logStream.write(`${message}\n`);
+    logStream.end();
+    process.exit(code ?? 0);
+});
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+    console.log('\nShutting down...');
+    child.kill('SIGINT');
+});
+process.on('SIGTERM', () => {
+    console.log('\nShutting down...');
+    child.kill('SIGTERM');
+});

package/dist/server/tests/types/test-helpers.d.ts

@@ -5,12 +5,11 @@ export interface MockServerConfig {
     id: string;
     name: string;
     config: {
-        allowedTools?: string[];
+        aggregatedTools?: string[];
     };
     instance: {
         id: string;
         timestamp: number;
-        hash: string;
     };
 }
 export interface MockTool {

package/dist/server/tests/types/test-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../../../tests/types/test-helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE;QACN,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;KACzB,CAAC;IACF,QAAQ,EAAE;QACR,EAAE,EAAE,MAAM,CAAC;QACX,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAGD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAGD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC"}
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../../../tests/types/test-helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE;QACN,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;KAC5B,CAAC;IACF,QAAQ,EAAE;QACR,EAAE,EAAE,MAAM,CAAC;QACX,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAGD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAGD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC"}

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

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

package/dist/server/tests/unit/config/config-loader-automatic-migration.test.d.ts.map

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