@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

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

@@ -1,10 +1,5 @@
-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 { SessionStateSchema, SessionStoreSchema, createEmptySessionStore, validateSessionStore } from '../../../shared/models/session.model.js';
-// Reset module cache
-vi.resetModules();
+import { describe, it, expect } from 'vitest';
+import { SessionStateSchema } from '../../../shared/models/session.model.js';
 describe('Session Model', () => {
     describe('SessionStateSchema', () => {
         it('should validate a valid session state', () => {
@@ -12,8 +7,6 @@ describe('Session Model', () => {
                 sessionId: 'test-session-123',
                 clientName: 'test-client',
                 clientVersion: '1.0.0',
-                cwd: '/path/to/project',
-                project: 'test-project',
                 createdAt: Date.now(),
                 lastAccessedAt: Date.now(),
                 metadata: {}
@@ -32,7 +25,6 @@ describe('Session Model', () => {
             };
             expect(minimalState.sessionId).toBe('test-session');
             expect(minimalState.clientName).toBeUndefined();
-            expect(minimalState.cwd).toBeUndefined();
         });
         it('should handle metadata with arbitrary keys', () => {
             const stateWithMetadata = {
@@ -48,434 +40,32 @@ describe('Session Model', () => {
             expect(stateWithMetadata.metadata.customKey).toBe('customValue');
             expect(stateWithMetadata.metadata.numericKey).toBe(123);
         });
-    });
-    describe('SessionStoreSchema', () => {
-        it('should create an empty session store', () => {
-            const store = createEmptySessionStore();
-            expect(store.version).toBe('1.0.0');
-            expect(store.sessions).toEqual({});
-        });
-        it('should validate a valid session store', () => {
-            const validStore = {
-                version: '1.0.0',
-                sessions: {
-                    'session-1': {
-                        sessionId: 'session-1',
-                        createdAt: Date.now(),
-                        lastAccessedAt: Date.now(),
-                        metadata: {}
-                    }
-                }
+        it('should support SessionState type with all optional fields', () => {
+            // Test full version
+            const fullState = {
+                sessionId: 'full-session-001',
+                clientName: 'test-client',
+                clientVersion: '1.0.0',
+                createdAt: Date.now(),
+                lastAccessedAt: Date.now(),
+                metadata: { foo: 'bar', count: 42 }
             };
-            expect(validStore.version).toBe('1.0.0');
-            expect(validStore.sessions['session-1']).toBeDefined();
-        });
-        it('should validate and normalize session store data', () => {
-            const storeData = {
-                version: '1.0.0',
-                sessions: {
-                    'session-1': {
-                        sessionId: 'session-1',
-                        createdAt: Date.now(),
-                        lastAccessedAt: Date.now(),
-                        metadata: {}
-                    }
-                }
+            expect(fullState.sessionId).toBe('full-session-001');
+            expect(fullState.clientName).toBe('test-client');
+            // Test minimal version
+            const minimalState = {
+                sessionId: 'minimal-session-001',
+                createdAt: Date.now(),
+                lastAccessedAt: Date.now(),
+                metadata: {}
             };
-            const validated = validateSessionStore(storeData);
-            expect(validated.version).toBe('1.0.0');
-            expect(validated.sessions['session-1']).toBeDefined();
-        });
-        it('should return empty store for invalid data', () => {
-            const invalidData = { invalid: 'data' };
-            const validated = validateSessionStore(invalidData);
-            expect(validated.version).toBe('1.0.0');
-            expect(validated.sessions).toEqual({});
+            expect(minimalState.sessionId).toBe('minimal-session-001');
+            expect(minimalState.clientName).toBeUndefined();
+            // Verify Schema validation
+            const fullResult = SessionStateSchema.safeParse(fullState);
+            const minimalResult = SessionStateSchema.safeParse(minimalState);
+            expect(fullResult.success).toBe(true);
+            expect(minimalResult.success).toBe(true);
         });
     });
 });
-describe('Session Persistence', () => {
-    let tempDir;
-    let sessionsPath;
-    let originalEnv;
-    beforeEach(() => {
-        originalEnv = { ...process.env };
-        // Create temporary directory
-        const testRunId = `session-test-${Date.now()}-${Math.random().toString(36).substr(2, 5)}`;
-        tempDir = path.join(os.tmpdir(), `mcp-hub-session-test-${testRunId}`);
-        sessionsPath = path.join(tempDir, 'sessions');
-        fs.mkdirSync(tempDir, { recursive: true });
-        // Set environment variables
-        process.env.MCP_HUB_CONFIG_PATH = path.join(tempDir, '.mcp-hub.json');
-    });
-    afterEach(() => {
-        // Restore environment variables
-        process.env = { ...originalEnv };
-        // Clean up temporary directory
-        if (fs.existsSync(tempDir)) {
-            let retries = 3;
-            while (retries > 0) {
-                try {
-                    fs.rmSync(tempDir, { recursive: true, force: true });
-                    break;
-                }
-                catch (error) {
-                    console.warn(`Failed to clean up test temp directory (retries left: ${retries - 1}): ${error}`);
-                    retries--;
-                    if (retries > 0) {
-                        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
-                    }
-                }
-            }
-        }
-        vi.restoreAllMocks();
-    });
-    it('should create directory if it does not exist when saving', () => {
-        const testStore = {
-            version: '1.0.0',
-            sessions: {
-                'test-session': {
-                    sessionId: 'test-session',
-                    createdAt: Date.now(),
-                    lastAccessedAt: Date.now(),
-                    metadata: {}
-                }
-            }
-        };
-        // Ensure directory doesn't exist
-        if (fs.existsSync(sessionsPath)) {
-            fs.rmSync(sessionsPath, { recursive: true, force: true });
-        }
-        // Simulate save operation - create sessions directory
-        if (!fs.existsSync(sessionsPath)) {
-            fs.mkdirSync(sessionsPath, { recursive: true });
-        }
-        // Save individual session file
-        const sessionPath = path.join(sessionsPath, 'test-session.json');
-        fs.writeFileSync(sessionPath, JSON.stringify(testStore.sessions['test-session'], null, 2));
-        // Save index file
-        const indexPath = path.join(sessionsPath, 'index.json');
-        fs.writeFileSync(indexPath, JSON.stringify({ sessions: ['test-session'] }, null, 2));
-        // Verify directory and files were created
-        expect(fs.existsSync(sessionsPath)).toBe(true);
-        expect(fs.existsSync(sessionPath)).toBe(true);
-        expect(fs.existsSync(indexPath)).toBe(true);
-        const savedSession = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
-        expect(savedSession.sessionId).toBe('test-session');
-        const savedIndex = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
-        expect(savedIndex.sessions).toContain('test-session');
-    });
-    it('should read existing sessions directory', () => {
-        // Create sessions directory
-        if (!fs.existsSync(sessionsPath)) {
-            fs.mkdirSync(sessionsPath, { recursive: true });
-        }
-        // Create individual session files
-        const session1Path = path.join(sessionsPath, 'session-1.json');
-        const session2Path = path.join(sessionsPath, 'session-2.json');
-        fs.writeFileSync(session1Path, JSON.stringify({
-            sessionId: 'session-1',
-            clientName: 'test-client',
-            createdAt: 1234567890,
-            lastAccessedAt: 1234567890,
-            metadata: {}
-        }, null, 2));
-        fs.writeFileSync(session2Path, JSON.stringify({
-            sessionId: 'session-2',
-            clientName: 'another-client',
-            createdAt: 9876543210,
-            lastAccessedAt: 9876543210,
-            metadata: {}
-        }, null, 2));
-        // Create index file
-        const indexPath = path.join(sessionsPath, 'index.json');
-        fs.writeFileSync(indexPath, JSON.stringify({
-            sessions: ['session-1', 'session-2']
-        }, null, 2));
-        // Simulate load operation
-        const indexContent = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
-        const loadedSessions = {};
-        for (const sessionId of indexContent.sessions) {
-            const sessionPath = path.join(sessionsPath, `${sessionId}.json`);
-            const sessionContent = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
-            loadedSessions[sessionId] = sessionContent;
-        }
-        const loadedStore = {
-            version: '1.0.0',
-            sessions: loadedSessions
-        };
-        const validated = validateSessionStore(loadedStore);
-        expect(validated.version).toBe('1.0.0');
-        expect(Object.keys(validated.sessions)).toHaveLength(2);
-        expect(validated.sessions['session-1'].clientName).toBe('test-client');
-        expect(validated.sessions['session-2'].clientName).toBe('another-client');
-    });
-    it('should handle missing sessions directory gracefully', () => {
-        if (fs.existsSync(sessionsPath)) {
-            fs.rmSync(sessionsPath, { recursive: true, force: true });
-        }
-        const store = createEmptySessionStore();
-        expect(store.version).toBe('1.0.0');
-        expect(store.sessions).toEqual({});
-    });
-    it('should handle invalid JSON in session files', () => {
-        // Create sessions directory
-        if (!fs.existsSync(sessionsPath)) {
-            fs.mkdirSync(sessionsPath, { recursive: true });
-        }
-        // Create invalid session file
-        const sessionPath = path.join(sessionsPath, 'invalid-session.json');
-        fs.writeFileSync(sessionPath, 'invalid json content');
-        // Create index file
-        const indexPath = path.join(sessionsPath, 'index.json');
-        fs.writeFileSync(indexPath, JSON.stringify({
-            sessions: ['invalid-session']
-        }, null, 2));
-        const content = fs.readFileSync(sessionPath, 'utf-8');
-        expect(() => JSON.parse(content)).toThrow();
-        // Verify it returns empty store when validation fails
-        const store = validateSessionStore(null);
-        expect(store.version).toBe('1.0.0');
-        expect(store.sessions).toEqual({});
-    });
-    it('should update sessions incrementally', () => {
-        // Create sessions directory
-        if (!fs.existsSync(sessionsPath)) {
-            fs.mkdirSync(sessionsPath, { recursive: true });
-        }
-        // Initial session
-        const session1Path = path.join(sessionsPath, 'session-1.json');
-        fs.writeFileSync(session1Path, JSON.stringify({
-            sessionId: 'session-1',
-            createdAt: 1234567890,
-            lastAccessedAt: 1234567890,
-            metadata: {}
-        }, null, 2));
-        // Create initial index
-        const indexPath = path.join(sessionsPath, 'index.json');
-        fs.writeFileSync(indexPath, JSON.stringify({
-            sessions: ['session-1']
-        }, null, 2));
-        // Add second session
-        const session2Path = path.join(sessionsPath, 'session-2.json');
-        fs.writeFileSync(session2Path, JSON.stringify({
-            sessionId: 'session-2',
-            createdAt: 9876543210,
-            lastAccessedAt: 9876543210,
-            metadata: {}
-        }, null, 2));
-        // Update index to include both sessions
-        fs.writeFileSync(indexPath, JSON.stringify({
-            sessions: ['session-1', 'session-2']
-        }, null, 2));
-        // Verify both sessions exist
-        expect(fs.existsSync(session1Path)).toBe(true);
-        expect(fs.existsSync(session2Path)).toBe(true);
-        const session1Content = JSON.parse(fs.readFileSync(session1Path, 'utf-8'));
-        const session2Content = JSON.parse(fs.readFileSync(session2Path, 'utf-8'));
-        expect(session1Content.sessionId).toBe('session-1');
-        expect(session2Content.sessionId).toBe('session-2');
-    });
-    it('should remove sessions when deleted', () => {
-        // Create sessions directory
-        if (!fs.existsSync(sessionsPath)) {
-            fs.mkdirSync(sessionsPath, { recursive: true });
-        }
-        // Create initial sessions
-        const session1Path = path.join(sessionsPath, 'session-1.json');
-        const session2Path = path.join(sessionsPath, 'session-2.json');
-        fs.writeFileSync(session1Path, JSON.stringify({
-            sessionId: 'session-1',
-            createdAt: 1234567890,
-            lastAccessedAt: 1234567890,
-            metadata: {}
-        }, null, 2));
-        fs.writeFileSync(session2Path, JSON.stringify({
-            sessionId: 'session-2',
-            createdAt: 9876543210,
-            lastAccessedAt: 9876543210,
-            metadata: {}
-        }, null, 2));
-        // Create initial index
-        const indexPath = path.join(sessionsPath, 'index.json');
-        fs.writeFileSync(indexPath, JSON.stringify({
-            sessions: ['session-1', 'session-2']
-        }, null, 2));
-        // Delete session-1 (remove file and update index)
-        fs.unlinkSync(session1Path);
-        // Update index to only include session-2
-        fs.writeFileSync(indexPath, JSON.stringify({
-            sessions: ['session-2']
-        }, null, 2));
-        // Verify session-1 has been deleted
-        expect(fs.existsSync(session1Path)).toBe(false);
-        expect(fs.existsSync(session2Path)).toBe(true);
-        const finalIndex = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
-        expect(finalIndex.sessions).toHaveLength(1);
-        expect(finalIndex.sessions).toContain('session-2');
-        expect(finalIndex.sessions).not.toContain('session-1');
-    });
-});
-describe('McpSessionManager with Real SDK', () => {
-    let tempDir;
-    let originalEnv;
-    beforeEach(() => {
-        originalEnv = { ...process.env };
-        // Create temporary directory
-        const testRunId = `session-mgr-test-${Date.now()}-${Math.random().toString(36).substr(2, 5)}`;
-        tempDir = path.join(os.tmpdir(), `mcp-hub-session-mgr-test-${testRunId}`);
-        fs.mkdirSync(tempDir, { recursive: true });
-        // Set environment variables
-        process.env.MCP_HUB_CONFIG_PATH = path.join(tempDir, '.mcp-hub.json');
-        process.env.SESSION_FLUSH_INTERVAL = '100'; // Fast refresh for testing
-    });
-    afterEach(() => {
-        // Restore environment variables
-        process.env = { ...originalEnv };
-        // Clean up temporary directory
-        if (fs.existsSync(tempDir)) {
-            let retries = 3;
-            while (retries > 0) {
-                try {
-                    fs.rmSync(tempDir, { recursive: true, force: true });
-                    break;
-                }
-                catch {
-                    retries--;
-                    if (retries > 0) {
-                        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
-                    }
-                }
-            }
-        }
-        vi.resetModules();
-        vi.restoreAllMocks();
-    });
-    it('should manually initialize transport._webStandardTransport for restored sessions', async () => {
-        // This test verifies the core fix logic in createSession method
-        // Use real SDK types to simulate actual runtime flow
-        // 1. Prepare test data - create real session state
-        const testSessionId = 'test-session-restore-001';
-        const testState = {
-            sessionId: testSessionId,
-            clientName: 'claude-code',
-            clientVersion: '1.0.0',
-            cwd: '/test/project/path',
-            project: 'test-project',
-            createdAt: Date.now() - 3600000,
-            lastAccessedAt: Date.now() - 60000,
-            metadata: {
-                restoredFromDisk: true,
-                testRun: 'integration-test'
-            }
-        };
-        // 2. Import real SDK types
-        // Note: We don't actually create SDK instances (to avoid side effects), but verify type compatibility
-        // Verify type import path exists
-        const { McpSessionManager: McpSessionManagerClass } = await import('../../../src/services/mcp-session-manager.js');
-        const manager = new McpSessionManagerClass();
-        manager.sessionStates.set(testSessionId, testState);
-        // Verify state injection succeeded
-        expect(manager.sessionStates.has(testSessionId)).toBe(true);
-        const injectedState = manager.sessionStates.get(testSessionId);
-        expect(injectedState).toBeDefined();
-        if (injectedState) {
-            expect(injectedState.sessionId).toBe(testSessionId);
-            expect(injectedState.clientName).toBe('claude-code');
-        }
-    });
-    it('should persist and reload session states using SessionStore schema', async () => {
-        // This test verifies the complete persistence flow - using real SessionStore model
-        // 1. Create test session store
-        const sessionsPath = path.join(tempDir, 'sessions');
-        const sessionIds = ['session-abc-123', 'session-def-456', 'session-ghi-789'];
-        const sessions = {};
-        for (const id of sessionIds) {
-            sessions[id] = {
-                sessionId: id,
-                clientName: `client-${id}`,
-                clientVersion: '2.0.0',
-                cwd: `/workspace/project-${id}`,
-                createdAt: Date.now() - 7200000,
-                lastAccessedAt: Date.now() - 300000,
-                metadata: {
-                    source: 'test-suite',
-                    createdAt: new Date().toISOString()
-                }
-            };
-        }
-        const testStore = {
-            version: '1.0.0',
-            sessions
-        };
-        // 2. Save to disk - simulate real persistence flow
-        fs.mkdirSync(path.dirname(sessionsPath), { recursive: true });
-        fs.writeFileSync(sessionsPath, JSON.stringify(testStore, null, 2));
-        // 3. Verify can be parsed using SessionStoreSchema
-        const rawContent = fs.readFileSync(sessionsPath, 'utf-8');
-        const parsed = JSON.parse(rawContent);
-        const validated = SessionStoreSchema.safeParse(parsed);
-        expect(validated.success).toBe(true);
-        if (validated.success) {
-            expect(validated.data.version).toBe('1.0.0');
-            expect(Object.keys(validated.data.sessions)).toHaveLength(3);
-            for (const id of sessionIds) {
-                expect(validated.data.sessions[id]).toBeDefined();
-                expect(validated.data.sessions[id].sessionId).toBe(id);
-            }
-        }
-    });
-    it('should support SessionState type with all optional fields', () => {
-        // This test verifies SessionState type flexibility
-        // Test full version
-        const fullState = {
-            sessionId: 'full-session-001',
-            clientName: 'test-client',
-            clientVersion: '1.0.0',
-            cwd: '/test/path',
-            project: 'test-project',
-            createdAt: Date.now(),
-            lastAccessedAt: Date.now(),
-            metadata: { foo: 'bar', count: 42 }
-        };
-        expect(fullState.sessionId).toBe('full-session-001');
-        expect(fullState.clientName).toBe('test-client');
-        // Test minimal version
-        const minimalState = {
-            sessionId: 'minimal-session-001',
-            createdAt: Date.now(),
-            lastAccessedAt: Date.now(),
-            metadata: {}
-        };
-        expect(minimalState.sessionId).toBe('minimal-session-001');
-        expect(minimalState.clientName).toBeUndefined();
-        // Verify Schema validation
-        const fullResult = SessionStateSchema.safeParse(fullState);
-        const minimalResult = SessionStateSchema.safeParse(minimalState);
-        expect(fullResult.success).toBe(true);
-        expect(minimalResult.success).toBe(true);
-    });
-    it('should integrate with real StreamableHTTPServerTransport structure', () => {
-        // This test verifies our fix is compatible with SDK's actual structure
-        // Verify the property paths we access are reasonable
-        // _webStandardTransport, sessionId, _initialized - these all actually exist in SDK
-        // We don't actually create SDK instances (may have side effects), but verify logical consistency of paths
-        // 1. Verify expected transport structure (based on our SDK code analysis)
-        const expectedTransportStructure = {
-            _webStandardTransport: {
-                sessionId: 'test-session-id',
-                _initialized: true
-            }
-        };
-        const mockTransport = expectedTransportStructure;
-        // This is what we do in the actual code
-        const webTransport = mockTransport._webStandardTransport;
-        expect(webTransport).toBeDefined();
-        if (webTransport) {
-            webTransport.sessionId = 'new-session-id';
-            webTransport._initialized = true;
-            expect(webTransport.sessionId).toBe('new-session-id');
-            expect(webTransport._initialized).toBe(true);
-        }
-    });
-});