@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { stringifyForLogging, stringifyForLoggingWithReplacer, setJsonPrettyConfigGetter, rawHeadersToObject, stringifyRawHeadersForLogging, getJsonPrettySetting, getMcpCommDebugSetting, getSessionDebugSetting } from '../../../src/utils/json-utils.js';
+import { stringifyForLogging, stringifyForLoggingWithReplacer, setJsonPrettyConfigGetter, rawHeadersToObject, stringifyRawHeadersForLogging, getJsonPrettySetting, getMcpCommDebugSetting, getApiDebugSetting } from '../../../src/utils/json-utils.js';
 describe('json-utils', () => {
     beforeEach(() => {
         // Reset config getter
@@ -13,7 +13,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -35,7 +35,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -53,7 +53,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -72,7 +72,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -102,7 +102,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: false,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -182,7 +182,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: false,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -192,7 +192,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -204,12 +204,106 @@ describe('json-utils', () => {
             });
             expect(getJsonPrettySetting()).toBe(true);
         });
+        it('should respect LOG_JSON_PRETTY environment variable when set to "true"', () => {
+            try {
+                process.env.LOG_JSON_PRETTY = 'true';
+                setJsonPrettyConfigGetter(() => ({
+                    system: {
+                        logging: {
+                            jsonPretty: false, // Config says false, but env should override
+                            mcpCommDebug: false,
+                            apiDebug: false
+                        }
+                    }
+                }));
+                expect(getJsonPrettySetting()).toBe(true);
+            }
+            finally {
+                delete process.env.LOG_JSON_PRETTY;
+                setJsonPrettyConfigGetter(null);
+            }
+        });
+        it('should respect LOG_JSON_PRETTY environment variable when set to "1"', () => {
+            try {
+                process.env.LOG_JSON_PRETTY = '1';
+                setJsonPrettyConfigGetter(() => ({
+                    system: {
+                        logging: {
+                            jsonPretty: false, // Config says false, but env should override
+                            mcpCommDebug: false,
+                            apiDebug: false
+                        }
+                    }
+                }));
+                expect(getJsonPrettySetting()).toBe(true);
+            }
+            finally {
+                delete process.env.LOG_JSON_PRETTY;
+                setJsonPrettyConfigGetter(null);
+            }
+        });
+        it('should respect LOG_JSON_PRETTY environment variable when set to "false"', () => {
+            try {
+                process.env.LOG_JSON_PRETTY = 'false';
+                setJsonPrettyConfigGetter(() => ({
+                    system: {
+                        logging: {
+                            jsonPretty: true, // Config says true, but env should override
+                            mcpCommDebug: false,
+                            apiDebug: false
+                        }
+                    }
+                }));
+                expect(getJsonPrettySetting()).toBe(false);
+            }
+            finally {
+                delete process.env.LOG_JSON_PRETTY;
+                setJsonPrettyConfigGetter(null);
+            }
+        });
+        it('should respect LOG_JSON_PRETTY environment variable when set to "0"', () => {
+            try {
+                process.env.LOG_JSON_PRETTY = '0';
+                setJsonPrettyConfigGetter(() => ({
+                    system: {
+                        logging: {
+                            jsonPretty: true, // Config says true, but env should override
+                            mcpCommDebug: false,
+                            apiDebug: false
+                        }
+                    }
+                }));
+                expect(getJsonPrettySetting()).toBe(false);
+            }
+            finally {
+                delete process.env.LOG_JSON_PRETTY;
+                setJsonPrettyConfigGetter(null);
+            }
+        });
+        it('should use config getter when LOG_JSON_PRETTY is not set', () => {
+            try {
+                delete process.env.LOG_JSON_PRETTY;
+                setJsonPrettyConfigGetter(() => ({
+                    system: {
+                        logging: {
+                            jsonPretty: false,
+                            mcpCommDebug: false,
+                            apiDebug: false
+                        }
+                    }
+                }));
+                expect(getJsonPrettySetting()).toBe(false);
+            }
+            finally {
+                setJsonPrettyConfigGetter(null);
+            }
+        });
     });
     describe('all setting getters', () => {
         it('should return correct defaults when no config getter is set', () => {
             expect(getJsonPrettySetting()).toBe(true);
             expect(getMcpCommDebugSetting()).toBe(false);
-            expect(getSessionDebugSetting()).toBe(false);
+            expect(getApiDebugSetting()).toBe(false);
         });
         it('should return values from config getter when available', () => {
             setJsonPrettyConfigGetter(() => ({
@@ -217,13 +311,13 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: false,
                         mcpCommDebug: true,
-                        sessionDebug: true
+                        apiDebug: true
                     }
                 }
             }));
             expect(getJsonPrettySetting()).toBe(false);
             expect(getMcpCommDebugSetting()).toBe(true);
-            expect(getSessionDebugSetting()).toBe(true);
+            expect(getApiDebugSetting()).toBe(true);
         });
         it('should fall back to defaults when config getter fails', () => {
             setJsonPrettyConfigGetter(() => {
@@ -231,7 +325,7 @@ describe('json-utils', () => {
             });
             expect(getJsonPrettySetting()).toBe(true);
             expect(getMcpCommDebugSetting()).toBe(false);
-            expect(getSessionDebugSetting()).toBe(false);
+            expect(getApiDebugSetting()).toBe(false);
         });
     });
     describe('rawHeadersToObject', () => {
@@ -270,7 +364,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));

package/dist/server/tests/unit/utils/logger-formatter.test.d.ts

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

package/dist/server/tests/unit/utils/logger-formatter.test.d.ts.map

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

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

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { formatError } from '../../../src/utils/logger/log-formatter.js';
+describe('Logger Formatter - formatError', () => {
+    it('should return empty string for array containing exactly one empty object ([{}])', () => {
+        const error = [{}];
+        const result = formatError(error);
+        expect(result).toBe('');
+    });
+    it('should return formatted string for array containing multiple empty objects ([{}, {}, {}])', () => {
+        const error = [{}, {}, {}];
+        const result = formatError(error);
+        expect(result).toContain('{}');
+    });
+    it('should return formatted string for array containing non-empty objects', () => {
+        const error = [{ message: 'test' }];
+        const result = formatError(error);
+        expect(result).toContain('message');
+        expect(result).toContain('test');
+    });
+    it('should return formatted string for array containing mixed objects (empty and non-empty)', () => {
+        const error = [{}, { message: 'test' }, {}];
+        const result = formatError(error);
+        expect(result).toContain('message');
+        expect(result).toContain('test');
+    });
+    it('should return empty string for empty array', () => {
+        const error = [];
+        const result = formatError(error);
+        expect(result).toBe('');
+    });
+    it('should handle Error objects with message correctly', () => {
+        const error = new Error('Test error');
+        const result = formatError(error);
+        expect(result).toContain('Test error');
+    });
+    it('should handle Error objects without message correctly', () => {
+        const error = new Error();
+        const result = formatError(error);
+        expect(result).toContain('Error');
+    });
+    it('should handle Error objects with custom name correctly', () => {
+        const error = Object.assign(new Error(), { name: 'NetworkError' });
+        const result = formatError(error);
+        expect(result).toContain('NetworkError');
+    });
+    it('should handle string errors correctly', () => {
+        const error = 'string error';
+        const result = formatError(error);
+        expect(result).toBe('string error');
+    });
+    it('should handle empty objects correctly', () => {
+        const error = {};
+        const result = formatError(error);
+        expect(result).toBe('{}');
+    });
+    it('should handle null values correctly', () => {
+        const error = null;
+        const result = formatError(error);
+        expect(result).toBe('null');
+    });
+    it('should handle undefined values correctly', () => {
+        const error = undefined;
+        const result = formatError(error);
+        expect(result).toBe('undefined');
+    });
+});

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

@@ -4,6 +4,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { Logger, logWithColor } from '../../../src/utils/logger.js';
 import { setJsonPrettyConfigGetter, setDevModeEnabled } from '../../../src/utils/json-utils.js';
+import { createColoredLogMessage, createLogMessage, getCallerInfo, formatCallerInfo } from '../../../src/utils/logger/log-formatter.js';
 describe('Logger', () => {
     let logger;
     let tempLogDir;
@@ -459,4 +460,104 @@ describe('Logger', () => {
             createWriteStreamSpy.mockRestore();
         });
     });
+    describe('caller information', () => {
+        it('should enable caller information by default', () => {
+            logger = new Logger();
+            // Since showCaller is private, we test through behavior
+            const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+            logger.info('test message');
+            expect(consoleInfoSpy).toHaveBeenCalled();
+            consoleInfoSpy.mockRestore();
+        });
+        it('should allow disabling caller information', () => {
+            logger = new Logger();
+            logger.setShowCaller(false);
+            const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+            logger.info('test message');
+            expect(consoleInfoSpy).toHaveBeenCalled();
+            consoleInfoSpy.mockRestore();
+        });
+        it('should respect LOG_CALLER environment variable when set to "false"', () => {
+            try {
+                process.env.LOG_CALLER = 'false';
+                logger = new Logger();
+                // Verify the logger was created without errors
+                expect(logger).toBeDefined();
+            }
+            finally {
+                delete process.env.LOG_CALLER;
+            }
+        });
+        it('should respect LOG_CALLER environment variable when set to "0"', () => {
+            try {
+                process.env.LOG_CALLER = '0';
+                logger = new Logger();
+                expect(logger).toBeDefined();
+            }
+            finally {
+                delete process.env.LOG_CALLER;
+            }
+        });
+        it('should include caller information in log messages when enabled', () => {
+            const message = createLogMessage('info', 'test message', {
+                caller: 'test-file.ts:123'
+            });
+            expect(message).toContain('[test-file.ts:123]');
+        });
+        it('should include caller information in colored log messages when enabled', () => {
+            const message = createColoredLogMessage('info', 'test message', {
+                caller: 'test-file.ts:123'
+            });
+            expect(message).toContain('[test-file.ts:123]');
+        });
+        it('should format caller info correctly', () => {
+            const formatted = formatCallerInfo({
+                fileName: 'logger.ts',
+                lineNumber: 42,
+                columnNumber: 10
+            });
+            expect(formatted).toBe('logger.ts:42');
+        });
+        it('should format caller info without line number when lineNumber is 0', () => {
+            const formatted = formatCallerInfo({
+                fileName: 'logger.ts',
+                lineNumber: 0,
+                columnNumber: 0
+            });
+            expect(formatted).toBe('logger.ts');
+        });
+        it('should get caller info (best effort)', () => {
+            // We can't assert specific values, but we can verify it doesn't throw
+            // and either returns null or a valid object
+            getCallerInfo(0);
+            expect(true).toBe(true);
+        });
+        describe('getCallerInfo with project file detection', () => {
+            // Save original prepareStackTrace
+            const originalPrepareStackTrace = Error.prepareStackTrace;
+            afterEach(() => {
+                // Restore original prepareStackTrace
+                Error.prepareStackTrace = originalPrepareStackTrace;
+            });
+            it('should extract clean file path from full path with /src/', () => {
+                // We need to test the internal logic indirectly
+                // Since we can't easily mock the stack, we'll verify our function
+                // doesn't throw and handles the basic case
+                const result = getCallerInfo(0);
+                // Just verify it returns something (null or object)
+                expect(result === null || typeof result === 'object').toBe(true);
+            });
+            it('should prefer project source files over external files', () => {
+                // This test verifies the concept - we trust that our implementation
+                // will search for /src/ in the file paths
+                const result = getCallerInfo(0);
+                expect(result === null || typeof result === 'object').toBe(true);
+            });
+            it('should handle Windows paths with \\src\\', () => {
+                // Test the function can be called without errors
+                const result = getCallerInfo(0);
+                expect(result === null || typeof result === 'object').toBe(true);
+            });
+        });
+    });
 });

package/dist/server/tests/unit/utils/parameter-validator.test.d.ts

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

package/dist/server/tests/unit/utils/parameter-validator.test.d.ts.map

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

package/dist/server/tests/unit/utils/parameter-validator.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import { validateParameters } from '../../../src/utils/parameter-validator.js';
+describe('Parameter Validator', () => {
+    it('should return null for valid parameters', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                age: { type: 'number' }
+            },
+            required: ['name']
+        };
+        const args = { name: 'test', age: 25 };
+        const result = validateParameters(args, schema);
+        expect(result).toBeNull();
+    });
+    it('should return error for missing required parameter', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                age: { type: 'number' }
+            },
+            required: ['name', 'age']
+        };
+        const args = { name: 'test' };
+        const result = validateParameters(args, schema);
+        expect(result).toContain('Missing required parameter');
+        expect(result).toContain('age');
+    });
+    it('should return error for invalid parameter type', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                age: { type: 'number' }
+            }
+        };
+        const args = { name: 'test', age: '25' }; // age should be number, not string
+        const result = validateParameters(args, schema);
+        expect(result).toContain('Invalid type for parameter');
+        expect(result).toContain('Expected: number');
+    });
+    it('should handle schema without required fields', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                optionalField: { type: 'string' }
+            }
+        };
+        const args = {};
+        const result = validateParameters(args, schema);
+        expect(result).toBeNull();
+    });
+    it('should handle schema without properties', () => {
+        const schema = {
+            type: 'object'
+        };
+        const args = { any: 'value' };
+        const result = validateParameters(args, schema);
+        expect(result).toBeNull();
+    });
+});

package/dist/server/tests/unit/utils/process-tree.test.d.ts

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

package/dist/server/tests/unit/utils/process-tree.test.d.ts.map

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

package/dist/server/tests/unit/utils/process-tree.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getChildren, getProcessTree, isAnyInTreeRunning, getWorkingProcessPid, killProcessTree } from '../../../src/utils/process-tree.js';
+// Mock child_process module
+vi.mock('child_process', () => ({
+    spawn: vi.fn()
+}));
+describe('process-tree (non-Windows platform)', () => {
+    // Save original platform
+    const originalPlatform = process.platform;
+    beforeEach(() => {
+        // Mock non-Windows platform
+        Object.defineProperty(process, 'platform', {
+            value: 'linux',
+            configurable: true
+        });
+        vi.clearAllMocks();
+    });
+    describe('getChildren', () => {
+        it('should return empty array on non-Windows platform', async () => {
+            const result = await getChildren(1234);
+            expect(result).toEqual([]);
+        });
+    });
+    describe('getProcessTree', () => {
+        it('should return array with just the original PID on non-Windows platform', async () => {
+            const result = await getProcessTree(1234);
+            expect(result).toEqual([1234]);
+        });
+    });
+    describe('getWorkingProcessPid', () => {
+        it('should return the original PID on non-Windows platform', async () => {
+            const result = await getWorkingProcessPid(1234);
+            expect(result).toEqual(1234);
+        });
+    });
+    describe('isAnyInTreeRunning', () => {
+        it('should check just the single process on non-Windows platform', async () => {
+            // Mock process.kill to return true (process running)
+            const originalKill = process.kill;
+            process.kill = vi.fn();
+            const result = await isAnyInTreeRunning(1234);
+            expect(result).toBeDefined();
+            // Restore original
+            process.kill = originalKill;
+        });
+    });
+    describe('killProcessTree', () => {
+        it('should just kill the single process on non-Windows platform', async () => {
+            // Mock process.kill
+            const originalKill = process.kill;
+            process.kill = vi.fn();
+            await killProcessTree(1234);
+            // Restore original
+            process.kill = originalKill;
+        });
+    });
+    // Restore original platform after all tests
+    afterAll(() => {
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform,
+            configurable: true
+        });
+    });
+});
+describe('process-tree (Windows platform)', () => {
+    // Save original platform
+    const originalPlatform = process.platform;
+    beforeEach(() => {
+        // Mock Windows platform
+        Object.defineProperty(process, 'platform', {
+            value: 'win32',
+            configurable: true
+        });
+        vi.clearAllMocks();
+    });
+    describe('isProcessRunning (internal helper behavior)', () => {
+        it('should handle process.kill correctly', async () => {
+            const originalKill = process.kill;
+            // isAnyInTreeRunning will call our mocked kill
+            // We'll test this indirectly
+            const pidToCheck = 99999; // A PID that doesn't exist
+            process.kill = vi.fn((checkPid, signal) => {
+                if (checkPid === pidToCheck && signal === 0) {
+                    throw new Error('ESRCH');
+                }
+                return true;
+            });
+            const result = await isAnyInTreeRunning(pidToCheck);
+            expect(result !== undefined).toBe(true);
+            // Restore original
+            process.kill = originalKill;
+        });
+    });
+    describe('edge cases and error handling', () => {
+        it('should handle invalid PID gracefully', async () => {
+            const result = await getChildren(0);
+            expect(Array.isArray(result)).toBe(true);
+        });
+        it('should handle negative PID gracefully', async () => {
+            const result = await getProcessTree(-1);
+            expect(Array.isArray(result)).toBe(true);
+        });
+        it('should handle errors in getWorkingProcessPid gracefully', async () => {
+            const pid = 12345;
+            const result = await getWorkingProcessPid(pid);
+            // When PowerShell fails, it should fall back to returning the original PID
+            expect(result).toEqual(pid);
+        });
+    });
+    describe('killProcessTree error handling', () => {
+        it('should handle errors in killProcessTree gracefully', async () => {
+            const originalKill = process.kill;
+            process.kill = vi.fn(() => {
+                throw new Error('Access denied');
+            });
+            // This should not throw, errors should be caught
+            await expect(killProcessTree(1234)).resolves.not.toThrow();
+            // Restore original
+            process.kill = originalKill;
+        });
+    });
+    // Restore original platform after all tests
+    afterAll(() => {
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform,
+            configurable: true
+        });
+    });
+});