memory-journal-mcp 6.1.2 → 6.2.1

package/tests/e2e/session-advanced.spec.ts

@@ -1,152 +0,0 @@
-/**
- * E2E Tests: Advanced Session Management
- *
- * Tests cross-protocol guard, concurrent sessions, post-DELETE
- * session rejection, and invalid session ID handling.
- */
-
-import { test, expect } from '@playwright/test'
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'
-
-test.describe('Advanced Session Management', () => {
-    test('should reject SSE session ID on /mcp (cross-protocol guard)', async () => {
-        // Connect via Legacy SSE to get an SSE session ID
-        const sseTransport = new SSEClientTransport(new URL('http://localhost:3100/sse'))
-        const sseClient = new Client(
-            { name: 'cross-protocol-test', version: '1.0.0' },
-            { capabilities: {} }
-        )
-
-        try {
-            await sseClient.connect(sseTransport)
-
-            // The SSE transport manages a session internally. We need to find the session ID.
-            // Since SSE sessions are managed server-side and don't expose the ID via headers,
-            // we can extract it from the endpoint URL parameter.
-            // For this test, we'll verify the server rejects mismatched protocol usage
-            // by trying to POST to /mcp with a session ID that doesn't exist in the
-            // Streamable HTTP transport map.
-
-            const response = await fetch('http://localhost:3100/mcp', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json, text/event-stream',
-                    'mcp-session-id': 'fake-sse-session-id',
-                },
-                body: JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: 1,
-                    method: 'ping',
-                }),
-            })
-
-            // Should be rejected — either because the session ID is unknown (400)
-            expect(response.status).toBe(400)
-        } finally {
-            await sseClient.close()
-        }
-    })
-
-    test('should support sequential session isolation', async () => {
-        // The MCP SDK server only supports one active server.connect() at a time.
-        // Verify that sequential sessions each get fresh state and distinct IDs.
-        const sessionIds: string[] = []
-
-        for (let i = 0; i < 3; i++) {
-            const transport = new StreamableHTTPClientTransport(
-                new URL('http://localhost:3100/mcp')
-            )
-            const client = new Client(
-                { name: `sequential-test-${i}`, version: '1.0.0' },
-                { capabilities: {} }
-            )
-
-            try {
-                await client.connect(transport)
-
-                const result = await client.callTool({
-                    name: 'test_simple',
-                    arguments: { message: `session-${i}` },
-                })
-
-                expect(result.isError).toBeUndefined()
-                expect(Array.isArray(result.content)).toBe(true)
-                const text = (result.content[0] as { type: string; text: string }).text
-                expect(text).toContain(`session-${i}`)
-
-                // Capture session ID from a raw init to verify uniqueness
-                sessionIds.push(String(i))
-            } finally {
-                await client.close()
-            }
-        }
-
-        // All 3 rounds completed successfully — sessions are isolated
-        expect(sessionIds).toHaveLength(3)
-    })
-
-    test('should reject request with non-existent session ID', async () => {
-        const response = await fetch('http://localhost:3100/mcp', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json, text/event-stream',
-                'mcp-session-id': '00000000-0000-4000-8000-000000000000',
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'tools/list',
-            }),
-        })
-
-        expect(response.status).toBe(400)
-        const body = await response.json()
-        expect(body.error).toHaveProperty('message', 'Bad Request: No valid session ID provided')
-    })
-
-    test('should reject requests after session DELETE', async ({ request }) => {
-        // Initialize a session
-        const initResponse = await request.post('/mcp', {
-            headers: { Accept: 'application/json, text/event-stream' },
-            data: {
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'initialize',
-                params: {
-                    protocolVersion: '2025-03-26',
-                    capabilities: {},
-                    clientInfo: { name: 'delete-reuse-test', version: '1.0.0' },
-                },
-            },
-        })
-
-        expect(initResponse.status()).toBe(200)
-        const sessionId = initResponse.headers()['mcp-session-id']
-        expect(sessionId).toBeDefined()
-
-        // Delete the session
-        const deleteResponse = await request.delete('/mcp', {
-            headers: { 'mcp-session-id': sessionId! },
-        })
-        expect([200, 204]).toContain(deleteResponse.status())
-
-        // Try to use the deleted session — should be rejected
-        const postDeleteResponse = await request.post('/mcp', {
-            headers: {
-                Accept: 'application/json, text/event-stream',
-                'mcp-session-id': sessionId!,
-            },
-            data: {
-                jsonrpc: '2.0',
-                id: 2,
-                method: 'tools/list',
-            },
-        })
-
-        expect(postDeleteResponse.status()).toBe(400)
-    })
-})

package/tests/e2e/sessions.spec.ts

@@ -1,95 +0,0 @@
-/**
- * E2E Tests: Session Lifecycle
- *
- * Tests the full Streamable HTTP session lifecycle: initialization,
- * tool calls with session ID, session termination (DELETE /mcp),
- * and rejection of stale/invalid sessions.
- */
-
-import { test, expect } from '@playwright/test'
-
-test.describe.configure({ mode: 'serial' })
-
-test.describe('Session Lifecycle', () => {
-    let sessionId: string
-
-    test('should initialize a session and return session ID', async ({ request }) => {
-        const response = await request.post('/mcp', {
-            headers: {
-                Accept: 'application/json, text/event-stream',
-            },
-            data: {
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'initialize',
-                params: {
-                    protocolVersion: '2025-03-26',
-                    capabilities: {},
-                    clientInfo: {
-                        name: 'playwright-session-test',
-                        version: '1.0.0',
-                    },
-                },
-            },
-        })
-
-        expect(response.status()).toBe(200)
-        sessionId = response.headers()['mcp-session-id']!
-        expect(sessionId).toBeDefined()
-        expect(sessionId.length).toBeGreaterThan(0)
-    })
-
-    test('should accept requests with valid session ID', async ({ request }) => {
-        // Send initialized notification (required by MCP protocol after init)
-        const response = await request.post('/mcp', {
-            headers: {
-                Accept: 'application/json, text/event-stream',
-                'mcp-session-id': sessionId,
-            },
-            data: {
-                jsonrpc: '2.0',
-                method: 'notifications/initialized',
-            },
-        })
-
-        // Notifications return 202 (accepted, no response body) or 200
-        expect([200, 202, 204]).toContain(response.status())
-    })
-
-    test('should allow tool calls with valid session ID', async ({ request }) => {
-        const response = await request.post('/mcp', {
-            headers: {
-                Accept: 'application/json, text/event-stream',
-                'mcp-session-id': sessionId,
-            },
-            data: {
-                jsonrpc: '2.0',
-                id: 2,
-                method: 'tools/list',
-            },
-        })
-
-        expect(response.status()).toBe(200)
-    })
-
-    test('GET /mcp (SSE) should reject without session ID', async ({ request }) => {
-        const response = await request.get('/mcp')
-        expect(response.status()).toBe(400)
-    })
-
-    test('DELETE /mcp should reject without session ID', async ({ request }) => {
-        const response = await request.delete('/mcp')
-        expect(response.status()).toBe(400)
-    })
-
-    test('DELETE /mcp should terminate a valid session', async ({ request }) => {
-        const response = await request.delete('/mcp', {
-            headers: {
-                'mcp-session-id': sessionId,
-            },
-        })
-
-        // DELETE returns 200 or 204
-        expect([200, 204]).toContain(response.status())
-    })
-})

package/tests/e2e/stateless.spec.ts

@@ -1,79 +0,0 @@
-/**
- * E2E Tests: Stateless HTTP Mode
- *
- * Tests the --stateless mode behavior. Uses a test-local server
- * on port 3102 to avoid conflicting with the main webServer.
- */
-
-import { test, expect } from '@playwright/test'
-import { startServer, stopServer } from './helpers.js'
-
-const STATELESS_PORT = 3102
-const STATELESS_BASE = `http://localhost:${STATELESS_PORT}`
-
-test.describe('Stateless HTTP Mode', () => {
-    test.beforeAll(async () => {
-        await startServer(STATELESS_PORT, ['--stateless'], 'stateless')
-    })
-
-    test.afterAll(() => {
-        stopServer(STATELESS_PORT)
-    })
-
-    test('POST /mcp should accept requests without session ID (stateless)', async () => {
-        const response = await fetch(`${STATELESS_BASE}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json, text/event-stream',
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'initialize',
-                params: {
-                    protocolVersion: '2025-03-26',
-                    capabilities: {},
-                    clientInfo: { name: 'stateless-test', version: '1.0' },
-                },
-            }),
-        })
-
-        expect(response.status).toBe(200)
-    })
-
-    test('GET /mcp should return 405 (SSE not available in stateless)', async () => {
-        const response = await fetch(`${STATELESS_BASE}/mcp`)
-
-        expect(response.status).toBe(405)
-        const body = await response.json()
-        expect(body.error).toHaveProperty(
-            'message',
-            'SSE streaming not available in stateless mode'
-        )
-    })
-
-    test('DELETE /mcp should return 204 (no-op in stateless)', async () => {
-        const response = await fetch(`${STATELESS_BASE}/mcp`, {
-            method: 'DELETE',
-        })
-
-        expect(response.status).toBe(204)
-    })
-
-    test('GET /sse should return 404 (legacy SSE not available in stateless)', async () => {
-        const response = await fetch(`${STATELESS_BASE}/sse`)
-
-        expect(response.status).toBe(404)
-        const body = await response.json()
-        expect(body).toHaveProperty('error', 'Not found')
-    })
-
-    test('/health should still work in stateless mode', async () => {
-        const response = await fetch(`${STATELESS_BASE}/health`)
-        expect(response.status).toBe(200)
-
-        const body = await response.json()
-        expect(body).toHaveProperty('status', 'healthy')
-    })
-})

package/tests/e2e/streaming.spec.ts

@@ -1,176 +0,0 @@
-/**
- * E2E Tests: HTTP/SSE Streaming
- *
- * Validates raw SSE event stream behavior for both Streamable HTTP
- * (GET /mcp) and Legacy SSE (GET /sse) transports.
- *
- * Uses a dedicated server on port 3107 to avoid disrupting SDK-based
- * tests on the shared port 3100 (raw SSE connections interfere with
- * McpServer.connect() single-transport state).
- */
-
-import { test, expect } from '@playwright/test'
-import { startServer, stopServer } from './helpers.js'
-
-const STREAM_PORT = 3107
-const STREAM_BASE = `http://localhost:${STREAM_PORT}`
-
-test.describe('HTTP/SSE Streaming', () => {
-    test.beforeAll(async () => {
-        await startServer(STREAM_PORT, [], 'streaming')
-    })
-
-    test.afterAll(() => {
-        stopServer(STREAM_PORT)
-    })
-
-    test.describe('Streamable HTTP (GET /mcp)', () => {
-        test('should require session ID for GET /mcp SSE stream', async () => {
-            const response = await fetch(`${STREAM_BASE}/mcp`)
-            expect(response.status).toBe(400)
-        })
-
-        test('should accept GET /mcp with valid session ID', async () => {
-            // First, initialize a session
-            const initResponse = await fetch(`${STREAM_BASE}/mcp`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json, text/event-stream',
-                },
-                body: JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: 1,
-                    method: 'initialize',
-                    params: {
-                        protocolVersion: '2025-03-26',
-                        capabilities: {},
-                        clientInfo: { name: 'streaming-test', version: '1.0.0' },
-                    },
-                }),
-            })
-
-            expect(initResponse.status).toBe(200)
-            const sessionId = initResponse.headers.get('mcp-session-id')
-            expect(sessionId).toBeDefined()
-
-            // Open SSE stream with session ID — use raw fetch with AbortController
-            const controller = new AbortController()
-            const timeout = setTimeout(() => controller.abort(), 3000)
-
-            try {
-                const sseResponse = await fetch(`${STREAM_BASE}/mcp`, {
-                    headers: {
-                        'mcp-session-id': sessionId!,
-                        Accept: 'text/event-stream',
-                    },
-                    signal: controller.signal,
-                })
-
-                // Server should accept the SSE connection
-                expect(sseResponse.status).toBe(200)
-                expect(sseResponse.headers.get('content-type')).toContain('text/event-stream')
-            } catch (error) {
-                // AbortError is expected when we timeout the long-lived SSE stream
-                if (error instanceof Error && error.name !== 'AbortError') {
-                    throw error
-                }
-            } finally {
-                clearTimeout(timeout)
-            }
-        })
-
-        test('should accept Last-Event-ID header for reconnection', async () => {
-            // Initialize session
-            const initResponse = await fetch(`${STREAM_BASE}/mcp`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json, text/event-stream',
-                },
-                body: JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: 1,
-                    method: 'initialize',
-                    params: {
-                        protocolVersion: '2025-03-26',
-                        capabilities: {},
-                        clientInfo: { name: 'reconnect-test', version: '1.0.0' },
-                    },
-                }),
-            })
-
-            const sessionId = initResponse.headers.get('mcp-session-id')
-            expect(sessionId).toBeDefined()
-
-            // Reconnect with Last-Event-ID — server should accept (not error)
-            const controller = new AbortController()
-            const timeout = setTimeout(() => controller.abort(), 2000)
-
-            try {
-                const sseResponse = await fetch(`${STREAM_BASE}/mcp`, {
-                    headers: {
-                        'mcp-session-id': sessionId!,
-                        'Last-Event-ID': 'test-event-id-123',
-                        Accept: 'text/event-stream',
-                    },
-                    signal: controller.signal,
-                })
-
-                // Should still return 200 with event-stream
-                expect(sseResponse.status).toBe(200)
-            } catch (error) {
-                if (error instanceof Error && error.name !== 'AbortError') {
-                    throw error
-                }
-            } finally {
-                clearTimeout(timeout)
-            }
-        })
-    })
-
-    test.describe('Legacy SSE (GET /sse)', () => {
-        test('should return text/event-stream from /sse endpoint', async () => {
-            const controller = new AbortController()
-            const timeout = setTimeout(() => controller.abort(), 3000)
-
-            try {
-                const response = await fetch(`${STREAM_BASE}/sse`, {
-                    headers: { Accept: 'text/event-stream' },
-                    signal: controller.signal,
-                })
-
-                expect(response.status).toBe(200)
-                expect(response.headers.get('content-type')).toContain('text/event-stream')
-
-                // Read the first chunk of SSE data — should contain the endpoint event
-                const reader = response.body!.getReader()
-                const decoder = new TextDecoder()
-
-                const { value } = await reader.read()
-                const text = decoder.decode(value)
-
-                // Legacy SSE sends an 'endpoint' event with the message URL
-                expect(text).toContain('event: endpoint')
-                expect(text).toContain('/messages?sessionId=')
-
-                reader.releaseLock()
-            } catch (error) {
-                if (error instanceof Error && error.name !== 'AbortError') {
-                    throw error
-                }
-            } finally {
-                clearTimeout(timeout)
-            }
-        })
-
-        // Note: Full SSE SDK round-trip test is in protocols.spec.ts (legacy SSE section).
-        // Duplicating it here consistently times out due to the single-transport
-        // limitation in McpServer.connect(). The raw stream test above validates
-        // SSE format and endpoint event delivery.
-    })
-
-    // Note: Streamable HTTP SDK round-trip tests live in tools.spec.ts and
-    // resources.spec.ts. Duplicating them here causes timeouts due to the
-    // single-transport limitation in McpServer.connect().
-})

package/tests/e2e/tool-filtering-presets.spec.ts

@@ -1,192 +0,0 @@
-/**
- * E2E Tests: Tool Filter Presets — essential, codemode-only, -github
- *
- * Validates tool filter presets not covered by tool-filtering.spec.ts:
- * - `essential`: includes core + codemode, excludes github and team
- * - `codemode`: exactly 1 tool (mj_execute_code), which is callable
- * - `-github`: all 61 tools minus 16 github = 45 tools
- *
- * Also verifies the fix: essential and starter now auto-include codemode.
- *
- * Uses dedicated server ports 3105, 3106, 3107.
- */
-
-import { test, expect } from '@playwright/test'
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
-import { startServer, stopServer } from './helpers.js'
-
-const ESSENTIAL_PORT = 3105
-const CODEMODE_PORT = 3106
-const MINUS_GITHUB_PORT = 3107
-
-// ============================================================================
-// essential preset: core + codemode (no github, no team, no search)
-// ============================================================================
-
-test.describe('Tool Filter: essential preset', () => {
-    let client: Client
-
-    test.beforeAll(async () => {
-        await startServer(ESSENTIAL_PORT, ['--tool-filter', 'essential'], 'filter-essential')
-
-        const transport = new StreamableHTTPClientTransport(
-            new URL(`http://localhost:${ESSENTIAL_PORT}/mcp`)
-        )
-        client = new Client(
-            { name: 'filter-essential-test', version: '1.0.0' },
-            { capabilities: {} }
-        )
-        await client.connect(transport)
-    })
-
-    test.afterAll(async () => {
-        await client.close()
-        stopServer(ESSENTIAL_PORT)
-    })
-
-    test('essential: exposes fewer than 20 tools', async () => {
-        const response = await client.listTools()
-        expect(response.tools.length).toBeLessThan(20)
-        expect(response.tools.length).toBeGreaterThanOrEqual(2) // at least core + codemode
-    })
-
-    test('essential: includes create_entry (core group)', async () => {
-        const response = await client.listTools()
-        const names = response.tools.map((t) => t.name)
-        expect(names).toContain('create_entry')
-        expect(names).toContain('get_recent_entries')
-    })
-
-    test('essential: includes mj_execute_code (codemode auto-injected)', async () => {
-        // The fix: essential now auto-includes codemode
-        const response = await client.listTools()
-        const names = response.tools.map((t) => t.name)
-        expect(names).toContain('mj_execute_code')
-    })
-
-    test('essential: excludes github tools', async () => {
-        const response = await client.listTools()
-        const names = response.tools.map((t) => t.name)
-        expect(names).not.toContain('get_github_issues')
-        expect(names).not.toContain('get_github_prs')
-    })
-
-    test('essential: excludes team tools', async () => {
-        const response = await client.listTools()
-        const names = response.tools.map((t) => t.name)
-        expect(names).not.toContain('team_create_entry')
-        expect(names).not.toContain('team_get_recent')
-    })
-})
-
-// ============================================================================
-// codemode-only preset: exactly 1 tool, and it works
-// ============================================================================
-
-test.describe('Tool Filter: codemode-only preset', () => {
-    let client: Client
-
-    test.beforeAll(async () => {
-        await startServer(CODEMODE_PORT, ['--tool-filter', 'codemode'], 'filter-codemode')
-
-        const transport = new StreamableHTTPClientTransport(
-            new URL(`http://localhost:${CODEMODE_PORT}/mcp`)
-        )
-        client = new Client(
-            { name: 'filter-codemode-test', version: '1.0.0' },
-            { capabilities: {} }
-        )
-        await client.connect(transport)
-    })
-
-    test.afterAll(async () => {
-        await client.close()
-        stopServer(CODEMODE_PORT)
-    })
-
-    test('codemode: exposes exactly 1 tool', async () => {
-        const response = await client.listTools()
-        expect(response.tools.length).toBe(1)
-        expect(response.tools[0]!.name).toBe('mj_execute_code')
-    })
-
-    test('codemode: mj_execute_code is callable and executes code', async () => {
-        const response = await client.callTool({
-            name: 'mj_execute_code',
-            arguments: {
-                code: `
-                    const result = await mj.core.testSimple({ message: 'codemode-only-e2e' });
-                    return result;
-                `,
-            },
-        })
-
-        expect(Array.isArray(response.content)).toBe(true)
-        const text = (response.content[0] as { type: string; text: string }).text
-        const payload = JSON.parse(text) as Record<string, unknown>
-        // Should succeed — test_simple echoes the message
-        expect(JSON.stringify(payload)).toContain('codemode-only-e2e')
-    })
-
-    test('codemode: does not expose any direct tool names (no create_entry etc.)', async () => {
-        const response = await client.listTools()
-        const names = response.tools.map((t) => t.name)
-        expect(names).not.toContain('create_entry')
-        expect(names).not.toContain('search_entries')
-        expect(names).not.toContain('get_github_issues')
-    })
-})
-
-// ============================================================================
-// -github subtractive filter: all 61 tools minus 16 github = 45 tools
-// ============================================================================
-
-test.describe('Tool Filter: -github subtractive filter', () => {
-    let client: Client
-
-    test.beforeAll(async () => {
-        await startServer(MINUS_GITHUB_PORT, ['--tool-filter', '-github'], 'filter-minus-github')
-
-        const transport = new StreamableHTTPClientTransport(
-            new URL(`http://localhost:${MINUS_GITHUB_PORT}/mcp`)
-        )
-        client = new Client(
-            { name: 'filter-minus-github-test', version: '1.0.0' },
-            { capabilities: {} }
-        )
-        await client.connect(transport)
-    })
-
-    test.afterAll(async () => {
-        await client.close()
-        stopServer(MINUS_GITHUB_PORT)
-    })
-
-    test('-github: exposes 45 tools (61 minus 16 github)', async () => {
-        const response = await client.listTools()
-        // 61 total - 16 github = 45
-        expect(response.tools.length).toBe(45)
-    })
-
-    test('-github: no github tools are present', async () => {
-        const response = await client.listTools()
-        const names = response.tools.map((t) => t.name)
-        expect(names).not.toContain('get_github_issues')
-        expect(names).not.toContain('get_github_prs')
-        expect(names).not.toContain('get_kanban_board')
-        expect(names).not.toContain('get_github_milestones')
-        expect(names).not.toContain('get_copilot_reviews')
-        expect(names).not.toContain('get_repo_insights')
-    })
-
-    test('-github: core, admin, team, and codemode tools remain', async () => {
-        const response = await client.listTools()
-        const names = response.tools.map((t) => t.name)
-        expect(names).toContain('create_entry')
-        expect(names).toContain('search_entries')
-        expect(names).toContain('delete_entry')
-        expect(names).toContain('mj_execute_code')
-        expect(names).toContain('team_create_entry')
-    })
-})