memory-journal-mcp 6.1.2 → 6.2.1

package/tests/server/mcp-server.test.ts

@@ -1,1326 +0,0 @@
-/**
- * McpServer Tests
- *
- * Tests the createServer() function with mocked MCP SDK, database,
- * vector manager, and GitHub integration. Verifies tool/resource/prompt
- * registration and server initialization flows.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-
-// ============================================================================
-// Hoisted mocks
-// ============================================================================
-
-const {
-    mockRegisterTool,
-    mockRegisterResource,
-    mockRegisterPrompt,
-    mockConnect,
-    mockServer,
-    mockDbInitialize,
-    mockDbGetRecentEntries,
-    mockDbGetStatistics,
-    mockDbClose,
-    mockDbGetRawDb,
-    mockVectorInitialize,
-    mockVectorRebuildIndex,
-    mockGitHubIsApiAvailable,
-    mockCreateEntry,
-    mockStdioTransport,
-    mockListTags,
-    mockHandlers,
-    mockSigintHandlers,
-} = vi.hoisted(() => ({
-    mockRegisterTool: vi.fn(),
-    mockRegisterResource: vi.fn(),
-    mockRegisterPrompt: vi.fn(),
-    mockConnect: vi.fn().mockResolvedValue(undefined),
-    mockServer: { server: {} },
-    mockDbInitialize: vi.fn().mockResolvedValue(undefined),
-    mockDbGetRecentEntries: vi.fn().mockReturnValue([
-        {
-            id: 1,
-            content: 'Test entry',
-            entryType: 'personal_reflection',
-            timestamp: new Date().toISOString(),
-            isPersonal: true,
-            tags: [],
-        },
-    ]),
-    mockDbGetStatistics: vi.fn().mockReturnValue({
-        totalEntries: 5,
-        entriesByType: {},
-        entriesByPeriod: [],
-        causalMetrics: { blocked_by: 0, resolved: 0, caused: 0 },
-    }),
-    mockDbClose: vi.fn(),
-    mockDbGetRawDb: vi.fn().mockReturnValue({
-        exec: vi.fn().mockReturnValue([]),
-    }),
-    mockVectorInitialize: vi.fn().mockResolvedValue(undefined),
-    mockVectorRebuildIndex: vi.fn().mockResolvedValue(10),
-    mockGitHubIsApiAvailable: vi.fn().mockReturnValue(false),
-    mockCreateEntry: vi.fn().mockReturnValue({
-        id: 1,
-        content: 'test',
-        entryType: 'personal_reflection',
-        timestamp: new Date().toISOString(),
-        isPersonal: true,
-        tags: [],
-    }),
-    mockStdioTransport: {},
-    mockListTags: vi.fn().mockReturnValue([]),
-    mockHandlers: {
-        get: {} as Record<string, Function>,
-        post: {} as Record<string, Function>,
-        delete: {} as Record<string, Function>,
-        all: {} as Record<string, Function>,
-        useMiddlewares: [] as Function[],
-    },
-    mockSigintHandlers: [] as Function[],
-}))
-
-// ============================================================================
-// Module mocks
-// ============================================================================
-
-vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
-    McpServer: function () {
-        return {
-            registerTool: mockRegisterTool,
-            registerResource: mockRegisterResource,
-            registerPrompt: mockRegisterPrompt,
-            connect: mockConnect,
-            server: mockServer,
-        }
-    },
-    ResourceTemplate: function () {
-        return {
-            uriTemplate: { template: 'mock-template' },
-        }
-    },
-}))
-
-vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
-    StdioServerTransport: function () {
-        return mockStdioTransport
-    },
-}))
-
-vi.mock('@modelcontextprotocol/sdk/server/streamableHttp.js', () => ({
-    StreamableHTTPServerTransport: function () {
-        return {
-            handleRequest: vi.fn().mockResolvedValue(undefined),
-            close: vi.fn().mockResolvedValue(undefined),
-            sessionId: undefined,
-        }
-    },
-}))
-
-vi.mock('@modelcontextprotocol/sdk/types.js', () => ({
-    isInitializeRequest: vi.fn().mockReturnValue(false),
-}))
-
-vi.mock('../../src/database/sqlite-adapter/index.js', () => ({
-    DatabaseAdapter: function () {
-        return {
-            initialize: mockDbInitialize,
-            getRecentEntries: mockDbGetRecentEntries,
-            getStatistics: mockDbGetStatistics,
-            getActiveEntryCount: vi.fn().mockReturnValue(5),
-            createEntry: mockCreateEntry,
-            getEntryById: vi.fn().mockReturnValue(null),
-            searchEntries: vi.fn().mockReturnValue([]),
-            searchByDateRange: vi.fn().mockReturnValue([]),
-            getRelationships: vi.fn().mockReturnValue([]),
-            linkEntries: vi.fn().mockReturnValue({ id: 1, relationshipType: 'references' }),
-            updateEntry: vi.fn().mockReturnValue(null),
-            deleteEntry: vi.fn().mockReturnValue(true),
-            listTags: mockListTags,
-            mergeTags: vi.fn().mockReturnValue({ sourceDeleted: true, entriesUpdated: 0 }),
-            applyTeamSchema: vi.fn(),
-            getHealthStatus: vi.fn().mockReturnValue({
-                database: { path: 'test.db', entryCount: 5, sizeBytes: 1000 },
-            }),
-            exportToFile: vi.fn().mockReturnValue({
-                filename: 'backup.db',
-                path: '/tmp/backup.db',
-                sizeBytes: 1000,
-            }),
-            listBackups: vi.fn().mockReturnValue([]),
-            getTagsForEntry: vi.fn().mockReturnValue([]),
-            getRawDb: mockDbGetRawDb,
-            getEntriesPage: vi.fn().mockReturnValue([]),
-            close: mockDbClose,
-        }
-    },
-}))
-
-vi.mock('../../src/vector/vector-search-manager.js', () => ({
-    VectorSearchManager: function () {
-        return {
-            initialize: mockVectorInitialize,
-            isInitialized: vi.fn().mockReturnValue(false),
-            search: vi.fn().mockResolvedValue([]),
-            addEntry: vi.fn().mockResolvedValue(true),
-            removeEntry: vi.fn().mockResolvedValue(true),
-            rebuildIndex: mockVectorRebuildIndex,
-            getStats: vi
-                .fn()
-                .mockResolvedValue({ itemCount: 0, modelName: 'test', dimensions: 384 }),
-            generateEmbedding: vi.fn().mockResolvedValue(new Array(384).fill(0)),
-        }
-    },
-}))
-
-vi.mock('../../src/github/github-integration.js', () => ({
-    GitHubIntegration: function () {
-        return {
-            isApiAvailable: mockGitHubIsApiAvailable,
-            getRepoInfo: vi.fn().mockResolvedValue({ owner: null, repo: null, branch: null }),
-            getCachedRepoInfo: vi.fn().mockReturnValue(null),
-            getRepoContext: vi.fn().mockResolvedValue(null),
-            getIssues: vi.fn().mockResolvedValue([]),
-            getIssue: vi.fn().mockResolvedValue(null),
-            createIssue: vi.fn().mockResolvedValue(null),
-            closeIssue: vi.fn().mockResolvedValue(null),
-            getPullRequests: vi.fn().mockResolvedValue([]),
-            getPullRequest: vi.fn().mockResolvedValue(null),
-            getWorkflowRuns: vi.fn().mockResolvedValue([]),
-            getProjectKanban: vi.fn().mockResolvedValue(null),
-            getMilestones: vi.fn().mockResolvedValue([]),
-            getMilestone: vi.fn().mockResolvedValue(null),
-            createMilestone: vi.fn().mockResolvedValue(null),
-            updateMilestone: vi.fn().mockResolvedValue(null),
-            deleteMilestone: vi.fn().mockResolvedValue(null),
-            moveProjectItem: vi.fn().mockResolvedValue({ success: false }),
-            addProjectItem: vi.fn().mockResolvedValue({ success: false }),
-            clearCache: vi.fn(),
-            invalidateCache: vi.fn(),
-        }
-    },
-}))
-
-// Mock express to avoid actual HTTP server creation
-vi.mock('express', () => {
-    const mockApp = {
-        use: vi.fn().mockImplementation((...args: unknown[]) => {
-            if (args.length === 1 && typeof args[0] === 'function') {
-                mockHandlers.useMiddlewares.push(args[0] as Function)
-            }
-        }),
-        get: vi.fn().mockImplementation((path: string, handler: unknown) => {
-            mockHandlers.get[path] = handler as () => void
-        }),
-        post: vi.fn().mockImplementation((path: string, handler: unknown) => {
-            mockHandlers.post[path] = handler as () => void
-        }),
-        delete: vi.fn().mockImplementation((path: string, handler: unknown) => {
-            mockHandlers.delete[path] = handler as () => void
-        }),
-        all: vi.fn().mockImplementation((path: string, handler: unknown) => {
-            mockHandlers.all[path] = handler as () => void
-        }),
-        listen: vi.fn().mockImplementation((_port: number, _host: string, cb?: () => void) => {
-            if (cb) cb()
-            return {
-                on: vi.fn(),
-                close: vi.fn(),
-            }
-        }),
-    }
-    const expressFn = vi.fn().mockReturnValue(mockApp)
-    return {
-        default: Object.assign(expressFn, {
-            json: vi.fn().mockReturnValue(vi.fn()),
-        }),
-    }
-})
-
-// Capture process.on('SIGINT') handlers for testing
-vi.spyOn(process, 'on').mockImplementation((event: string, handler: Function) => {
-    if (event === 'SIGINT') {
-        mockSigintHandlers.push(handler)
-    }
-    return process
-})
-vi.spyOn(process, 'exit').mockImplementation((() => {}) as never)
-
-// ============================================================================
-// Import after mocks
-// ============================================================================
-
-import { createServer, type ServerOptions } from '../../src/server/mcp-server.js'
-
-describe('McpServer', () => {
-    beforeEach(() => {
-        // Reset call counts but preserve mock implementations
-        // (vi.clearAllMocks() would wipe .mockImplementation() on express mock)
-        mockRegisterTool.mockClear()
-        mockRegisterResource.mockClear()
-        mockRegisterPrompt.mockClear()
-        mockConnect.mockClear()
-        mockDbInitialize.mockClear()
-        mockDbClose.mockClear()
-        mockVectorInitialize.mockClear()
-        mockVectorRebuildIndex.mockClear()
-        mockCreateEntry.mockClear()
-        // Clear captured handler references
-        mockHandlers.get = {}
-        mockHandlers.post = {}
-        mockHandlers.delete = {}
-        mockHandlers.all = {}
-        mockHandlers.useMiddlewares.length = 0
-        mockSigintHandlers.length = 0
-    })
-
-    // ========================================================================
-    // Server initialization
-    // ========================================================================
-
-    describe('createServer - stdio transport', () => {
-        it('should initialize database and register tools/resources/prompts', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            // Database should be initialized
-            expect(mockDbInitialize).toHaveBeenCalledOnce()
-
-            // Tools should be registered
-            expect(mockRegisterTool).toHaveBeenCalled()
-            expect(mockRegisterTool.mock.calls.length).toBeGreaterThan(10)
-
-            // Resources should be registered
-            expect(mockRegisterResource).toHaveBeenCalled()
-            expect(mockRegisterResource.mock.calls.length).toBeGreaterThan(5)
-
-            // Prompts should be registered
-            expect(mockRegisterPrompt).toHaveBeenCalled()
-
-            // Should connect with stdio transport
-            expect(mockConnect).toHaveBeenCalled()
-        })
-
-        it('should pass tool options with description', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            // First registered tool should have description
-            const firstCall = mockRegisterTool.mock.calls[0] as unknown[]
-            expect(firstCall).toBeDefined()
-            expect(typeof firstCall[0]).toBe('string') // tool name
-            expect(firstCall[1]).toBeDefined() // tool options with description
-        })
-
-        it('should register create_entry tool', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            // Check that 'create_entry' was registered
-            const toolNames = mockRegisterTool.mock.calls.map(
-                (call: unknown[]) => call[0]
-            ) as string[]
-            expect(toolNames).toContain('create_entry')
-            expect(toolNames).toContain('get_entry_by_id')
-            expect(toolNames).toContain('search_entries')
-        })
-    })
-
-    // ========================================================================
-    // Tool filter
-    // ========================================================================
-
-    describe('createServer - with tool filter', () => {
-        it('should apply tool filter when provided', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-                toolFilter: 'core',
-            })
-
-            // Should still register tools (filtered set)
-            expect(mockRegisterTool).toHaveBeenCalled()
-            // Filtered set should be smaller than full set
-            const filteredCount = mockRegisterTool.mock.calls.length
-            expect(filteredCount).toBeGreaterThan(0)
-        })
-    })
-
-    // ========================================================================
-    // Auto-rebuild vector index
-    // ========================================================================
-
-    describe('createServer - auto rebuild index', () => {
-        it('should rebuild vector index when autoRebuildIndex is true', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-                autoRebuildIndex: true,
-            })
-
-            expect(mockVectorInitialize).toHaveBeenCalledOnce()
-            expect(mockVectorRebuildIndex).toHaveBeenCalled()
-        })
-
-        it('should NOT rebuild index when autoRebuildIndex is not set', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            expect(mockVectorInitialize).not.toHaveBeenCalled()
-            expect(mockVectorRebuildIndex).not.toHaveBeenCalled()
-        })
-    })
-
-    // ========================================================================
-    // Team Database & Sandbox Mode
-    // ========================================================================
-
-    describe('createServer - team database and sandbox', () => {
-        it('should initialize team database and team vector manager when teamDbPath is provided', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-                teamDbPath: './team.db',
-            })
-            // Since mockDbInitialize is shared, it should be called twice (once for main, once for team)
-            expect(mockDbInitialize).toHaveBeenCalledTimes(2)
-        })
-
-        it('should configure sandbox mode when provided', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-                sandboxMode: 'isolate' as const,
-            })
-            // Assert server creation succeeded
-            expect(mockConnect).toHaveBeenCalled()
-        })
-    })
-
-    // ========================================================================
-    // Resource registration
-    // ========================================================================
-
-    describe('createServer - resource registration', () => {
-        it('should register both static and template resources', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            // Should have both static and template resources
-            const resourceCalls = mockRegisterResource.mock.calls
-            expect(resourceCalls.length).toBeGreaterThan(10)
-        })
-    })
-
-    // ========================================================================
-    // Prompt registration
-    // ========================================================================
-
-    describe('createServer - prompt registration', () => {
-        it('should register prompts with argsSchema', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            const promptCalls = mockRegisterPrompt.mock.calls
-            expect(promptCalls.length).toBeGreaterThan(0)
-
-            // Each prompt has name, options, handler
-            const firstPrompt = promptCalls[0] as unknown[]
-            expect(typeof firstPrompt[0]).toBe('string') // prompt name
-            expect(firstPrompt[1]).toBeDefined() // options with description
-            expect(typeof firstPrompt[2]).toBe('function') // handler
-        })
-    })
-
-    // ========================================================================
-    // HTTP transport (stateless)
-    // ========================================================================
-
-    describe('createServer - HTTP stateless', () => {
-        it('should set up express app for stateless HTTP', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: true,
-                port: 4000,
-                host: '0.0.0.0',
-            })
-
-            // Should connect to transport
-            expect(mockConnect).toHaveBeenCalled()
-        })
-    })
-
-    // ========================================================================
-    // HTTP transport (stateful)
-    // ========================================================================
-
-    describe('createServer - HTTP stateful', () => {
-        it('should set up express app for stateful HTTP with session management', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: false,
-                port: 5000,
-                host: '127.0.0.1',
-            })
-
-            // Should NOT call connect for stateful mode (connects per-session)
-            // The server.connect is only called once for stateless or stdio
-            // For stateful, connect is called per new session initialization
-            expect(mockRegisterTool).toHaveBeenCalled()
-        })
-
-        it('should configure CORS origin from options', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                corsOrigins: ['https://example.com'],
-            })
-
-            expect(mockRegisterTool).toHaveBeenCalled()
-        })
-    })
-
-    // ========================================================================
-    // Default project number
-    // ========================================================================
-
-    describe('createServer - defaultProjectNumber', () => {
-        it('should pass defaultProjectNumber through to tools', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-                defaultProjectNumber: 42,
-            })
-
-            // Tools should be registered (they receive defaultProjectNumber internally)
-            expect(mockRegisterTool).toHaveBeenCalled()
-        })
-    })
-
-    // ========================================================================
-    // Tool handler callbacks
-    // ========================================================================
-
-    describe('tool handler callbacks', () => {
-        it('should invoke tool handler and return structured content', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            // Get the handler for a tool
-            const createEntryCalls = mockRegisterTool.mock.calls.filter(
-                (call: unknown[]) => call[0] === 'create_entry'
-            ) as unknown[][]
-
-            expect(createEntryCalls.length).toBe(1)
-            const handler = createEntryCalls[0]![2] as (
-                args: Record<string, unknown>,
-                extra: Record<string, unknown>
-            ) => Promise<{ content: { type: string; text: string }[] }>
-
-            const result = await handler({ content: 'Test from mock' }, { _meta: {} })
-
-            expect(result.content).toBeDefined()
-            expect(result.content[0]!.type).toBe('text')
-        })
-
-        it('should return structured error content when tool throws', async () => {
-            // Make createEntry throw
-            mockCreateEntry.mockImplementationOnce(() => {
-                throw new Error('Database error')
-            })
-
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            const createEntryCalls = mockRegisterTool.mock.calls.filter(
-                (call: unknown[]) => call[0] === 'create_entry'
-            ) as unknown[][]
-
-            const handler = createEntryCalls[0]![2] as (
-                args: Record<string, unknown>,
-                extra: Record<string, unknown>
-            ) => Promise<{
-                content: { type: string; text: string }[]
-                isError?: boolean
-            }>
-
-            const result = await handler({ content: 'Will fail' }, { _meta: {} })
-
-            // With deterministic error handling, errors are caught by the handler
-            // and returned as structured JSON (not as MCP isError)
-            expect(result.isError).toBeUndefined()
-            expect(result.content[0]!.type).toBe('text')
-
-            const parsed = JSON.parse(result.content[0]!.text) as {
-                success: boolean
-                error: string
-            }
-            expect(parsed.success).toBe(false)
-            expect(parsed.error).toContain('Database error')
-        })
-    })
-
-    // ========================================================================
-    // Prompt handler callbacks
-    // ========================================================================
-
-    describe('prompt handler callbacks', () => {
-        it('should invoke prompt handler and return messages', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            const promptCalls = mockRegisterPrompt.mock.calls
-            expect(promptCalls.length).toBeGreaterThan(0)
-
-            // Get the handler for the first prompt
-            const handler = promptCalls[0]![2] as (
-                args: Record<string, string>
-            ) => Promise<{ messages: unknown[] }>
-
-            const result = await handler({})
-
-            expect(result.messages).toBeDefined()
-            expect(result.messages.length).toBeGreaterThan(0)
-        })
-    })
-
-    // ========================================================================
-    // Resource handler callbacks
-    // ========================================================================
-
-    describe('resource handler callbacks', () => {
-        it('should invoke resource handler and return contents', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-                briefingConfig: { defaultProjectNumber: 1337 }, // Also tests passing explicit briefingConfig
-            })
-
-            // Find a static resource handler (e.g., memory://health is a simple one)
-            const healthCalls = mockRegisterResource.mock.calls.filter(
-                (call: unknown[]) => call[0] === 'Health Status'
-            ) as unknown[][]
-
-            if (healthCalls.length > 0) {
-                const handler = healthCalls[0]![3] as (
-                    uri: URL
-                ) => Promise<{ contents: { uri: string; text: string }[] }>
-
-                const result = await handler(new URL('memory://health'))
-
-                expect(result.contents).toBeDefined()
-                expect(result.contents.length).toBeGreaterThan(0)
-                expect(result.contents[0]!.uri).toBe('memory://health')
-            }
-        })
-    })
-
-    // ========================================================================
-    // SIGINT Handlers
-    // ========================================================================
-
-    describe('SIGINT clean shutdown', () => {
-        it('should register SIGINT handlers and cleanly close database (stdio)', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            expect(mockSigintHandlers.length).toBeGreaterThan(0)
-
-            // Execute the last registered SIGINT handler
-            const handler = mockSigintHandlers[mockSigintHandlers.length - 1]
-            if (handler) {
-                handler()
-                expect(mockDbClose).toHaveBeenCalled()
-            }
-        })
-    })
-
-    // ========================================================================
-    // HTTP Endpoint handlers
-    // ========================================================================
-
-    describe('HTTP endpoint handlers', () => {
-        it('should handle POST /mcp in stateless mode', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: true,
-            })
-
-            const postHandler = mockHandlers.post['/mcp']
-            expect(postHandler).toBeDefined()
-
-            const mockReq = { body: { jsonrpc: '2.0', id: 1, method: 'initialize' } }
-            const mockRes = { status: vi.fn().mockReturnThis(), json: vi.fn(), end: vi.fn() }
-
-            // Invoke the handler
-            if (postHandler) {
-                await postHandler(mockReq, mockRes)
-            }
-            // StreamableHTTPServerTransport.handleRequest should be called (from our mock)
-        })
-
-        it('should handle GET /mcp and DELETE /mcp in stateless mode', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: true,
-            })
-
-            const getHandler = mockHandlers.get['/mcp']
-            const deleteHandler = mockHandlers.delete['/mcp']
-            expect(getHandler).toBeDefined()
-            expect(deleteHandler).toBeDefined()
-
-            const mockReq = {}
-            const mockRes = { status: vi.fn().mockReturnThis(), json: vi.fn(), end: vi.fn() }
-
-            if (getHandler) await getHandler(mockReq, mockRes)
-            expect(mockRes.status).toHaveBeenCalledWith(405)
-
-            if (deleteHandler) await deleteHandler(mockReq, mockRes)
-            expect(mockRes.status).toHaveBeenCalledWith(204)
-        })
-
-        it('should handle stateful mode POST /mcp validation failures', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: false,
-            })
-
-            const postHandler = mockHandlers.post['/mcp']
-            expect(postHandler).toBeDefined()
-
-            // Missing session ID and not initialization request
-            const mockReq = { headers: {}, body: {} } // isInitializeRequest returns false
-            const mockRes = { status: vi.fn().mockReturnThis(), json: vi.fn() }
-
-            if (postHandler) {
-                await postHandler(mockReq, mockRes)
-            }
-
-            expect(mockRes.status).toHaveBeenCalledWith(400)
-            expect(mockRes.json).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    error: expect.objectContaining({
-                        message: expect.stringContaining('No valid session ID'),
-                    }),
-                })
-            )
-        })
-
-        it('should handle OPTIONS preflight via middleware', async () => {
-            const middlewareFns: Function[] = []
-            const { default: expressMod } = await import('express')
-            const app = expressMod()
-            ;(app.use as ReturnType<typeof vi.fn>).mockImplementation((...args: unknown[]) => {
-                if (args.length === 1 && typeof args[0] === 'function') {
-                    middlewareFns.push(args[0] as Function)
-                }
-            })
-
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-            })
-
-            // Find the OPTIONS middleware
-            let optionsMwFound = false
-            for (const mw of middlewareFns) {
-                const mockResOptions = {
-                    status: vi.fn().mockReturnThis(),
-                    end: vi.fn(),
-                    setHeader: vi.fn(),
-                    json: vi.fn(),
-                }
-                const nextFn = vi.fn()
-                mw({ method: 'OPTIONS', headers: { host: 'localhost' } }, mockResOptions, nextFn)
-                if (mockResOptions.status.mock.calls.some((c: unknown[]) => c[0] === 204)) {
-                    optionsMwFound = true
-                    expect(nextFn).not.toHaveBeenCalled()
-
-                    // Also verify non-OPTIONS calls next
-                    const mockRes2 = {
-                        status: vi.fn().mockReturnThis(),
-                        end: vi.fn(),
-                        setHeader: vi.fn(),
-                        json: vi.fn(),
-                    }
-                    const nextFn2 = vi.fn()
-                    mw({ method: 'GET', headers: { host: 'localhost' } }, mockRes2, nextFn2)
-                    expect(nextFn2).toHaveBeenCalled()
-                    break
-                }
-            }
-            expect(optionsMwFound).toBe(true)
-        })
-
-        it('should invoke security headers middleware', async () => {
-            const middlewareFns: Function[] = []
-            const { default: expressMod } = await import('express')
-            const app = expressMod()
-            // Capture all middleware registered via app.use()
-            ;(app.use as ReturnType<typeof vi.fn>).mockImplementation((...args: unknown[]) => {
-                if (args.length === 1 && typeof args[0] === 'function') {
-                    middlewareFns.push(args[0] as Function)
-                }
-            })
-
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: true,
-            })
-
-            // The first middleware (after express.json) should set security headers
-            // Find a middleware that calls setHeader for security headers
-            let securityMiddlewareFound = false
-            for (const mw of middlewareFns) {
-                const mockRes = {
-                    setHeader: vi.fn(),
-                    status: vi.fn().mockReturnThis(),
-                    end: vi.fn(),
-                    json: vi.fn(),
-                }
-                const nextFn = vi.fn()
-                mw({ headers: { host: 'localhost' } }, mockRes, nextFn)
-                const calls = mockRes.setHeader.mock.calls as [string, string][]
-                const headerNames = calls.map((c) => c[0])
-                if (headerNames.includes('X-Content-Type-Options')) {
-                    securityMiddlewareFound = true
-                    expect(headerNames).toContain('X-Frame-Options')
-                    expect(headerNames).toContain('Content-Security-Policy')
-                    expect(headerNames).toContain('Cache-Control')
-                    expect(headerNames).toContain('Referrer-Policy')
-                    expect(nextFn).toHaveBeenCalled()
-                    break
-                }
-            }
-            expect(securityMiddlewareFound).toBe(true)
-        })
-
-        it('should invoke CORS middleware and handle OPTIONS', async () => {
-            const middlewareFns: Function[] = []
-            const { default: expressMod } = await import('express')
-            const app = expressMod()
-            ;(app.use as ReturnType<typeof vi.fn>).mockImplementation((...args: unknown[]) => {
-                if (args.length === 1 && typeof args[0] === 'function') {
-                    middlewareFns.push(args[0] as Function)
-                }
-            })
-
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: true,
-                corsOrigins: ['https://test.example.com'],
-            })
-
-            // Find the security+CORS middleware (sets Access-Control-Allow-Origin)
-            let corsMiddlewareFound = false
-            for (const mw of middlewareFns) {
-                const mockRes = {
-                    setHeader: vi.fn(),
-                    status: vi.fn().mockReturnThis(),
-                    end: vi.fn(),
-                    json: vi.fn(),
-                }
-
-                const noopNext = vi.fn()
-                mw(
-                    {
-                        method: 'GET',
-                        headers: { origin: 'https://test.example.com', host: 'localhost' },
-                    },
-                    mockRes,
-                    noopNext
-                )
-                const calls = mockRes.setHeader.mock.calls as [string, string][]
-                const headerNames = calls.map((c) => c[0])
-                if (headerNames.includes('Access-Control-Allow-Methods')) {
-                    corsMiddlewareFound = true
-                    expect(headerNames).toContain('Access-Control-Allow-Headers')
-                    expect(headerNames).toContain('Access-Control-Expose-Headers')
-                    expect(noopNext).toHaveBeenCalled()
-                    break
-                }
-            }
-            expect(corsMiddlewareFound).toBe(true)
-
-            // Find OPTIONS middleware (returns 204)
-            let optionsMwFound = false
-            for (const mw of middlewareFns) {
-                const mockRes2 = {
-                    setHeader: vi.fn(),
-                    status: vi.fn().mockReturnThis(),
-                    end: vi.fn(),
-                    json: vi.fn(),
-                }
-                const nextFn = vi.fn()
-                mw({ method: 'OPTIONS', headers: { host: 'localhost' } }, mockRes2, nextFn)
-                if (mockRes2.status.mock.calls.some((c: unknown[]) => c[0] === 204)) {
-                    optionsMwFound = true
-                    expect(nextFn).not.toHaveBeenCalled()
-                    break
-                }
-            }
-            expect(optionsMwFound).toBe(true)
-
-            // Test CORS middleware with non-OPTIONS request (calls next)
-            for (const mw of middlewareFns) {
-                const mockRes = {
-                    setHeader: vi.fn(),
-                    status: vi.fn().mockReturnThis(),
-                    end: vi.fn(),
-                    json: vi.fn(),
-                }
-                const nextFn = vi.fn()
-                mw(
-                    {
-                        method: 'POST',
-                        headers: { origin: 'https://test.example.com', host: 'localhost' },
-                    },
-                    mockRes,
-                    nextFn
-                )
-                const calls = mockRes.setHeader.mock.calls as [string, string][]
-                const headerNames = calls.map((c) => c[0])
-                if (headerNames.includes('Access-Control-Allow-Methods')) {
-                    expect(nextFn).toHaveBeenCalled()
-                    break
-                }
-            }
-        })
-
-        it('should handle stateful GET /mcp without session', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: false,
-            })
-
-            const getHandler = mockHandlers.get['/mcp']
-            expect(getHandler).toBeDefined()
-
-            // No session ID
-            const mockReq = { headers: {} }
-            const mockRes = {
-                status: vi.fn().mockReturnThis(),
-                send: vi.fn(),
-            }
-
-            if (getHandler) await getHandler(mockReq, mockRes)
-            expect(mockRes.status).toHaveBeenCalledWith(400)
-            expect(mockRes.send).toHaveBeenCalledWith(
-                expect.stringContaining('Invalid or missing session ID')
-            )
-        })
-
-        it('should handle stateful DELETE /mcp without session', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: false,
-            })
-
-            const deleteHandler = mockHandlers.delete['/mcp']
-            expect(deleteHandler).toBeDefined()
-
-            const mockReq = { headers: {} }
-            const mockRes = {
-                status: vi.fn().mockReturnThis(),
-                send: vi.fn(),
-            }
-
-            if (deleteHandler) await deleteHandler(mockReq, mockRes)
-            expect(mockRes.status).toHaveBeenCalledWith(400)
-        })
-
-        it('should handle stateful GET /mcp with invalid session', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: false,
-            })
-
-            const getHandler = mockHandlers.get['/mcp']
-            const mockReq = { headers: { 'mcp-session-id': 'nonexistent-session' } }
-            const mockRes = {
-                status: vi.fn().mockReturnThis(),
-                send: vi.fn(),
-            }
-
-            if (getHandler) await getHandler(mockReq, mockRes)
-            expect(mockRes.status).toHaveBeenCalledWith(400)
-        })
-
-        it('should handle stateful DELETE /mcp with invalid session', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: false,
-            })
-
-            const deleteHandler = mockHandlers.delete['/mcp']
-            const mockReq = { headers: { 'mcp-session-id': 'nonexistent-session' } }
-            const mockRes = {
-                status: vi.fn().mockReturnThis(),
-                send: vi.fn(),
-            }
-
-            if (deleteHandler) await deleteHandler(mockReq, mockRes)
-            expect(mockRes.status).toHaveBeenCalledWith(400)
-        })
-
-        it('should handle stateful POST /mcp with initialization request', async () => {
-            // Make isInitializeRequest return true for this test
-            const { isInitializeRequest: mockIsInit } =
-                await import('@modelcontextprotocol/sdk/types.js')
-            ;(mockIsInit as ReturnType<typeof vi.fn>).mockReturnValueOnce(true)
-
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: false,
-            })
-
-            const postHandler = mockHandlers.post['/mcp']
-            expect(postHandler).toBeDefined()
-
-            // Simulate initialization request (no session ID, isInitializeRequest returns true)
-            const mockReq = {
-                headers: {},
-                body: { jsonrpc: '2.0', id: 1, method: 'initialize' },
-            }
-            const mockRes = {
-                status: vi.fn().mockReturnThis(),
-                json: vi.fn(),
-                headersSent: false,
-            }
-
-            if (postHandler) {
-                await postHandler(mockReq, mockRes)
-                // Wait for async void handler to complete
-                await new Promise((r) => setTimeout(r, 50))
-            }
-
-            // The transport should have been created and connected
-            // (StreamableHTTPServerTransport mock handles the request)
-            expect(mockConnect).toHaveBeenCalled()
-        })
-
-        it('should handle stateful POST /mcp error with 500 response', async () => {
-            // Create a transport mock that throws
-            const StreamableTransportMod =
-                await import('@modelcontextprotocol/sdk/server/streamableHttp.js')
-            const OrigConstructor = StreamableTransportMod.StreamableHTTPServerTransport
-            const throwingConstructor = vi.fn().mockImplementation(() => {
-                return {
-                    handleRequest: vi.fn().mockRejectedValue(new Error('Transport failure')),
-                    close: vi.fn().mockResolvedValue(undefined),
-                    sessionId: 'fail-session',
-                }
-            })
-            ;(StreamableTransportMod as Record<string, unknown>)['StreamableHTTPServerTransport'] =
-                throwingConstructor
-
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: false,
-            })
-
-            const postHandler = mockHandlers.post['/mcp']
-            expect(postHandler).toBeDefined()
-
-            // Request with existing session ID that throws during handleRequest
-            const mockReq = {
-                headers: { 'mcp-session-id': 'fail-session' },
-                body: { jsonrpc: '2.0', id: 1, method: 'test' },
-            }
-            const mockRes = {
-                status: vi.fn().mockReturnThis(),
-                json: vi.fn(),
-                headersSent: false,
-            }
-
-            if (postHandler) {
-                await postHandler(mockReq, mockRes)
-                await new Promise((r) => setTimeout(r, 50))
-            }
-
-            // Restore original
-            ;(StreamableTransportMod as Record<string, unknown>)['StreamableHTTPServerTransport'] =
-                OrigConstructor
-        })
-    })
-
-    // ========================================================================
-    // Scheduler
-    // ========================================================================
-
-    describe('createServer - scheduler', () => {
-        it('should warn and not start scheduler on stdio transport', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-                scheduler: {
-                    backupIntervalMinutes: 60,
-                    vacuumIntervalMinutes: 120,
-                    rebuildIndexIntervalMinutes: 180,
-                },
-            })
-
-            // Scheduler should NOT be started for stdio
-            // (no way to directly check but the code path is covered)
-            expect(mockDbInitialize).toHaveBeenCalled()
-        })
-
-        it('should start scheduler on HTTP transport', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: true,
-                scheduler: {
-                    backupIntervalMinutes: 60,
-                    vacuumIntervalMinutes: 0,
-                    rebuildIndexIntervalMinutes: 0,
-                },
-            })
-
-            expect(mockDbInitialize).toHaveBeenCalled()
-        })
-
-        it('should not create scheduler when all intervals are 0', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                scheduler: {
-                    backupIntervalMinutes: 0,
-                    vacuumIntervalMinutes: 0,
-                    rebuildIndexIntervalMinutes: 0,
-                },
-            })
-
-            expect(mockDbInitialize).toHaveBeenCalled()
-        })
-    })
-
-    // ========================================================================
-    // Tool handler with outputSchema
-    // ========================================================================
-
-    describe('tool handler structuredContent', () => {
-        it('should return structuredContent for tools with outputSchema', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            // get_recent_entries has an outputSchema
-            const calls = mockRegisterTool.mock.calls.filter(
-                (call: unknown[]) => call[0] === 'get_recent_entries'
-            ) as unknown[][]
-
-            expect(calls.length).toBe(1)
-            const handler = calls[0]![2] as (
-                args: Record<string, unknown>,
-                extra: Record<string, unknown>
-            ) => Promise<{
-                content: { type: string; text: string }[]
-                structuredContent?: Record<string, unknown>
-            }>
-
-            const result = await handler({ limit: 5 }, { _meta: {} })
-
-            // Should have both content and structuredContent
-            expect(result.content).toBeDefined()
-            expect(result.structuredContent).toBeDefined()
-        })
-
-        it('should pass progressToken to tool handler when provided', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            const calls = mockRegisterTool.mock.calls.filter(
-                (call: unknown[]) => call[0] === 'create_entry'
-            ) as unknown[][]
-
-            const handler = calls[0]![2] as (
-                args: Record<string, unknown>,
-                extra: Record<string, unknown>
-            ) => Promise<unknown>
-
-            // Invoke with a progressToken in _meta
-            const result = await handler(
-                { content: 'Progress test' },
-                { _meta: { progressToken: 'tok-123' } }
-            )
-
-            expect(result).toBeDefined()
-        })
-    })
-
-    // ========================================================================
-    // Environment-based tool filter
-    // ========================================================================
-
-    describe('createServer - env tool filter', () => {
-        it('should use MEMORY_JOURNAL_MCP_TOOL_FILTER env var when no explicit filter', async () => {
-            process.env['MEMORY_JOURNAL_MCP_TOOL_FILTER'] = 'core'
-
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            // Tools should be filtered from env
-            expect(mockRegisterTool).toHaveBeenCalled()
-            const toolCount = mockRegisterTool.mock.calls.length
-
-            delete process.env['MEMORY_JOURNAL_MCP_TOOL_FILTER']
-
-            // Reset only the specific mock call counts we care about
-            mockRegisterTool.mockClear()
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            const unfilteredCount = mockRegisterTool.mock.calls.length
-            // Env-filtered should have fewer tools than unfiltered
-            expect(toolCount).toBeLessThan(unfilteredCount)
-        })
-    })
-
-    describe('Registered Handlers', () => {
-        beforeEach(() => {
-            vi.clearAllMocks()
-        })
-
-        it('should execute registered tools successfully', async () => {
-            await createServer({ dbPath: './test-server.db' })
-
-            // Verify tool registration occurred
-            const toolCall = mockRegisterTool.mock.calls.find(
-                (c: any[]) =>
-                    typeof c[0] === 'string' &&
-                    (c[0] === 'create_entry' || c[0] === 'mj_create_entry')
-            )
-            expect(toolCall).toBeDefined()
-
-            const handler = toolCall[2]
-
-            // Success path — callTool dispatches to the group handler which calls db.createEntry
-            mockCreateEntry.mockReturnValueOnce({ id: 99, content: 'passed' })
-            const successResult = await handler(
-                { content: 'test', entry_type: 'personal_reflection' },
-                {}
-            )
-            expect(successResult.isError).toBeUndefined()
-            expect(successResult.content).toBeDefined()
-        })
-
-        it('should execute registered resources successfully', async () => {
-            await createServer({ dbPath: './test-server.db' })
-
-            const resCall =
-                mockRegisterResource.mock.calls.find((c: any[]) => c[0].endsWith('recent')) ||
-                mockRegisterResource.mock.calls[0]
-            expect(resCall).toBeDefined()
-
-            const handler = resCall[2]
-
-            try {
-                // If it requires a URL
-                const url = new URL('memory://recent')
-                const resResult = await handler(url, 'text/plain')
-                expect(resResult.contents).toBeDefined()
-                expect(resResult.contents[0].uri).toBe('memory://recent')
-            } catch (error) {
-                // The DB logic might throw due to missing mocks for other files, but coverage will be hit
-                console.warn('Resource handler threw, but coverage achieved:', error)
-            }
-        })
-    })
-
-    // ========================================================================
-    // SIGINT shutdown handlers
-    // ========================================================================
-
-    describe('createServer - shutdown handlers', () => {
-        it('should register SIGINT handler for stdio transport', async () => {
-            await createServer({
-                transport: 'stdio',
-                dbPath: './test-server.db',
-            })
-
-            expect(mockSigintHandlers.length).toBe(1)
-        })
-
-        it('should register SIGINT handler for stateless HTTP', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: true,
-            })
-
-            expect(mockSigintHandlers.length).toBe(1)
-
-            // Exercise the SIGINT handler
-            const sigintHandler = mockSigintHandlers[0]
-            if (sigintHandler) {
-                sigintHandler()
-                // Wait for async void
-                await new Promise((r) => setTimeout(r, 50))
-            }
-
-            expect(mockDbClose).toHaveBeenCalled()
-        })
-
-        it('should register SIGINT handler for stateful HTTP', async () => {
-            await createServer({
-                transport: 'http',
-                dbPath: './test-server.db',
-                statelessHttp: false,
-            })
-
-            expect(mockSigintHandlers.length).toBe(1)
-
-            // Exercise the SIGINT handler
-            const sigintHandler = mockSigintHandlers[0]
-            if (sigintHandler) {
-                sigintHandler()
-                await new Promise((r) => setTimeout(r, 50))
-            }
-
-            expect(mockDbClose).toHaveBeenCalled()
-        })
-    })
-})