@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

package/dist/server/tests/integration/api/gateway.test.js

@@ -2,10 +2,12 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 // Define mocks first
 const mocks = vi.hoisted(() => {
     const mockToolCache = new Map();
+    const mockListRoots = vi.fn();
     return {
         setRequestHandler: vi.fn(),
         setNotificationHandler: vi.fn(),
         request: vi.fn(),
+        listRoots: mockListRoots,
         connect: vi.fn(),
         getAllTools: vi.fn(),
         callTool: vi.fn(),
@@ -19,21 +21,28 @@ const mocks = vi.hoisted(() => {
         listServers: vi.fn(),
         findServers: vi.fn(),
         getSystemTools: vi.fn().mockReturnValue([]),
-        updateClientRoots: vi.fn(),
-        getClientContext: vi.fn().mockReturnValue({ sessionId: 'test-session' }),
+        updateSessionRoots: vi.fn(),
+        updateSession: vi.fn(),
+        getSession: vi.fn().mockReturnValue({
+            sessionId: 'test-session',
+            capabilities: { roots: { list: true } }
+        }),
+        getSessionContext: vi.fn().mockReturnValue({ sessionId: 'test-session' }),
         mockToolCache
     };
 });
 // Mock dependencies
-vi.mock('@services/client-tracker.service.js', () => ({
-    clientTrackerService: {
-        updateClientRoots: mocks.updateClientRoots,
-        getClients: vi.fn().mockReturnValue([])
+vi.mock('@services/session-tracker.service.js', () => ({
+    sessionTrackerService: {
+        updateSessionRoots: mocks.updateSessionRoots,
+        updateSession: mocks.updateSession,
+        getSession: mocks.getSession,
+        getSessions: vi.fn().mockReturnValue([])
     }
 }));
 vi.mock('@utils/request-context.js', () => ({
-    getClientContext: mocks.getClientContext,
-    getClientCwd: vi.fn()
+    getSessionContext: mocks.getSessionContext,
+    getSessionCwd: vi.fn()
 }));
 vi.mock('@utils/logger.js', () => ({
     logger: {
@@ -53,7 +62,9 @@ vi.mock('@services/mcp-connection-manager.js', () => ({
         callTool: mocks.callTool,
         toolCache: mocks.mockToolCache,
         // Add method to access the mock toolCache
-        getToolCache: () => mocks.mockToolCache
+        getToolCache: () => mocks.mockToolCache,
+        // Add getToolCacheEntries method for backward compatibility
+        getToolCacheEntries: () => Array.from(mocks.mockToolCache.entries())
     }
 }));
 vi.mock('@services/hub-manager.service.js', () => ({
@@ -81,7 +92,8 @@ vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => {
             server = {
                 setRequestHandler: mocks.setRequestHandler,
                 setNotificationHandler: mocks.setNotificationHandler,
-                request: mocks.request
+                request: mocks.request,
+                listRoots: mocks.listRoots
             };
             connect = mocks.connect;
         }
@@ -115,7 +127,7 @@ describe('GatewayService', () => {
         vi.mocked(mocks.getServerById).mockReturnValue({
             name: 'Test Server',
             id: 'server1',
-            config: { allowedTools: ['testTool'] },
+            config: { template: { aggregatedTools: ['testTool'] } },
             instance: { id: 'server1', timestamp: Date.now(), hash: 'abc123' }
         });
         // Populate toolCache for the test
@@ -158,7 +170,7 @@ describe('GatewayService', () => {
         vi.mocked(mocks.getServerById).mockReturnValue({
             name: 'Test Server',
             id: 'server1',
-            config: { allowedTools: ['testTool'] },
+            config: { template: { aggregatedTools: ['testTool'] } },
             instance: { id: 'server1', timestamp: Date.now(), hash: 'abc123' }
         });
         // Find list tools handler to populate tool map
@@ -265,33 +277,6 @@ describe('GatewayService', () => {
         expect(result.tools).toHaveLength(9);
         expect(result.tools.some((t) => t.name === 'list_servers')).toBe(true);
     });
-    // it('should fetch roots on initialized notification', async () => {
-    //   // Find initialized notification handler
-    //   let initializedHandler: Function | undefined;
-    //   for (const call of mocks.setNotificationHandler.mock.calls) {
-    //       const schemaStr = JSON.stringify(call[0]);
-    //       if (schemaStr.includes('"notifications/initialized"')) {
-    //           initializedHandler = call[1];
-    //           break;
-    //       }
-    //   }
-    //   expect(initializedHandler).toBeDefined();
-    //
-    //   // Mock server.request returning roots
-    //   vi.mocked(mocks.request).mockResolvedValue({ roots: [{ uri: 'file:///test/path' }] });
-    //
-    //   // Call the handler
-    //   await initializedHandler!();
-    //
-    //   // Verify request was made
-    //   expect(mocks.request).toHaveBeenCalledWith(
-    //       expect.objectContaining({ method: 'roots/list' }),
-    //       expect.anything()
-    //   );
-    //
-    //   // Verify client tracker was updated
-    //   expect(mocks.updateClientRoots).toHaveBeenCalledWith('test-session', [{ uri: 'file:///test/path' }]);
-    // });
     it('should call system tools', async () => {
         // Find call tool handler
         let callToolHandler;

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/temp/test-stack.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env tsx
+declare const err: Error;
+declare const originalPrepareStackTrace: (err: Error, stackTraces: NodeJS.CallSite[]) => any;
+declare const err2: Error;
+declare const stack: NodeJS.CallSite[];
+//# sourceMappingURL=test-stack.d.ts.map

package/dist/server/tests/temp/test-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-stack.d.ts","sourceRoot":"","sources":["../../../../tests/temp/test-stack.ts"],"names":[],"mappings":";AAMA,QAAA,MAAM,GAAG,OAAc,CAAC;AAKxB,QAAA,MAAM,yBAAyB,qDAA0B,CAAC;AAE1D,QAAA,MAAM,IAAI,OAAc,CAAC;AACzB,QAAA,MAAM,KAAK,EAA4B,MAAM,CAAC,QAAQ,EAAE,CAAC"}

package/dist/server/tests/temp/test-stack.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env tsx
+"use strict";
+console.log('=== Testing Stack Trace ===');
+// Test 1: Default Error stack
+console.log('\nTest 1: Default Error stack');
+const err = new Error();
+console.log('Stack:', err.stack);
+// Test 2: prepareStackTrace
+console.log('\nTest 2: Using prepareStackTrace');
+const originalPrepareStackTrace = Error.prepareStackTrace;
+Error.prepareStackTrace = (_err, stack) => stack;
+const err2 = new Error();
+const stack = err2.stack;
+console.log('Stack frames count:', stack.length);
+stack.forEach((frame, i) => {
+    console.log(`Frame ${i}:`);
+    console.log(`  getFileName():`, frame.getFileName());
+    console.log(`  getLineNumber():`, frame.getLineNumber());
+    console.log(`  getColumnNumber():`, frame.getColumnNumber());
+    console.log(`  getFunctionName():`, frame.getFunctionName());
+    console.log(`  getMethodName():`, frame.getMethodName());
+    console.log(`  isNative():`, frame.isNative());
+    console.log(`  isEval():`, frame.isEval());
+});
+Error.prepareStackTrace = originalPrepareStackTrace;
+// Test 3: Our current implementation
+console.log('\nTest 3: Testing our current implementation');
+import('./src/utils/logger/log-formatter.js').then(module => {
+    console.log('isTsxMode():', module.isTsxMode?.() ?? 'not exported');
+    const callerInfo = module.getCallerInfo?.(0);
+    console.log('getCallerInfo(0):', callerInfo);
+    const callerInfo2 = module.getCallerInfo?.(1);
+    console.log('getCallerInfo(1):', callerInfo2);
+    const callerInfo3 = module.getCallerInfo?.(2);
+    console.log('getCallerInfo(2):', callerInfo3);
+    const callerInfo4 = module.getCallerInfo?.(3);
+    console.log('getCallerInfo(3):', callerInfo4);
+    const callerInfo5 = module.getCallerInfo?.(4);
+    console.log('getCallerInfo(4):', callerInfo5);
+});

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":""}