memory-journal-mcp 6.1.2 → 6.2.1

package/tests/e2e/rate-limiting.spec.ts

@@ -1,291 +0,0 @@
-/**
- * E2E Tests: Rate Limiting
- *
- * Tests the built-in rate limiter by launching a server with a very
- * low rate limit and verifying 429 behavior, Retry-After headers,
- * and health endpoint exemption.
- *
- * Uses a dedicated server on port 3103 with MCP_RATE_LIMIT_MAX=5.
- */
-
-import { test, expect } from '@playwright/test'
-import { startServer, stopServer } from './helpers.js'
-
-const RATE_PORT = 3103
-const RATE_BASE = `http://localhost:${RATE_PORT}`
-
-test.describe('Rate Limiting', () => {
-    test.beforeAll(async () => {
-        await startServer(RATE_PORT, [], 'rate-limit')
-    })
-
-    test.afterAll(() => {
-        stopServer(RATE_PORT)
-    })
-
-    test('should return 429 after exceeding rate limit', async () => {
-        // The server on this port uses the default env MCP_RATE_LIMIT_MAX=10000.
-        // We need to override it. Since startServer doesn't pass MCP_RATE_LIMIT_MAX
-        // for rate limit tests (checked in the helper), we use direct fetch with
-        // a tight burst.
-
-        // Actually, let's stop the default server and start one with low limit
-        stopServer(RATE_PORT)
-
-        // Start with explicit low rate limit via env override
-        const { spawn } = await import('node:child_process')
-        const { setTimeout: delay } = await import('node:timers/promises')
-
-        const serverProcess = spawn(
-            'node',
-            [
-                'dist/cli.js',
-                '--transport',
-                'http',
-                '--port',
-                String(RATE_PORT),
-                '--db',
-                './.test-output/e2e/test-e2e-rate-limit.db',
-            ],
-            {
-                cwd: process.cwd(),
-                stdio: 'pipe',
-                env: {
-                    ...process.env,
-                    MCP_RATE_LIMIT_MAX: '5',
-                },
-            }
-        )
-
-        // Wait for server to start
-        for (let i = 0; i < 30; i++) {
-            try {
-                const res = await fetch(`${RATE_BASE}/health`)
-                if (res.ok) break
-            } catch {
-                // Not ready
-            }
-            await delay(500)
-        }
-
-        try {
-            // Send 5 requests (within limit)
-            for (let i = 0; i < 5; i++) {
-                const res = await fetch(`${RATE_BASE}/mcp`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Accept: 'application/json, text/event-stream',
-                    },
-                    body: JSON.stringify({
-                        jsonrpc: '2.0',
-                        id: i + 1,
-                        method: 'initialize',
-                        params: {
-                            protocolVersion: '2025-03-26',
-                            capabilities: {},
-                            clientInfo: { name: 'rate-test', version: '1.0' },
-                        },
-                    }),
-                })
-                // These should succeed (200 or 400 for non-init, but not 429)
-                expect(res.status).not.toBe(429)
-            }
-
-            // 6th request should be rate-limited
-            const limitedResponse = await fetch(`${RATE_BASE}/mcp`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json, text/event-stream',
-                },
-                body: JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: 99,
-                    method: 'initialize',
-                    params: {
-                        protocolVersion: '2025-03-26',
-                        capabilities: {},
-                        clientInfo: { name: 'rate-test', version: '1.0' },
-                    },
-                }),
-            })
-
-            expect(limitedResponse.status).toBe(429)
-        } finally {
-            serverProcess.kill('SIGTERM')
-        }
-    })
-
-    test('should include Retry-After header on 429', async () => {
-        const { spawn } = await import('node:child_process')
-        const { setTimeout: delay } = await import('node:timers/promises')
-
-        const serverProcess = spawn(
-            'node',
-            [
-                'dist/cli.js',
-                '--transport',
-                'http',
-                '--port',
-                String(RATE_PORT),
-                '--db',
-                './.test-output/e2e/test-e2e-rate-retry.db',
-            ],
-            {
-                cwd: process.cwd(),
-                stdio: 'pipe',
-                env: {
-                    ...process.env,
-                    MCP_RATE_LIMIT_MAX: '3',
-                },
-            }
-        )
-
-        for (let i = 0; i < 30; i++) {
-            try {
-                const res = await fetch(`${RATE_BASE}/health`)
-                if (res.ok) break
-            } catch {
-                // Not ready
-            }
-            await delay(500)
-        }
-
-        try {
-            // Exhaust the limit
-            for (let i = 0; i < 3; i++) {
-                await fetch(`${RATE_BASE}/mcp`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Accept: 'application/json, text/event-stream',
-                    },
-                    body: JSON.stringify({
-                        jsonrpc: '2.0',
-                        id: i + 1,
-                        method: 'initialize',
-                        params: {
-                            protocolVersion: '2025-03-26',
-                            capabilities: {},
-                            clientInfo: { name: 'retry-test', version: '1.0' },
-                        },
-                    }),
-                })
-            }
-
-            // Next request should be 429 with Retry-After
-            const response = await fetch(`${RATE_BASE}/mcp`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json, text/event-stream',
-                },
-                body: JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: 99,
-                    method: 'initialize',
-                    params: {
-                        protocolVersion: '2025-03-26',
-                        capabilities: {},
-                        clientInfo: { name: 'retry-test', version: '1.0' },
-                    },
-                }),
-            })
-
-            expect(response.status).toBe(429)
-            const retryAfter = response.headers.get('retry-after')
-            expect(retryAfter).toBeDefined()
-            expect(Number(retryAfter)).toBeGreaterThan(0)
-        } finally {
-            serverProcess.kill('SIGTERM')
-        }
-    })
-
-    test('should exempt /health from rate limiting', async () => {
-        const { spawn } = await import('node:child_process')
-        const { setTimeout: delay } = await import('node:timers/promises')
-
-        const serverProcess = spawn(
-            'node',
-            [
-                'dist/cli.js',
-                '--transport',
-                'http',
-                '--port',
-                String(RATE_PORT),
-                '--db',
-                './.test-output/e2e/test-e2e-rate-health.db',
-            ],
-            {
-                cwd: process.cwd(),
-                stdio: 'pipe',
-                env: {
-                    ...process.env,
-                    MCP_RATE_LIMIT_MAX: '2',
-                },
-            }
-        )
-
-        for (let i = 0; i < 30; i++) {
-            try {
-                const res = await fetch(`${RATE_BASE}/health`)
-                if (res.ok) break
-            } catch {
-                // Not ready
-            }
-            await delay(500)
-        }
-
-        try {
-            // Exhaust rate limit
-            for (let i = 0; i < 2; i++) {
-                await fetch(`${RATE_BASE}/mcp`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Accept: 'application/json, text/event-stream',
-                    },
-                    body: JSON.stringify({
-                        jsonrpc: '2.0',
-                        id: i + 1,
-                        method: 'initialize',
-                        params: {
-                            protocolVersion: '2025-03-26',
-                            capabilities: {},
-                            clientInfo: { name: 'health-test', version: '1.0' },
-                        },
-                    }),
-                })
-            }
-
-            // /health should still work
-            const healthResponse = await fetch(`${RATE_BASE}/health`)
-            expect(healthResponse.status).toBe(200)
-            const body = await healthResponse.json()
-            expect(body).toHaveProperty('status', 'healthy')
-
-            // But /mcp should be 429
-            const mcpResponse = await fetch(`${RATE_BASE}/mcp`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json, text/event-stream',
-                },
-                body: JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: 99,
-                    method: 'initialize',
-                    params: {
-                        protocolVersion: '2025-03-26',
-                        capabilities: {},
-                        clientInfo: { name: 'health-test', version: '1.0' },
-                    },
-                }),
-            })
-            expect(mcpResponse.status).toBe(429)
-        } finally {
-            serverProcess.kill('SIGTERM')
-        }
-    })
-})

package/tests/e2e/resources-briefing-env.spec.ts

@@ -1,106 +0,0 @@
-/**
- * E2E Tests: Briefing Environment Variable Overrides
- *
- * Verifies that the memory://briefing template actually responds
- * to environment configurations like BRIEFING_ENTRY_COUNT,
- * BRIEFING_INCLUDE_TEAM, etc.
- */
-
-import { test, expect } from '@playwright/test'
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { Client as McpClient } from '@modelcontextprotocol/sdk/client/index.js'
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
-import { spawn, type ChildProcess } from 'node:child_process'
-import { setTimeout as delay } from 'node:timers/promises'
-
-const BRIEFING_PORT = 3112
-const BRIEFING_BASE = `http://localhost:${BRIEFING_PORT}`
-
-test.describe.configure({ mode: 'serial' })
-
-test.describe('Resources: Briefing Environment Configurations', () => {
-    let client: Client
-    let serverProcess: ChildProcess
-
-    test.beforeAll(async () => {
-        // Start server with specific config and team db
-        serverProcess = spawn(
-            'node',
-            [
-                'dist/cli.js',
-                '--transport',
-                'http',
-                '--port',
-                String(BRIEFING_PORT),
-                '--db',
-                './.test-output/e2e/test-briefing.db',
-            ],
-            {
-                cwd: process.cwd(),
-                stdio: 'pipe',
-                env: {
-                    ...process.env,
-                    MCP_RATE_LIMIT_MAX: '10000',
-                    BRIEFING_ENTRY_COUNT: '2', // Only 2 entries max
-                    BRIEFING_INCLUDE_TEAM: 'true', // Force inclusion
-                    BRIEFING_COPILOT_REVIEWS: 'true', // Adds copilot block
-                    TEAM_DB_PATH: './.test-output/e2e/test-briefing-team.db',
-                },
-            }
-        )
-
-        for (let i = 0; i < 30; i++) {
-            try {
-                const res = await fetch(`${BRIEFING_BASE}/health`)
-                if (res.ok) break
-            } catch {}
-            await delay(500)
-        }
-
-        const transport = new StreamableHTTPClientTransport(new URL(`${BRIEFING_BASE}/mcp`))
-        client = new McpClient({ name: 'briefing-test', version: '1.0' }, { capabilities: {} })
-        await client.connect(transport)
-    })
-
-    test.afterAll(async () => {
-        if (client) {
-            await client.close()
-        }
-        if (serverProcess) {
-            serverProcess.kill('SIGTERM')
-        }
-    })
-
-    test('memory://briefing dynamically generates based on ENV limits', async () => {
-        // Create 3 entries to exceed the limit of 2
-        for (let i = 1; i <= 3; i++) {
-            const resp = await client.callTool({
-                name: 'create_entry',
-                arguments: { content: `Briefing test code ${i}`, entry_type: 'test_entry' },
-            })
-            expect(resp.isError).toBeUndefined()
-        }
-
-        // Also create a team entry to test inclusion
-        const t_resp = await client.callTool({
-            name: 'team_create_entry',
-            arguments: { content: 'Team insight', entry_type: 'test_entry' },
-        })
-        expect(t_resp.isError).toBeUndefined()
-
-        const response = await client.readResource({ uri: 'memory://briefing' })
-
-        expect(response.contents).toBeDefined()
-        const contentText = response.contents[0]!.text as string
-
-        // The briefing resource yields JSON format
-        const briefingObj = JSON.parse(contentText)
-
-        // Assert entry limit of 2 is respected
-        expect(briefingObj.journal.latestEntries.length).toBe(2)
-        // Assert team block is populated
-        expect(briefingObj.teamContext).toBeDefined()
-        expect(briefingObj.teamLatestEntries.length).toBeGreaterThan(0)
-        expect(briefingObj.teamLatestEntries[0].preview).toContain('insight')
-    })
-})

package/tests/e2e/resources-complete.spec.ts

@@ -1,180 +0,0 @@
-/**
- * E2E Tests: Complete Resource Coverage
- *
- * Tests 13 resources not covered by resources.spec.ts or resources-expanded.spec.ts:
- * help (index + per-group + gotchas), rules, workflows, skills,
- * github (status, insights, milestones), graph/actions, actions/recent,
- * and team (recent, statistics).
- */
-
-import { test, expect } from '@playwright/test'
-import { createClient } from './helpers.js'
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
-
-test.describe.configure({ mode: 'serial' })
-
-test.describe('E2E Resource Reads: Complete Coverage', () => {
-    let client: Client
-
-    test.beforeAll(async () => {
-        client = await createClient()
-    })
-
-    test.afterAll(async () => {
-        await client.close()
-    })
-
-    // --- Help resources ---
-    test('should read memory://help (tool group index)', async () => {
-        const response = await client.readResource({ uri: 'memory://help' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        const parsed = JSON.parse(text)
-        expect(parsed).toHaveProperty('groups')
-        expect(Array.isArray(parsed.groups)).toBe(true)
-        expect(parsed.groups.length).toBeGreaterThanOrEqual(10)
-    })
-
-    test('should read memory://help/core (per-group tool details)', async () => {
-        const response = await client.readResource({ uri: 'memory://help/core' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        const parsed = JSON.parse(text)
-        expect(parsed).toHaveProperty('group', 'core')
-        expect(parsed).toHaveProperty('tools')
-        expect(Array.isArray(parsed.tools)).toBe(true)
-        expect(parsed.tools.length).toBeGreaterThanOrEqual(5)
-    })
-
-    test('should read memory://help/gotchas (field notes)', async () => {
-        const response = await client.readResource({ uri: 'memory://help/gotchas' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        // Gotchas content should be a non-trivial text block
-        expect(text.length).toBeGreaterThan(50)
-    })
-
-    // --- Configuration-dependent resources (unconfigured in test env) ---
-    test('should read memory://rules (unconfigured)', async () => {
-        const response = await client.readResource({ uri: 'memory://rules' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        const parsed = JSON.parse(text)
-        expect(parsed).toHaveProperty('configured', false)
-    })
-
-    test('should read memory://workflows (unconfigured)', async () => {
-        const response = await client.readResource({ uri: 'memory://workflows' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        const parsed = JSON.parse(text)
-        expect(parsed).toHaveProperty('configured', false)
-    })
-
-    test('should read memory://skills (unconfigured)', async () => {
-        const response = await client.readResource({ uri: 'memory://skills' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        const parsed = JSON.parse(text)
-        // Without SKILLS_DIR_PATH, should return { configured: false } or empty skills
-        expect(typeof parsed).toBe('object')
-    })
-
-    // --- GitHub resources (no token in test env) ---
-    test('should read memory://github/status', async () => {
-        const response = await client.readResource({ uri: 'memory://github/status' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        // May return error or partial data without token — either is valid
-        expect(typeof text).toBe('string')
-        expect(text.length).toBeGreaterThan(0)
-    })
-
-    test('should read memory://github/insights', async () => {
-        const response = await client.readResource({ uri: 'memory://github/insights' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        expect(typeof text).toBe('string')
-        expect(text.length).toBeGreaterThan(0)
-    })
-
-    test('should read memory://github/milestones', async () => {
-        const response = await client.readResource({ uri: 'memory://github/milestones' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        expect(typeof text).toBe('string')
-        expect(text.length).toBeGreaterThan(0)
-    })
-
-    // --- Graph resources ---
-    test('should read memory://graph/actions', async () => {
-        const response = await client.readResource({ uri: 'memory://graph/actions' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        expect(typeof text).toBe('string')
-    })
-
-    test('should read memory://actions/recent', async () => {
-        const response = await client.readResource({ uri: 'memory://actions/recent' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        expect(typeof text).toBe('string')
-    })
-
-    // --- Team resources (no TEAM_DB_PATH in test env) ---
-    test('should read memory://team/recent', async () => {
-        const response = await client.readResource({ uri: 'memory://team/recent' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        const parsed = JSON.parse(text)
-        // Without team DB, should return a not-configured indicator
-        expect(typeof parsed).toBe('object')
-    })
-
-    test('should read memory://team/statistics', async () => {
-        const response = await client.readResource({ uri: 'memory://team/statistics' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        const parsed = JSON.parse(text)
-        expect(typeof parsed).toBe('object')
-    })
-})

package/tests/e2e/resources-expanded.spec.ts

@@ -1,83 +0,0 @@
-/**
- * E2E Tests: Expanded Resource Reads via SDK Client
- *
- * Covers resources not tested by resources.spec.ts:
- * memory://instructions, memory://significant, memory://graph/recent,
- * memory://tags, and unknown resource URI error handling.
- */
-
-import { test, expect } from '@playwright/test'
-import { createClient } from './helpers.js'
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
-
-test.describe.configure({ mode: 'serial' })
-
-test.describe('E2E Resource Reads: Expanded', () => {
-    let client: Client
-
-    test.beforeAll(async () => {
-        client = await createClient()
-    })
-
-    test.afterAll(async () => {
-        await client.close()
-    })
-
-    test('should read memory://instructions resource', async () => {
-        const response = await client.readResource({ uri: 'memory://instructions' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        // Instructions should be a substantial text block
-        expect(text.length).toBeGreaterThan(100)
-        // Should mention memory journal or MCP
-        expect(text.toLowerCase()).toMatch(/memory|journal|mcp/)
-    })
-
-    test('should read memory://significant resource', async () => {
-        const response = await client.readResource({ uri: 'memory://significant' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        const parsed = JSON.parse(text)
-        // Should return a valid structure (may be empty if no significant entries)
-        expect(typeof parsed).toBe('object')
-    })
-
-    test('should read memory://graph/recent resource', async () => {
-        const response = await client.readResource({ uri: 'memory://graph/recent' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        // Should be a Mermaid diagram or empty structure
-        expect(typeof text).toBe('string')
-    })
-
-    test('should read memory://tags resource', async () => {
-        const response = await client.readResource({ uri: 'memory://tags' })
-
-        expect(response.contents).toBeDefined()
-        expect(response.contents.length).toBeGreaterThan(0)
-
-        const text = response.contents[0]!.text as string
-        const parsed = JSON.parse(text)
-        expect(parsed).toHaveProperty('tags')
-        expect(Array.isArray(parsed.tags)).toBe(true)
-    })
-
-    test('should handle unknown resource URI gracefully', async () => {
-        try {
-            await client.readResource({ uri: 'memory://nonexistent-resource-uri' })
-            // If it doesn't throw, it should still return a valid structure
-        } catch (error) {
-            // Expected: MCP SDK throws for unknown resources
-            expect(error).toBeDefined()
-        }
-    })
-})