memory-journal-mcp 4.4.2 → 5.0.0

package/tests/constants/server-instructions.test.ts

@@ -99,6 +99,32 @@ describe('generateInstructions', () => {
             )
             expect(result).not.toContain('## GitHub Integration')
         })
+
+        it('should include Session End section', () => {
+            const result = generateInstructions(
+                TEST_TOOLS,
+                TEST_RESOURCES,
+                TEST_PROMPTS,
+                undefined,
+                'essential'
+            )
+            expect(result).toContain('Session End')
+            expect(result).toContain('session-summary')
+            expect(result).toContain('retrospective')
+            expect(result).toContain('opt-out')
+        })
+
+        it('should include Rule & Skill Suggestions section', () => {
+            const result = generateInstructions(
+                TEST_TOOLS,
+                TEST_RESOURCES,
+                TEST_PROMPTS,
+                undefined,
+                'essential'
+            )
+            expect(result).toContain('Rule & Skill Suggestions')
+            expect(result).toContain('always ask the user first')
+        })
     })
 
     describe('standard level', () => {
@@ -466,7 +492,7 @@ describe('generateInstructions', () => {
             'memory://graph/recent',
             'memory://graph/actions',
             'memory://actions/recent',
-            'memory://team/recent',
+
             'memory://github/status',
             'memory://github/milestones',
             'memory://github/insights',
@@ -482,9 +508,9 @@ describe('generateInstructions', () => {
     })
 
     describe('tool count consistency', () => {
-        it('should have 39 tools across all groups', () => {
+        it('should have 42 tools across all groups', () => {
             const allToolNames = getAllToolNames()
-            expect(allToolNames.length).toBe(39)
+            expect(allToolNames.length).toBe(42)
         })
 
         it('should show correct active tool count for all tools', () => {
@@ -492,7 +518,7 @@ describe('generateInstructions', () => {
             expect(result).toContain(`Active Tools (${String(ALL_TOOLS.size)})`)
         })
 
-        it('should list all 8 tool groups in active tools', () => {
+        it('should list all 9 tool groups in active tools', () => {
             const result = fullInstructions()
             const groups = Object.keys(TOOL_GROUPS)
             for (const group of groups) {

package/tests/database/sqlite-adapter.test.ts

@@ -64,7 +64,7 @@ describe('SqliteAdapter', () => {
         it('should create an entry with all fields', () => {
             const entry = db.createEntry({
                 content: 'Full entry',
-                entryType: 'decision',
+                entryType: 'project_decision',
                 tags: ['tag-a', 'tag-b'],
                 isPersonal: false,
                 significanceType: 'milestone',
@@ -73,7 +73,7 @@ describe('SqliteAdapter', () => {
                 issueNumber: 7,
             })
 
-            expect(entry.entryType).toBe('decision')
+            expect(entry.entryType).toBe('project_decision')
             expect(entry.isPersonal).toBe(false)
             expect(entry.tags).toContain('tag-a')
             expect(entry.tags).toContain('tag-b')
@@ -187,13 +187,13 @@ describe('SqliteAdapter', () => {
 
         it('should filter by isPersonal', () => {
             db.createEntry({ content: 'Personal entry', isPersonal: true })
-            db.createEntry({ content: 'Team entry', isPersonal: false })
+            db.createEntry({ content: 'Non-personal entry', isPersonal: false })
 
             const personal = db.getRecentEntries(100, true)
-            const team = db.getRecentEntries(100, false)
+            const nonPersonal = db.getRecentEntries(100, false)
 
             expect(personal.every((e) => e.isPersonal)).toBe(true)
-            expect(team.every((e) => !e.isPersonal)).toBe(true)
+            expect(nonPersonal.every((e) => !e.isPersonal)).toBe(true)
         })
     })
 
@@ -471,6 +471,65 @@ describe('SqliteAdapter', () => {
                 fs.unlinkSync(backup.path)
             }
         })
+
+        it('should delete old backups keeping only keepCount', () => {
+            const fs = require('node:fs')
+
+            // Clean up any pre-existing backups from other tests
+            const preExisting = db.listBackups()
+            for (const backup of preExisting) {
+                if (fs.existsSync(backup.path)) fs.unlinkSync(backup.path)
+            }
+
+            // Create 3 backups
+            const b1 = db.exportToFile('cleanup-1')
+            const b2 = db.exportToFile('cleanup-2')
+            const b3 = db.exportToFile('cleanup-3')
+
+            // Keep only 1 newest
+            db.deleteOldBackups(1)
+
+            const remaining = db.listBackups()
+            // Should have exactly 1 backup remaining (newest)
+            expect(remaining.length).toBe(1)
+
+            // Cleanup any remaining
+            for (const path of [b1.path, b2.path, b3.path]) {
+                if (fs.existsSync(path)) fs.unlinkSync(path)
+            }
+        })
+
+        it('should restore from a backup file', async () => {
+            const fs = require('node:fs')
+            // Create an entry and backup
+            db.createEntry({ content: 'Before restore test' })
+            const countBefore = db.getActiveEntryCount()
+            const backup = db.exportToFile('restore-test')
+
+            // Create more entries after backup
+            db.createEntry({ content: 'After backup 1' })
+            db.createEntry({ content: 'After backup 2' })
+            const countAfterAdding = db.getActiveEntryCount()
+            expect(countAfterAdding).toBeGreaterThan(countBefore)
+
+            // Restore should revert to backup state
+            const result = await db.restoreFromFile(backup.filename)
+            expect(result.previousEntryCount).toBe(countAfterAdding)
+            expect(result.newEntryCount).toBe(countBefore)
+
+            // Cleanup
+            const backups = db.listBackups()
+            for (const b of backups) {
+                const path = require('node:path').join('backups', b.filename)
+                if (fs.existsSync(path)) fs.unlinkSync(path)
+            }
+        })
+
+        it('should get raw database handle', () => {
+            const rawDb = db.getRawDb()
+            expect(rawDb).toBeDefined()
+            expect(typeof rawDb.exec).toBe('function')
+        })
     })
 
     // ========================================================================
@@ -536,10 +595,10 @@ describe('SqliteAdapter', () => {
         it('should filter by entry type', () => {
             const today = new Date().toISOString().split('T')[0]!
             const results = db.searchByDateRange(today, today, {
-                entryType: 'decision',
+                entryType: 'project_decision',
             })
             for (const r of results) {
-                expect(r.entryType).toBe('decision')
+                expect(r.entryType).toBe('project_decision')
             }
         })
 
@@ -552,4 +611,29 @@ describe('SqliteAdapter', () => {
             expect(results.length).toBeGreaterThan(0)
         })
     })
+
+    // ========================================================================
+    // Backup edge cases
+    // ========================================================================
+
+    describe('backup edge cases', () => {
+        it('should return empty array when backups directory does not exist', () => {
+            // Use a fresh adapter with no backups dir created
+            const tempDb = new SqliteAdapter('./test-no-backups.db')
+            tempDb.initialize()
+            const backups = tempDb.listBackups()
+            expect(backups).toEqual([])
+            tempDb.close()
+        })
+
+        it('should throw when deleteOldBackups keepCount is less than 1', () => {
+            expect(() => db.deleteOldBackups(0)).toThrow('keepCount must be at least 1')
+        })
+
+        it('should throw when restoring from non-existent backup file', async () => {
+            await expect(db.restoreFromFile('nonexistent-backup.db')).rejects.toThrow(
+                'Backup file not found'
+            )
+        })
+    })
 })

package/tests/e2e/auth.spec.ts

@@ -0,0 +1,154 @@
+/**
+ * E2E Tests: Bearer Token Authentication
+ *
+ * Tests the --auth-token middleware. Uses a test-local server
+ * on port 3101 to avoid conflicting with the main webServer.
+ */
+
+import { test, expect } from '@playwright/test'
+import { type ChildProcess, spawn } from 'node:child_process'
+import { setTimeout as delay } from 'node:timers/promises'
+
+const AUTH_TOKEN = 'test-secret-token-e2e'
+const AUTH_PORT = 3101
+const AUTH_BASE = `http://localhost:${AUTH_PORT}`
+
+let serverProcess: ChildProcess | null = null
+
+/**
+ * Start a second MCP server with --auth-token on a different port.
+ * Waits for /health to become reachable before returning.
+ */
+async function startAuthServer(): Promise<void> {
+    serverProcess = spawn(
+        'node',
+        [
+            'dist/cli.js',
+            '--transport',
+            'http',
+            '--port',
+            String(AUTH_PORT),
+            '--db',
+            './test-e2e-auth.db',
+            '--auth-token',
+            AUTH_TOKEN,
+        ],
+        {
+            cwd: process.cwd(),
+            stdio: 'pipe',
+        }
+    )
+
+    // Wait for server to be ready (poll /health)
+    const maxAttempts = 30
+    for (let i = 0; i < maxAttempts; i++) {
+        try {
+            const res = await fetch(`${AUTH_BASE}/health`)
+            if (res.ok) return
+        } catch {
+            // Server not ready yet
+        }
+        await delay(500)
+    }
+    throw new Error('Auth server did not start within timeout')
+}
+
+function stopAuthServer(): void {
+    if (serverProcess) {
+        serverProcess.kill('SIGTERM')
+        serverProcess = null
+    }
+}
+
+test.describe('Bearer Token Authentication', () => {
+    test.beforeAll(async () => {
+        await startAuthServer()
+    })
+
+    test.afterAll(() => {
+        stopAuthServer()
+    })
+
+    test('/health should be accessible without token (exempt)', async () => {
+        const response = await fetch(`${AUTH_BASE}/health`)
+        expect(response.status).toBe(200)
+
+        const body = await response.json()
+        expect(body).toHaveProperty('status', 'healthy')
+    })
+
+    test('POST /mcp should return 401 without Authorization header', async () => {
+        const response = await fetch(`${AUTH_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: 'test', version: '1.0' },
+                },
+            }),
+        })
+
+        expect(response.status).toBe(401)
+        const body = await response.json()
+        expect(body).toHaveProperty('error', 'Unauthorized')
+    })
+
+    test('POST /mcp should return 401 with wrong token', async () => {
+        const response = await fetch(`${AUTH_BASE}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/event-stream',
+                Authorization: 'Bearer wrong-token',
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'initialize',
+                params: {
+                    protocolVersion: '2025-03-26',
+                    capabilities: {},
+                    clientInfo: { name: 'test', version: '1.0' },
+                },
+            }),
+        })
+
+        expect(response.status).toBe(401)
+    })
+
+    test('POST /mcp should succeed with correct Bearer token', async () => {
+        const response = await fetch(`${AUTH_BASE}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/event-stream',
+                Authorization: `Bearer ${AUTH_TOKEN}`,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'initialize',
+                params: {
+                    protocolVersion: '2025-03-26',
+                    capabilities: {},
+                    clientInfo: { name: 'test', version: '1.0' },
+                },
+            }),
+        })
+
+        expect(response.status).toBe(200)
+    })
+
+    test('GET / should return 401 without token', async () => {
+        const response = await fetch(`${AUTH_BASE}/`)
+        expect(response.status).toBe(401)
+    })
+})

package/tests/e2e/health.spec.ts

@@ -0,0 +1,63 @@
+/**
+ * E2E Tests: Health & Root Info
+ *
+ * Verifies the HTTP server's health check and root info endpoints
+ * return correct responses with expected structure.
+ */
+
+import { test, expect } from '@playwright/test'
+
+test.describe('Health & Root Info', () => {
+    test('should return 200 OK from /health endpoint', async ({ request }) => {
+        const response = await request.get('/health')
+        expect(response.status()).toBe(200)
+
+        const body = await response.json()
+        expect(body).toHaveProperty('status', 'healthy')
+        expect(body).toHaveProperty('timestamp')
+        // Timestamp should be a valid ISO string
+        expect(new Date(body.timestamp).toISOString()).toBe(body.timestamp)
+    })
+
+    test('should return server metadata on GET /', async ({ request }) => {
+        const response = await request.get('/')
+        expect(response.status()).toBe(200)
+
+        const body = await response.json()
+        expect(body).toHaveProperty('name', 'memory-journal-mcp')
+        expect(body).toHaveProperty('version')
+        expect(body).toHaveProperty('description')
+        expect(body).toHaveProperty('endpoints')
+        expect(body.endpoints).toHaveProperty('POST /mcp')
+        expect(body.endpoints).toHaveProperty('GET /sse')
+        expect(body.endpoints).toHaveProperty('GET /health')
+    })
+
+    test('should accept MCP initialization request on /mcp', 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-test',
+                        version: '1.0.0',
+                    },
+                },
+            },
+        })
+
+        expect(response.status()).toBe(200)
+        // Session ID should be returned in response headers
+        const sessionId = response.headers()['mcp-session-id']
+        expect(sessionId).toBeDefined()
+        expect(typeof sessionId).toBe('string')
+        expect(sessionId!.length).toBeGreaterThan(0)
+    })
+})

package/tests/e2e/protocols.spec.ts

@@ -0,0 +1,134 @@
+/**
+ * E2E Tests: HTTP Transport Protocols
+ *
+ * Tests both Streamable HTTP (MCP 2025-03-26) and Legacy SSE (MCP 2024-11-05)
+ * protocol error handling and routing.
+ */
+
+import { test, expect } from '@playwright/test'
+
+test.describe('HTTP Transport Protocols', () => {
+    test.describe('Streamable HTTP (MCP 2025-03-26)', () => {
+        test('should reject non-init request without session ID', async ({ request }) => {
+            const response = await request.post('/mcp', {
+                headers: {
+                    Accept: 'application/json, text/event-stream',
+                },
+                data: {
+                    jsonrpc: '2.0',
+                    id: 1,
+                    method: 'ping',
+                },
+            })
+
+            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 malformed JSON body on /mcp', async ({ request }) => {
+            const response = await request.post('/mcp', {
+                headers: {
+                    Accept: 'application/json, text/event-stream',
+                    'Content-Type': 'application/json',
+                },
+                data: Buffer.from('{"broken": json}'),
+            })
+
+            // Express JSON parser rejects invalid JSON before reaching our handler
+            expect(response.status()).toBe(400)
+        })
+
+        test('should accept initialization 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-protocol-test',
+                            version: '1.0.0',
+                        },
+                    },
+                },
+            })
+
+            expect(response.status()).toBe(200)
+            const sessionId = response.headers()['mcp-session-id']
+            expect(sessionId).toBeDefined()
+        })
+    })
+
+    test.describe('Legacy SSE (MCP 2024-11-05)', () => {
+        test('should reject /messages POST without sessionId parameter', async ({ request }) => {
+            const response = await request.post('/messages', {
+                data: {
+                    jsonrpc: '2.0',
+                    id: 1,
+                    method: 'initialize',
+                    params: {
+                        protocolVersion: '2024-11-05',
+                        capabilities: {},
+                        clientInfo: { name: 'test', version: '1.0' },
+                    },
+                },
+            })
+
+            expect(response.status()).toBe(400)
+            const body = await response.json()
+            expect(body.error).toHaveProperty('message', 'Missing sessionId parameter')
+        })
+
+        test('should reject /messages POST with unknown sessionId', async ({ request }) => {
+            const response = await request.post('/messages?sessionId=invalid-session-uuid', {
+                data: {
+                    jsonrpc: '2.0',
+                    id: 1,
+                    method: 'ping',
+                },
+            })
+
+            expect(response.status()).toBe(404)
+            const body = await response.json()
+            expect(body.error).toHaveProperty('message', 'Session not found')
+        })
+
+        test('should complete full SDK client round-trip via Legacy SSE', async () => {
+            // Regression test: server.connect() auto-calls start() on SSEServerTransport,
+            // so a redundant start() call would throw "already started!" and break SSE entirely.
+            const { Client } = await import('@modelcontextprotocol/sdk/client/index.js')
+            const { SSEClientTransport } = await import('@modelcontextprotocol/sdk/client/sse.js')
+
+            const transport = new SSEClientTransport(new URL('http://localhost:3100/sse'))
+            const client = new Client(
+                { name: 'playwright-sse-regression', version: '1.0.0' },
+                { capabilities: {} }
+            )
+
+            try {
+                await client.connect(transport)
+
+                const response = await client.callTool({
+                    name: 'test_simple',
+                    arguments: { message: 'SSE round-trip' },
+                })
+
+                expect(response.isError).toBeUndefined()
+                expect(Array.isArray(response.content)).toBe(true)
+                const text = (response.content[0] as { type: string; text: string }).text
+                expect(text).toContain('SSE round-trip')
+            } finally {
+                await client.close()
+            }
+        })
+    })
+})

package/tests/e2e/resources.spec.ts

@@ -0,0 +1,103 @@
+/**
+ * E2E Tests: MCP Resource Reads via SDK Client
+ *
+ * Uses the official @modelcontextprotocol/sdk client to connect
+ * via Streamable HTTP transport and read resources end-to-end.
+ */
+
+import { test, expect } from '@playwright/test'
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
+
+test.describe.configure({ mode: 'serial' })
+
+test.describe('E2E Resource Reads (via MCP SDK Client)', () => {
+    let client: Client
+
+    test.beforeAll(async () => {
+        const transport = new StreamableHTTPClientTransport(new URL('http://localhost:3100/mcp'))
+        client = new Client(
+            { name: 'playwright-resource-test', version: '1.0.0' },
+            { capabilities: {} }
+        )
+        await client.connect(transport)
+    })
+
+    test.afterAll(async () => {
+        await client.close()
+    })
+
+    test('should list available resources', async () => {
+        const listResponse = await client.listResources()
+
+        expect(listResponse.resources).toBeDefined()
+        expect(Array.isArray(listResponse.resources)).toBe(true)
+        expect(listResponse.resources.length).toBeGreaterThan(0)
+
+        const uris = listResponse.resources.map((r) => r.uri)
+        expect(uris).toContain('memory://health')
+        expect(uris).toContain('memory://briefing')
+        expect(uris).toContain('memory://recent')
+        expect(uris).toContain('memory://statistics')
+    })
+
+    test('should read memory://health resource', async () => {
+        const response = await client.readResource({ uri: 'memory://health' })
+
+        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('database')
+        expect(parsed).toHaveProperty('vectorIndex')
+        expect(parsed).toHaveProperty('scheduler')
+    })
+
+    test('should read memory://briefing resource', async () => {
+        const response = await client.readResource({ uri: 'memory://briefing' })
+
+        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('userMessage')
+        expect(parsed).toHaveProperty('journal')
+    })
+
+    test('should read memory://recent resource', async () => {
+        const response = await client.readResource({ uri: 'memory://recent' })
+
+        expect(response.contents).toBeDefined()
+        expect(response.contents.length).toBeGreaterThan(0)
+
+        const text = response.contents[0]!.text as string
+        const parsed = JSON.parse(text)
+        // May be empty if no entries exist, but should be valid JSON
+        expect(parsed).toBeDefined()
+    })
+
+    test('should read memory://statistics resource', async () => {
+        const response = await client.readResource({ uri: 'memory://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(parsed).toHaveProperty('totalEntries')
+    })
+
+    test('should list resource templates', async () => {
+        const response = await client.listResourceTemplates()
+
+        expect(response.resourceTemplates).toBeDefined()
+        expect(Array.isArray(response.resourceTemplates)).toBe(true)
+        expect(response.resourceTemplates.length).toBeGreaterThan(0)
+
+        const uriTemplates = response.resourceTemplates.map((t) => t.uriTemplate)
+        expect(uriTemplates).toContain('memory://issues/{issue_number}/entries')
+        expect(uriTemplates).toContain('memory://kanban/{project_number}')
+    })
+})