@loop_ouroboros/mcp-hub-lite 1.0.2 → 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
                     }
                 }
             }));
@@ -212,7 +212,7 @@ describe('json-utils', () => {
                         logging: {
                             jsonPretty: false, // Config says false, but env should override
                             mcpCommDebug: false,
-                            sessionDebug: false
+                            apiDebug: false
                         }
                     }
                 }));
@@ -231,7 +231,7 @@ describe('json-utils', () => {
                         logging: {
                             jsonPretty: false, // Config says false, but env should override
                             mcpCommDebug: false,
-                            sessionDebug: false
+                            apiDebug: false
                         }
                     }
                 }));
@@ -250,7 +250,7 @@ describe('json-utils', () => {
                         logging: {
                             jsonPretty: true, // Config says true, but env should override
                             mcpCommDebug: false,
-                            sessionDebug: false
+                            apiDebug: false
                         }
                     }
                 }));
@@ -269,7 +269,7 @@ describe('json-utils', () => {
                         logging: {
                             jsonPretty: true, // Config says true, but env should override
                             mcpCommDebug: false,
-                            sessionDebug: false
+                            apiDebug: false
                         }
                     }
                 }));
@@ -288,7 +288,7 @@ describe('json-utils', () => {
                         logging: {
                             jsonPretty: false,
                             mcpCommDebug: false,
-                            sessionDebug: false
+                            apiDebug: false
                         }
                     }
                 }));
@@ -303,7 +303,7 @@ describe('json-utils', () => {
         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(() => ({
@@ -311,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(() => {
@@ -325,7 +325,7 @@ describe('json-utils', () => {
             });
             expect(getJsonPrettySetting()).toBe(true);
             expect(getMcpCommDebugSetting()).toBe(false);
-            expect(getSessionDebugSetting()).toBe(false);
+            expect(getApiDebugSetting()).toBe(false);
         });
     });
     describe('rawHeadersToObject', () => {
@@ -364,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/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
+        });
+    });
+});

package/dist/server/tests/unit/utils/request-context.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { requestContext, getSessionContext, getSessionCwd } from '../../../src/utils/request-context.js';
+import { requestContext, getSessionContext } from '../../../src/utils/request-context.js';
 describe('Request Context', () => {
     beforeEach(() => {
         // Clean up any existing context
@@ -11,14 +11,11 @@ describe('Request Context', () => {
     });
     it('should return undefined when no context is set', () => {
         expect(getSessionContext()).toBeUndefined();
-        expect(getSessionCwd()).toBeUndefined();
     });
     it('should store and retrieve session context correctly', async () => {
         const testContext = {
             sessionId: 'test-session',
             clientName: 'Test Client',
-            cwd: '/test/cwd',
-            project: 'test-project',
             ip: '127.0.0.1',
             userAgent: 'test-agent',
             timestamp: Date.now()
@@ -26,8 +23,6 @@ describe('Request Context', () => {
         await requestContext.run(testContext, () => {
             const context = getSessionContext();
             expect(context).toEqual(testContext);
-            const cwd = getSessionCwd();
-            expect(cwd).toBe('/test/cwd');
         });
     });
     it('should handle partial context correctly', async () => {
@@ -38,19 +33,15 @@ describe('Request Context', () => {
         await requestContext.run(partialContext, () => {
             const context = getSessionContext();
             expect(context).toEqual(partialContext);
-            const cwd = getSessionCwd();
-            expect(cwd).toBeUndefined();
         });
     });
     it('should maintain context isolation between async operations', async () => {
         const context1 = {
             sessionId: 'session-1',
-            cwd: '/path/1',
             timestamp: Date.now()
         };
         const context2 = {
             sessionId: 'session-2',
-            cwd: '/path/2',
             timestamp: Date.now()
         };
         let result1;
@@ -58,25 +49,15 @@ describe('Request Context', () => {
         const operation1 = requestContext.run(context1, async () => {
             // Simulate async operation
             await new Promise((resolve) => setTimeout(resolve, 10));
-            result1 = getSessionCwd();
+            result1 = getSessionContext();
         });
         const operation2 = requestContext.run(context2, async () => {
             // Simulate async operation
             await new Promise((resolve) => setTimeout(resolve, 5));
-            result2 = getSessionCwd();
+            result2 = getSessionContext();
         });
         await Promise.all([operation1, operation2]);
-        expect(result1).toBe('/path/1');
-        expect(result2).toBe('/path/2');
-    });
-    it('should return undefined for getSessionCwd when cwd is not set', async () => {
-        const contextWithoutCwd = {
-            sessionId: 'no-cwd-session',
-            timestamp: Date.now()
-        };
-        await requestContext.run(contextWithoutCwd, () => {
-            const cwd = getSessionCwd();
-            expect(cwd).toBeUndefined();
-        });
+        expect(result1).toEqual(context1);
+        expect(result2).toEqual(context2);
     });
 });

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

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

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

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