@loop_ouroboros/mcp-hub-lite 1.2.8 → 1.3.0

package/dist/server/tests/unit/api/search.test.d.ts.map

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

package/dist/server/tests/unit/api/search.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest';
+import { filterByAggregatedTools } from '../../../src/api/web/search.js';
+function mockConfig(aggregatedTools = []) {
+    return {
+        template: {
+            type: 'stdio',
+            command: 'test',
+            args: [],
+            env: {},
+            headers: {},
+            aggregatedTools,
+            timeout: 30000
+        },
+        instances: [],
+        tagDefinitions: []
+    };
+}
+function mockTool(name, serverName = 'test-server') {
+    return { name, description: `Tool ${name}`, serverName };
+}
+describe('filterByAggregatedTools', () => {
+    it('should skip tools when aggregatedTools is empty', () => {
+        const tools = [mockTool('tool1'), mockTool('tool2')];
+        const getConfig = () => mockConfig([]);
+        const result = filterByAggregatedTools(tools, getConfig);
+        expect(result).toHaveLength(0);
+    });
+    it('should only include tools in aggregatedTools list', () => {
+        const tools = [mockTool('tool1'), mockTool('tool2'), mockTool('tool3')];
+        const getConfig = () => mockConfig(['tool1', 'tool3']);
+        const result = filterByAggregatedTools(tools, getConfig);
+        expect(result).toHaveLength(2);
+        expect(result.map((t) => t.name)).toEqual(['tool1', 'tool3']);
+    });
+    it('should skip tools when server config not found', () => {
+        const tools = [mockTool('tool1')];
+        const getConfig = () => undefined;
+        const result = filterByAggregatedTools(tools, getConfig);
+        expect(result).toHaveLength(0);
+    });
+    it('should filter tools from multiple servers independently', () => {
+        const tools = [
+            mockTool('a', 'server-a'),
+            mockTool('b', 'server-a'),
+            mockTool('x', 'server-b'),
+            mockTool('y', 'server-b')
+        ];
+        const configs = {
+            'server-a': mockConfig(['a']),
+            'server-b': mockConfig([])
+        };
+        const getConfig = (name) => configs[name];
+        const result = filterByAggregatedTools(tools, getConfig);
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe('a');
+    });
+    it('should return empty array when no tools provided', () => {
+        const result = filterByAggregatedTools([], () => mockConfig(['tool1']));
+        expect(result).toHaveLength(0);
+    });
+});

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

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { dryRunMigration, checkMigrationStatus, migrateConfig, rollbackMigration, resolveInstanceConfig, getEnabledInstances } from '../../../src/config/config-migrator.js';
+import { migrateConfig, resolveInstanceConfig } from '../../../src/config/config-migrator.js';
 import { SystemConfigSchema, isLegacyV1Config } from '../../../src/config/config.schema.js';
 describe('Config Migrator', () => {
     let tempDir;
@@ -85,59 +85,15 @@ describe('Config Migrator', () => {
         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,
-                        gatewayDebug: 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', () => {
+    describe('migrateConfig (actual migration)', () => {
+        it('should perform dry run without modifying files', () => {
             writeLegacyV1Config();
             const originalContent = fs.readFileSync(testConfigPath, 'utf8');
-            const result = dryRunMigration(testConfigPath);
+            const result = migrateConfig(testConfigPath, {
+                dryRun: true,
+                createBackup: false,
+                validateAfterMigration: true
+            });
             expect(result.success).toBe(true);
             expect(result.migratedConfig).toBeDefined();
             expect(result.backupPath).toBeUndefined();
@@ -145,9 +101,13 @@ describe('Config Migrator', () => {
             const currentContent = fs.readFileSync(testConfigPath, 'utf8');
             expect(currentContent).toBe(originalContent);
         });
-        it('should convert servers to servers correctly', () => {
+        it('should convert servers correctly (dry run)', () => {
             writeLegacyV1Config();
-            const result = dryRunMigration(testConfigPath);
+            const result = migrateConfig(testConfigPath, {
+                dryRun: true,
+                createBackup: false,
+                validateAfterMigration: true
+            });
             expect(result.success).toBe(true);
             expect(result.migratedConfig).toBeDefined();
             const migrated = result.migratedConfig;
@@ -156,7 +116,6 @@ describe('Config Migrator', () => {
             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']);
@@ -167,17 +126,19 @@ describe('Config Migrator', () => {
             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', () => {
+        it('should preserve system and security config (dry run)', () => {
             writeLegacyV1Config();
             const v1Config = createLegacyV1Config();
-            const result = dryRunMigration(testConfigPath);
+            const result = migrateConfig(testConfigPath, {
+                dryRun: true,
+                createBackup: false,
+                validateAfterMigration: true
+            });
             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');
@@ -208,40 +169,15 @@ describe('Config Migrator', () => {
             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);
+                const migrationResult = migrateConfig(testConfigPath, {
+                    dryRun: true,
+                    createBackup: false,
+                    validateAfterMigration: true
+                });
                 expect(migrationResult.success).toBe(true);
                 const serverConfig = migrationResult.migratedConfig.servers['test-server-1'];
                 const resolved = resolveInstanceConfig(serverConfig);
@@ -255,7 +191,11 @@ describe('Config Migrator', () => {
             });
             it('should resolve specific instance by ID', () => {
                 writeLegacyV1Config();
-                const migrationResult = dryRunMigration(testConfigPath);
+                const migrationResult = migrateConfig(testConfigPath, {
+                    dryRun: true,
+                    createBackup: false,
+                    validateAfterMigration: true
+                });
                 expect(migrationResult.success).toBe(true);
                 const serverConfig = migrationResult.migratedConfig.servers['test-server-1'];
                 const instanceId = serverConfig.instances[0].id;
@@ -265,25 +205,17 @@ describe('Config Migrator', () => {
             });
             it('should return null for non-existent instance ID', () => {
                 writeLegacyV1Config();
-                const migrationResult = dryRunMigration(testConfigPath);
+                const migrationResult = migrateConfig(testConfigPath, {
+                    dryRun: true,
+                    createBackup: false,
+                    validateAfterMigration: true
+                });
                 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', () => {
@@ -292,7 +224,11 @@ describe('Config Migrator', () => {
                 servers: {}
             };
             fs.writeFileSync(testConfigPath, JSON.stringify(emptyV1Config, null, 2));
-            const result = dryRunMigration(testConfigPath);
+            const result = migrateConfig(testConfigPath, {
+                dryRun: true,
+                createBackup: false,
+                validateAfterMigration: true
+            });
             expect(result.success).toBe(true);
             expect(result.migratedConfig.servers).toEqual({});
         });
@@ -310,7 +246,11 @@ describe('Config Migrator', () => {
                 }
             };
             fs.writeFileSync(testConfigPath, JSON.stringify(minimalV1Config, null, 2));
-            const result = dryRunMigration(testConfigPath);
+            const result = migrateConfig(testConfigPath, {
+                dryRun: true,
+                createBackup: false,
+                validateAfterMigration: true
+            });
             expect(result.success).toBe(true);
             expect(result.migratedConfig.servers['minimal-server']).toBeDefined();
         });

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

@@ -5,7 +5,7 @@ import path from 'path';
 // Mock fs module
 vi.mock('fs');
 vi.mock('path');
-vi.mock('@utils/logger.js', () => ({
+vi.mock('@utils/logger/index.js', () => ({
     logger: {
         debug: vi.fn(),
         error: vi.fn()

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

@@ -2,8 +2,8 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { runServer } from '../../../src/server/runner.js';
 import { buildApp } from '../../../src/app.js';
 import { configManager } from '../../../src/config/config-manager.js';
-import { logger } from '../../../src/utils/logger.js';
-import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
+import { logger } from '../../../src/utils/logger/index.js';
+import { mcpConnectionManager } from '../../../src/services/connection/index.js';
 import { PidManager } from '../../../src/pid/manager.js';
 import { checkPort, checkPortWithExit } from '../../../src/utils/port-checker.js';
 // Mock resolveInstanceConfig to return a valid resolved config
@@ -16,8 +16,7 @@ vi.mock('@config/config-migrator.js', () => ({
         aggregatedTools: [],
         tags: {},
         enabled: true
-    })),
-    getEnabledInstances: vi.fn()
+    }))
 }));
 // Mock all dependencies
 vi.mock('@src/app.js', () => ({
@@ -31,7 +30,7 @@ vi.mock('@config/config-manager.js', () => ({
         addServerInstance: vi.fn()
     }
 }));
-vi.mock('@utils/logger.js', () => ({
+vi.mock('@utils/logger/index.js', () => ({
     logger: {
         info: vi.fn(),
         error: vi.fn(),
@@ -43,7 +42,7 @@ vi.mock('@utils/logger.js', () => ({
         SERVER: { module: 'Server' }
     }
 }));
-vi.mock('@services/mcp-connection-manager.js', () => ({
+vi.mock('@services/connection/index.js', () => ({
     mcpConnectionManager: {
         connect: vi.fn(() => Promise.resolve(true)),
         disconnectAll: vi.fn()

package/dist/server/tests/unit/services/gateway-logging.test.js

@@ -1,5 +1,5 @@
 import { describe, test, expect } from 'vitest';
-import { GatewayService } from '../../../src/services/gateway.service.js';
+import { GatewayService } from '../../../src/services/gateway/index.js';
 describe('GatewayService Logging Helpers', () => {
     // Access private methods using type assertion for testing
     const gateway = new GatewayService();

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

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

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

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

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

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

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

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { Logger, logWithColor } from '../../../src/utils/logger.js';
+import { Logger } from '../../../src/utils/logger/index.js';
 import { setJsonPrettyConfigGetter, setDevModeEnabled } from '../../../src/utils/json-utils.js';
 import { createColoredLogMessage, createLogMessage, getCallerInfo, formatCallerInfo } from '../../../src/utils/logger/log-formatter.js';
 describe('Logger', () => {
@@ -363,28 +363,6 @@ describe('Logger', () => {
         expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('file line 3'));
         vi.restoreAllMocks();
     });
-    it('should handle logWithColor function with traceId and spanId', () => {
-        // Reset logger instance to avoid interference between tests
-        const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
-        logWithColor('colored message', 'plain message', {
-            pid: 123,
-            serverName: 'test-server',
-            traceId: '1234567890abcdef1234567890abcdef',
-            spanId: 'abcdef1234567890'
-        });
-        expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('[TID:1234567890abcdef1234567890abcdef]'));
-        expect(consoleInfoSpy).toHaveBeenCalledWith(expect.stringContaining('[SID:abcdef1234567890]'));
-        // Restore console methods
-        consoleInfoSpy.mockRestore();
-    });
-    it('should handle logWithColor function without context', () => {
-        // Reset logger instance to avoid interference between tests
-        const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
-        logWithColor('colored message', 'plain message');
-        expect(consoleInfoSpy).toHaveBeenCalled();
-        // Restore console methods
-        consoleInfoSpy.mockRestore();
-    });
     describe('dev log rotation', () => {
         it('should create devLogRotator when enableDevLog is called', () => {
             // Mock fs modules to avoid file system operations

package/dist/server/tests/unit/utils/sort-utils.test.js

@@ -1,50 +1,6 @@
 import { describe, it, expect } from 'vitest';
-import { sortObjectKeys, sortObjectKeysCaseInsensitive, sortObjectKeysDeep, sortServerConfigEnvHeaders } from '../../../src/utils/sort-utils.js';
+import { sortObjectKeysCaseInsensitive, sortServerConfigEnvHeaders } from '../../../src/utils/sort-utils.js';
 describe('sort-utils', () => {
-    describe('sortObjectKeys', () => {
-        it('should sort object keys alphabetically using localeCompare', () => {
-            const obj = {
-                zebra: 'value3',
-                apple: 'value1',
-                banana: 'value2'
-            };
-            const result = sortObjectKeys(obj);
-            expect(Object.keys(result)).toEqual(['apple', 'banana', 'zebra']);
-            expect(result).toEqual({
-                apple: 'value1',
-                banana: 'value2',
-                zebra: 'value3'
-            });
-        });
-        it('should return the same object if input is null or undefined', () => {
-            expect(sortObjectKeys(null)).toBe(null);
-            expect(sortObjectKeys(undefined)).toBe(undefined);
-        });
-        it('should return the same object if input is an array', () => {
-            const arr = [3, 1, 2];
-            expect(sortObjectKeys(arr)).toBe(arr);
-        });
-        it('should return the same object if input is not an object', () => {
-            expect(sortObjectKeys('string')).toBe('string');
-            expect(sortObjectKeys(42)).toBe(42);
-            expect(sortObjectKeys(true)).toBe(true);
-        });
-        it('should preserve the original object (return a new object)', () => {
-            const obj = {
-                zebra: 'value3',
-                apple: 'value1'
-            };
-            const result = sortObjectKeys(obj);
-            expect(result).not.toBe(obj);
-            expect(obj).toEqual({
-                zebra: 'value3',
-                apple: 'value1'
-            });
-        });
-        it('should handle empty object', () => {
-            expect(sortObjectKeys({})).toEqual({});
-        });
-    });
     describe('sortObjectKeysCaseInsensitive', () => {
         it('should sort object keys alphabetically, case-insensitive', () => {
             const obj = {
@@ -77,53 +33,6 @@ describe('sort-utils', () => {
             expect(sortObjectKeysCaseInsensitive(undefined)).toBe(undefined);
         });
     });
-    describe('sortObjectKeysDeep', () => {
-        it('should recursively sort all object keys in a nested structure', () => {
-            const obj = {
-                zebra: {
-                    delta: 'value4',
-                    alpha: 'value1'
-                },
-                apple: {
-                    charlie: 'value3',
-                    bravo: 'value2'
-                }
-            };
-            const result = sortObjectKeysDeep(obj);
-            expect(Object.keys(result)).toEqual(['apple', 'zebra']);
-            expect(Object.keys(result.apple)).toEqual(['bravo', 'charlie']);
-            expect(Object.keys(result.zebra)).toEqual(['alpha', 'delta']);
-        });
-        it('should handle arrays and recursively sort objects within arrays', () => {
-            const obj = {
-                items: [
-                    { zebra: 'value3', apple: 'value1' },
-                    { delta: 'value4', alpha: 'value1' }
-                ]
-            };
-            const result = sortObjectKeysDeep(obj);
-            expect(Array.isArray(result.items)).toBe(true);
-            expect(Object.keys(result.items[0])).toEqual(['apple', 'zebra']);
-            expect(Object.keys(result.items[1])).toEqual(['alpha', 'delta']);
-        });
-        it('should handle mixed types in nested structure', () => {
-            const obj = {
-                number: 42,
-                string: 'hello',
-                boolean: true,
-                array: [1, 2, 3],
-                object: {
-                    nested: {
-                        z: 'last',
-                        a: 'first'
-                    }
-                }
-            };
-            const result = sortObjectKeysDeep(obj);
-            expect(Object.keys(result)).toEqual(['array', 'boolean', 'number', 'object', 'string']);
-            expect(Object.keys(result.object.nested)).toEqual(['a', 'z']);
-        });
-    });
     describe('sortServerConfigEnvHeaders', () => {
         it('should sort env and headers objects in a server configuration', () => {
             const config = {