memory-journal-mcp 6.1.2 → 6.2.1

package/tests/e2e/payloads-codemode-readonly.spec.ts

@@ -1,116 +0,0 @@
-/**
- * Payload Contract Tests: Code Mode Readonly Enforcement
- *
- * Tests that mj_execute_code with readonly=true correctly
- * returns structured errors for mutation attempts instead of
- * TypeError or undefined behavior.
- *
- * Uses the standard E2E server (port 3100) with the built-in
- * readonly parameter on mj_execute_code (not --tool-filter readonly
- * which would exclude mj_execute_code entirely).
- */
-
-import { test, expect } from '@playwright/test'
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { createClient } from './helpers.js'
-
-test.describe('Code Mode Readonly Enforcement', () => {
-    let client: Client
-
-    test.beforeAll(async () => {
-        client = await createClient()
-    })
-
-    test.afterAll(async () => {
-        await client.close()
-    })
-
-    test('read operations succeed with readonly=true param', async () => {
-        const response = await client.callTool({
-            name: 'mj_execute_code',
-            arguments: {
-                code: `
-                    const recent = await mj.core.getRecentEntries({ limit: 1 });
-                    return recent;
-                `,
-                readonly: true,
-            },
-        })
-
-        expect(Array.isArray(response.content)).toBe(true)
-        const content = response.content as Array<{ type: string; text?: string }>
-        expect(content.length).toBeGreaterThan(0)
-        expect(content[0]!.type).toBe('text')
-        // Read should succeed — no error
-        const payload = JSON.parse(content[0]!.text!) as Record<string, unknown>
-        // Should have entries/count fields, not a structured error
-        expect(payload.success).not.toBe(false)
-    })
-
-    test('mj.core.createEntry raises structured error via readonly=true param', async () => {
-        const response = await client.callTool({
-            name: 'mj_execute_code',
-            arguments: {
-                code: `
-                    const result = await mj.core.createEntry({
-                        content: 'Should not be created',
-                        entry_type: 'test_entry',
-                    });
-                    return result;
-                `,
-                readonly: true,
-            },
-        })
-
-        expect(Array.isArray(response.content)).toBe(true)
-        const content = response.content as Array<{ type: string; text?: string }>
-        const payload = JSON.parse(content[0]!.text!) as Record<string, unknown>
-
-        // Should be a structured error, not a TypeError
-        expect(payload.success).toBe(false)
-        expect(typeof payload.error).toBe('string')
-        // Error message mentions either "not available", "not found in group", or "read-only"
-        expect((payload.error as string).toLowerCase()).toMatch(
-            /not available|not found in group|readonly|read.only/i
-        )
-    })
-
-    test('mj.admin.deleteEntry raises structured error via readonly=true param', async () => {
-        const response = await client.callTool({
-            name: 'mj_execute_code',
-            arguments: {
-                code: `
-                    const result = await mj.admin.deleteEntry({ entry_id: 1 });
-                    return result;
-                `,
-                readonly: true,
-            },
-        })
-
-        expect(Array.isArray(response.content)).toBe(true)
-        const content = response.content as Array<{ type: string; text?: string }>
-        const payload = JSON.parse(content[0]!.text!) as Record<string, unknown>
-
-        expect(payload.success).toBe(false)
-        expect(typeof payload.error).toBe('string')
-    })
-
-    test('mj.help() works correctly via readonly=true param', async () => {
-        const response = await client.callTool({
-            name: 'mj_execute_code',
-            arguments: {
-                code: `
-                    const help = mj.help();
-                    return help;
-                `,
-                readonly: true,
-            },
-        })
-
-        expect(Array.isArray(response.content)).toBe(true)
-        const content = response.content as Array<{ type: string; text?: string }>
-        expect(content.length).toBeGreaterThan(0)
-        // help() should return a string description or object
-        expect(content[0]!.text).toBeDefined()
-    })
-})

package/tests/e2e/payloads-codemode.spec.ts

@@ -1,116 +0,0 @@
-/**
- * Payload Contract Tests: Code Mode
- *
- * Validates mj_execute_code (Code Mode) execution, multi-step workflows,
- * security rejection, and timeout enforcement via E2E.
- */
-
-import { test, expect } from '@playwright/test'
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { createClient, callToolAndParse } from './helpers.js'
-
-test.describe.configure({ mode: 'serial' })
-
-test.describe('Payload Contracts: Code Mode', () => {
-    let client: Client
-
-    test.beforeAll(async () => {
-        client = await createClient()
-    })
-
-    test.afterAll(async () => {
-        await client.close()
-    })
-
-    test('should execute basic code via mj_execute_code', async () => {
-        const payload = await callToolAndParse(client, 'mj_execute_code', {
-            code: `
-                const result = await mj.core.testSimple({ message: 'code-mode-e2e' });
-                return result;
-            `,
-        })
-
-        expect(typeof payload).toBe('object')
-        // The result should contain the test_simple response
-        expect(JSON.stringify(payload)).toContain('code-mode-e2e')
-    })
-
-    test('should execute multi-step workflow in single execution', async () => {
-        const payload = await callToolAndParse(client, 'mj_execute_code', {
-            code: `
-                // Step 1: Create an entry
-                const created = await mj.core.createEntry({
-                    content: 'Code mode multi-step test',
-                    entry_type: 'test_entry',
-                    tags: ['codemode-test'],
-                });
-
-                // Step 2: Retrieve recent entries
-                const recent = await mj.core.getRecentEntries({ limit: 1 });
-
-                return {
-                    created: created.success,
-                    recentCount: recent.count,
-                };
-            `,
-        })
-
-        expect(typeof payload).toBe('object')
-    })
-
-    test('should reject code with blocked patterns (require)', async () => {
-        const response = await client.callTool({
-            name: 'mj_execute_code',
-            arguments: {
-                code: `const fs = require('fs'); return fs.readFileSync('/etc/passwd');`,
-            },
-        })
-
-        expect(response.isError).toBeUndefined()
-        expect(Array.isArray(response.content)).toBe(true)
-
-        const text = (response.content[0] as { type: string; text: string }).text
-        const parsed = JSON.parse(text)
-
-        // Should return a structured error with security failure
-        expect(parsed.success).toBe(false)
-        expect(parsed.error).toBeDefined()
-    })
-
-    test('should reject code with blocked patterns (process)', async () => {
-        const response = await client.callTool({
-            name: 'mj_execute_code',
-            arguments: {
-                code: `return process.env;`,
-            },
-        })
-
-        expect(response.isError).toBeUndefined()
-        expect(Array.isArray(response.content)).toBe(true)
-
-        const text = (response.content[0] as { type: string; text: string }).text
-        const parsed = JSON.parse(text)
-
-        expect(parsed.success).toBe(false)
-        expect(parsed.error).toBeDefined()
-    })
-
-    test('should enforce execution timeout', async () => {
-        const response = await client.callTool({
-            name: 'mj_execute_code',
-            arguments: {
-                code: `while (true) {}`,
-                timeout: 1,
-            },
-        })
-
-        expect(response.isError).toBeUndefined()
-        expect(Array.isArray(response.content)).toBe(true)
-
-        const text = (response.content[0] as { type: string; text: string }).text
-        const parsed = JSON.parse(text)
-
-        // Should report timeout or execution failure
-        expect(parsed.success).toBe(false)
-    })
-})

package/tests/e2e/payloads-core.spec.ts

@@ -1,82 +0,0 @@
-/**
- * Payload Contract Tests: Core
- *
- * Validates response shapes for 6 core tools:
- * create_entry, get_recent_entries, get_entry_by_id,
- * create_entry_minimal, test_simple, list_tags.
- */
-
-import { test, expect } from '@playwright/test'
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { createClient, callToolAndParse, expectSuccess } from './helpers.js'
-
-test.describe.configure({ mode: 'serial' })
-
-test.describe('Payload Contracts: Core', () => {
-    let client: Client
-    let createdEntryId: number
-
-    test.beforeAll(async () => {
-        client = await createClient()
-    })
-
-    test.afterAll(async () => {
-        await client.close()
-    })
-
-    test('test_simple returns { message }', async () => {
-        const payload = await callToolAndParse(client, 'test_simple', {
-            message: 'payload test',
-        })
-        expect(typeof payload.message).toBe('string')
-        expect(payload.message).toContain('payload test')
-    })
-
-    test('create_entry returns { success, entry }', async () => {
-        const payload = await callToolAndParse(client, 'create_entry', {
-            content: 'Payload contract test entry',
-            entry_type: 'test_entry',
-            tags: ['test', 'payload'],
-        })
-        expectSuccess(payload)
-        expect(payload.success).toBe(true)
-        expect(payload.entry).toBeDefined()
-        const entry = payload.entry as Record<string, unknown>
-        expect(typeof entry.id).toBe('number')
-        createdEntryId = entry.id as number
-    })
-
-    test('create_entry_minimal returns { success, entry }', async () => {
-        const payload = await callToolAndParse(client, 'create_entry_minimal', {
-            content: 'Minimal payload test',
-        })
-        expectSuccess(payload)
-        expect(payload.success).toBe(true)
-        expect(payload.entry).toBeDefined()
-    })
-
-    test('get_recent_entries returns { entries, count }', async () => {
-        const payload = await callToolAndParse(client, 'get_recent_entries', {
-            limit: 3,
-        })
-        expectSuccess(payload)
-        expect(Array.isArray(payload.entries)).toBe(true)
-        expect(typeof payload.count).toBe('number')
-    })
-
-    test('get_entry_by_id returns { entry, importance }', async () => {
-        const payload = await callToolAndParse(client, 'get_entry_by_id', {
-            entry_id: createdEntryId,
-        })
-        expectSuccess(payload)
-        expect(payload.entry).toBeDefined()
-        expect(payload.importance).toBeDefined()
-    })
-
-    test('list_tags returns { tags, count }', async () => {
-        const payload = await callToolAndParse(client, 'list_tags', {})
-        expectSuccess(payload)
-        expect(Array.isArray(payload.tags)).toBe(true)
-        expect(typeof payload.count).toBe('number')
-    })
-})

package/tests/e2e/payloads-error-contracts.spec.ts

@@ -1,159 +0,0 @@
-/**
- * Payload Contract Tests: Structured Error Field Contracts
- *
- * Validates that tool error responses include all required structured fields:
- * { success: false, error: string, code: string, category: string,
- *   suggestion: string, recoverable: boolean }
- *
- * Tests specific documented error paths: inverted date range,
- * nonexistent entry, self-loop link, and duplicate link detection.
- */
-
-import { test, expect } from '@playwright/test'
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { createClient, callToolAndParse, expectSuccess } from './helpers.js'
-
-test.describe.configure({ mode: 'serial' })
-
-test.describe('Payload Contracts: Structured Error Fields', () => {
-    let client: Client
-    let entryId1: number
-    let entryId2: number
-
-    test.beforeAll(async () => {
-        client = await createClient()
-        // Seed two entries for relationship error tests
-        const e1 = await callToolAndParse(client, 'create_entry', {
-            content: 'Error contract test entry A',
-            entry_type: 'test_entry',
-        })
-        expectSuccess(e1)
-        entryId1 = (e1.entry as Record<string, unknown>).id as number
-
-        const e2 = await callToolAndParse(client, 'create_entry', {
-            content: 'Error contract test entry B',
-            entry_type: 'test_entry',
-        })
-        expectSuccess(e2)
-        entryId2 = (e2.entry as Record<string, unknown>).id as number
-    })
-
-    test.afterAll(async () => {
-        await client.close()
-    })
-
-    /**
-     * Assert minimum structured error fields (success, error, code, category).
-     * Use for handlers that return inline error objects without suggestion/recoverable.
-     */
-    function expectMinimumError(payload: Record<string, unknown>, expectedCode?: string): void {
-        expect(payload.success).toBe(false)
-        expect(typeof payload.error).toBe('string')
-        expect(typeof payload.code).toBe('string')
-        expect(typeof payload.category).toBe('string')
-
-        if (expectedCode) {
-            expect(payload.code).toBe(expectedCode)
-        }
-    }
-
-    /**
-     * Assert all 6 structured error fields are present (formatHandlerError paths).
-     * Use for tools that route errors through formatHandlerError or MemoryJournalMcpError.
-     */
-    function expectFullError(payload: Record<string, unknown>, expectedCode?: string): void {
-        expectMinimumError(payload, expectedCode)
-        expect(typeof payload.suggestion).toBe('string')
-        expect(typeof payload.recoverable).toBe('boolean')
-    }
-
-    // --- search_by_date_range: inverted date range ---
-
-    test('search_by_date_range (inverted range) returns VALIDATION_ERROR with all fields', async () => {
-        const payload = await callToolAndParse(client, 'search_by_date_range', {
-            start_date: '2030-12-31',
-            end_date: '2020-01-01',
-        })
-
-        expectFullError(payload, 'VALIDATION_ERROR')
-        expect(payload.category).toBe('validation')
-    })
-
-    // --- get_entry_by_id: nonexistent entry ---
-
-    test('get_entry_by_id (nonexistent ID) returns structured error with code+category', async () => {
-        const payload = await callToolAndParse(client, 'get_entry_by_id', {
-            entry_id: 999999999,
-        })
-
-        expectMinimumError(payload)
-        // Resource errors categorize under 'resource' or 'not_found'
-        expect(['resource', 'not_found']).toContain(payload.category)
-    })
-
-    // --- update_entry: nonexistent entry ---
-
-    test('update_entry (nonexistent ID) returns structured error with code+category', async () => {
-        const payload = await callToolAndParse(client, 'update_entry', {
-            entry_id: 999999999,
-            content: 'should not update',
-        })
-
-        expectMinimumError(payload)
-        expect(typeof payload.category).toBe('string')
-    })
-
-    // --- link_entries: self-loop ---
-
-    test('link_entries self-loop returns structured error with code+category', async () => {
-        const payload = await callToolAndParse(client, 'link_entries', {
-            from_entry_id: entryId1,
-            to_entry_id: entryId1,
-            relationship_type: 'references',
-        })
-
-        // Self-loop returns { success, error, code: 'VALIDATION_ERROR', category: 'validation' }
-        // (no suggestion/recoverable on inline error paths)
-        expectMinimumError(payload, 'VALIDATION_ERROR')
-        expect(payload.category).toBe('validation')
-    })
-
-    // --- link_entries: duplicate detection returns { duplicate: true } ---
-
-    test('link_entries duplicate returns { duplicate: true } (not alreadyExists)', async () => {
-        // First link succeeds
-        const first = await callToolAndParse(client, 'link_entries', {
-            from_entry_id: entryId1,
-            to_entry_id: entryId2,
-            relationship_type: 'references',
-        })
-        expectSuccess(first)
-        expect(first.success).toBe(true)
-
-        // Second identical link is a duplicate
-        const payload = await callToolAndParse(client, 'link_entries', {
-            from_entry_id: entryId1,
-            to_entry_id: entryId2,
-            relationship_type: 'references',
-        })
-
-        // Duplicate detection: { duplicate: true } — NOT { alreadyExists: true }
-        expect(payload.duplicate).toBe(true)
-        expect(payload).not.toHaveProperty('alreadyExists')
-    })
-
-    // --- delete_entry: nonexistent entry structured error ---
-
-    test('delete_entry (already-deleted or nonexistent) returns structured error with code+category', async () => {
-        // Try to delete a very high ID that doesn't exist
-        const payload = await callToolAndParse(client, 'delete_entry', {
-            entry_id: 999999998,
-        })
-
-        // Should be a structured error with minimum fields
-        if (payload.success === false) {
-            expectMinimumError(payload)
-        }
-        // If success (sqlite soft-delete may silently succeed on missing rows) — also valid
-    })
-})

package/tests/e2e/payloads-export.spec.ts

@@ -1,46 +0,0 @@
-/**
- * Payload Contract Tests: Export
- *
- * Validates response shapes for 1 export tool:
- * export_entries.
- */
-
-import { test, expect } from '@playwright/test'
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { createClient, callToolAndParse, expectSuccess } from './helpers.js'
-
-test.describe.configure({ mode: 'serial' })
-
-test.describe('Payload Contracts: Export', () => {
-    let client: Client
-
-    test.beforeAll(async () => {
-        client = await createClient()
-    })
-
-    test.afterAll(async () => {
-        await client.close()
-    })
-
-    test('export_entries (json) returns { format, entries, count }', async () => {
-        const payload = await callToolAndParse(client, 'export_entries', {
-            format: 'json',
-            limit: 5,
-        })
-        expectSuccess(payload)
-        expect(payload.format).toBe('json')
-        expect(Array.isArray(payload.entries)).toBe(true)
-        expect(typeof payload.count).toBe('number')
-        expect(payload.count).toBe(payload.entries.length)
-    })
-
-    test('export_entries (markdown) returns { format, content }', async () => {
-        const payload = await callToolAndParse(client, 'export_entries', {
-            format: 'markdown',
-            limit: 5,
-        })
-        expectSuccess(payload)
-        expect(payload.format).toBe('markdown')
-        expect(typeof payload.content).toBe('string')
-    })
-})

package/tests/e2e/payloads-github-degradation.spec.ts

@@ -1,73 +0,0 @@
-/**
- * Payload Contract Tests: GitHub Configuration Degradation
- *
- * Verifies that GitHub tools gracefully degrade and return
- * structured { requiresUserInput: true } errors instead of crashing
- * or throwing unhandled exceptions when GITHUB_REPO_PATH is missing.
- */
-
-import { test, expect } from '@playwright/test'
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { startServer, stopServer, createClient } from './helpers.js'
-import { tmpdir } from 'node:os'
-
-const GITHUB_DEGRADE_PORT = 3115
-
-test.describe.configure({ mode: 'serial' })
-
-test.describe('Payload Contracts: GitHub Config Degradation', () => {
-    let client: Client
-
-    test.beforeAll(async () => {
-        // Strip out GITHUB_REPO_PATH and GITHUB_TOKEN so auto-detect fails
-        const oldRepo = process.env.GITHUB_REPO_PATH
-        const oldToken = process.env.GITHUB_TOKEN
-
-        delete process.env.GITHUB_REPO_PATH
-        delete process.env.GITHUB_TOKEN
-
-        // startServer propagates the current process.env
-        try {
-            const startOpts = { cwd: tmpdir() }
-            await startServer(GITHUB_DEGRADE_PORT, [], 'gh-degrade', startOpts)
-            client = await createClient(GITHUB_DEGRADE_PORT)
-        } finally {
-            if (oldRepo) process.env.GITHUB_REPO_PATH = oldRepo
-            if (oldToken) process.env.GITHUB_TOKEN = oldToken
-        }
-    })
-
-    test.afterAll(async () => {
-        if (client) {
-            await client.close()
-        }
-        stopServer(GITHUB_DEGRADE_PORT)
-    })
-
-    test('get_github_issues returns requiresUserInput: true without auto-detect env', async () => {
-        const response = await client.callTool({
-            name: 'get_github_issues',
-            arguments: {}, // Empty properties to fail auto-detect
-        })
-
-        expect(Array.isArray(response.content)).toBe(true)
-        const text = (response.content as Array<{ text: string }>)[0]!.text
-        console.log('GitHub Degrade Response:', text)
-        // Check for presence of auto-detect mention
-        expect(text).toContain('Could not auto-detect')
-    })
-
-    test('get_github_context degrades gracefully to returning missing state', async () => {
-        const response = await client.callTool({
-            name: 'get_github_context',
-            arguments: {},
-        })
-
-        expect(Array.isArray(response.content)).toBe(true)
-        const text = (response.content as Array<{ text: string }>)[0]!.text
-        const payload = JSON.parse(text)
-
-        expect(payload.repoName).toBeNull()
-        expect(payload.issueCount).toBe(0)
-    })
-})