memory-journal-mcp 6.1.2 → 6.2.1

package/tests/auth/token-validator.test.ts

@@ -1,271 +0,0 @@
-/**
- * memory-journal-mcp — Token Validator Unit Tests
- *
- * Tests for JWT token validation including error handling,
- * scope parsing, and JWKS integration.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { TokenValidator, createTokenValidator } from '../../src/auth/token-validator.js'
-import type { TokenValidatorConfig } from '../../src/auth/types.js'
-import { AUTH_ERROR_CODES } from '../../src/auth/errors.js'
-
-// Mock jose to avoid real JWKS fetching
-vi.mock('jose', () => ({
-    createRemoteJWKSet: vi.fn(() => vi.fn()),
-    jwtVerify: vi.fn(),
-    errors: {
-        JWTExpired: class JWTExpired extends Error {
-            constructor() {
-                super('JWT expired')
-                this.name = 'JWTExpired'
-            }
-        },
-        JWKSNoMatchingKey: class JWKSNoMatchingKey extends Error {
-            constructor() {
-                super('No matching key')
-                this.name = 'JWKSNoMatchingKey'
-            }
-        },
-        JWSSignatureVerificationFailed: class JWSSignatureVerificationFailed extends Error {
-            constructor() {
-                super('Signature failed')
-                this.name = 'JWSSignatureVerificationFailed'
-            }
-        },
-        JWTClaimValidationFailed: class JWTClaimValidationFailed extends Error {
-            constructor() {
-                super('Claim validation failed')
-                this.name = 'JWTClaimValidationFailed'
-            }
-        },
-    },
-}))
-
-describe('TokenValidator', () => {
-    let config: TokenValidatorConfig
-
-    beforeEach(() => {
-        vi.clearAllMocks()
-        config = {
-            jwksUri: 'https://auth.example.com/.well-known/jwks.json',
-            issuer: 'https://auth.example.com',
-            audience: 'memory-journal-mcp',
-        }
-    })
-
-    describe('construction', () => {
-        it('should create instance with config', () => {
-            const validator = new TokenValidator(config)
-            expect(validator).toBeInstanceOf(TokenValidator)
-        })
-
-        it('should apply default clockTolerance', () => {
-            const validator = new TokenValidator(config)
-            expect(validator).toBeDefined()
-        })
-    })
-
-    describe('createTokenValidator factory', () => {
-        it('should create TokenValidator instance', () => {
-            const validator = createTokenValidator(config)
-            expect(validator).toBeInstanceOf(TokenValidator)
-        })
-    })
-
-    describe('validate', () => {
-        it('should validate token and return claims on success', async () => {
-            const { jwtVerify } = await import('jose')
-            const mockVerify = vi.mocked(jwtVerify)
-
-            const mockPayload = {
-                sub: 'user-1',
-                iss: 'https://auth.example.com',
-                aud: 'memory-journal-mcp',
-                exp: Math.floor(Date.now() / 1000) + 3600,
-                iat: Math.floor(Date.now() / 1000),
-                scope: 'read write',
-            }
-
-            mockVerify.mockResolvedValueOnce({
-                payload: mockPayload,
-                protectedHeader: { alg: 'RS256' },
-            } as never)
-
-            const validator = new TokenValidator(config)
-            const result = await validator.validate('valid-jwt-token')
-
-            expect(result.valid).toBe(true)
-            expect(result.claims).toBeDefined()
-            expect(result.claims?.sub).toBe('user-1')
-            expect(result.claims?.scopes).toEqual(['read', 'write'])
-        })
-
-        it('should return invalid for expired tokens', async () => {
-            const { jwtVerify, errors } = await import('jose')
-            const mockVerify = vi.mocked(jwtVerify)
-
-            const mockError = Object.create(errors.JWTExpired.prototype) as Error
-            mockError.message = 'JWT expired'
-            mockError.name = 'JWTExpired'
-
-            mockVerify.mockRejectedValueOnce(mockError)
-
-            const validator = new TokenValidator(config)
-            const result = await validator.validate('expired-token')
-
-            expect(result.valid).toBe(false)
-            expect(result.error).toBeDefined()
-            expect(result.errorCode).toBe(AUTH_ERROR_CODES.TOKEN_EXPIRED)
-        })
-
-        it('should handle signature verification failure', async () => {
-            const { jwtVerify, errors } = await import('jose')
-            const mockVerify = vi.mocked(jwtVerify)
-
-            const mockError = Object.create(
-                errors.JWSSignatureVerificationFailed.prototype
-            ) as Error
-            mockError.message = 'Signature failed'
-            mockError.name = 'JWSSignatureVerificationFailed'
-
-            mockVerify.mockRejectedValueOnce(mockError)
-
-            const validator = new TokenValidator(config)
-            const result = await validator.validate('bad-sig-token')
-
-            expect(result.valid).toBe(false)
-            expect(result.errorCode).toBe(AUTH_ERROR_CODES.SIGNATURE_INVALID)
-        })
-
-        it('should handle claim validation failure', async () => {
-            const { jwtVerify, errors } = await import('jose')
-            const mockVerify = vi.mocked(jwtVerify)
-
-            const mockError = Object.create(errors.JWTClaimValidationFailed.prototype) as Error
-            mockError.message = 'Claim validation failed'
-            mockError.name = 'JWTClaimValidationFailed'
-
-            mockVerify.mockRejectedValueOnce(mockError)
-
-            const validator = new TokenValidator(config)
-            const result = await validator.validate('bad-claims-token')
-
-            expect(result.valid).toBe(false)
-            expect(result.errorCode).toBe(AUTH_ERROR_CODES.TOKEN_INVALID)
-        })
-
-        it('should handle no matching key in JWKS', async () => {
-            const { jwtVerify, errors } = await import('jose')
-            const mockVerify = vi.mocked(jwtVerify)
-
-            const mockError = Object.create(errors.JWKSNoMatchingKey.prototype) as Error
-            mockError.message = 'No matching key'
-            mockError.name = 'JWKSNoMatchingKey'
-
-            mockVerify.mockRejectedValueOnce(mockError)
-
-            const validator = new TokenValidator(config)
-            const result = await validator.validate('no-matching-key-token')
-
-            expect(result.valid).toBe(false)
-            expect(result.errorCode).toBe(AUTH_ERROR_CODES.TOKEN_INVALID)
-        })
-
-        it('should handle unknown errors', async () => {
-            const { jwtVerify } = await import('jose')
-            const mockVerify = vi.mocked(jwtVerify)
-
-            mockVerify.mockRejectedValueOnce(new Error('Unknown error'))
-
-            const validator = new TokenValidator(config)
-            const result = await validator.validate('unknown-error-token')
-
-            expect(result.valid).toBe(false)
-            expect(result.errorCode).toBe(AUTH_ERROR_CODES.TOKEN_INVALID)
-        })
-
-        it('should parse scope claim as string', async () => {
-            const { jwtVerify } = await import('jose')
-            const mockVerify = vi.mocked(jwtVerify)
-
-            mockVerify.mockResolvedValueOnce({
-                payload: {
-                    sub: 'user-1',
-                    scope: 'read admin',
-                    exp: Math.floor(Date.now() / 1000) + 3600,
-                    iat: Math.floor(Date.now() / 1000),
-                },
-                protectedHeader: { alg: 'RS256' },
-            } as never)
-
-            const validator = new TokenValidator(config)
-            const result = await validator.validate('scope-token')
-
-            expect(result.valid).toBe(true)
-            expect(result.claims?.scopes).toEqual(['read', 'admin'])
-        })
-
-        it('should parse scopes claim as array', async () => {
-            const { jwtVerify } = await import('jose')
-            const mockVerify = vi.mocked(jwtVerify)
-
-            mockVerify.mockResolvedValueOnce({
-                payload: {
-                    sub: 'user-2',
-                    scopes: ['write', 'admin'],
-                    exp: Math.floor(Date.now() / 1000) + 3600,
-                    iat: Math.floor(Date.now() / 1000),
-                },
-                protectedHeader: { alg: 'RS256' },
-            } as never)
-
-            const validator = new TokenValidator(config)
-            const result = await validator.validate('array-scope-token')
-
-            expect(result.valid).toBe(true)
-            expect(result.claims?.scopes).toEqual(['write', 'admin'])
-        })
-    })
-
-    describe('cache management', () => {
-        it('should clear cache', () => {
-            const validator = new TokenValidator(config)
-            expect(() => validator.clearCache()).not.toThrow()
-        })
-
-        it('should refresh JWKS', () => {
-            const validator = new TokenValidator(config)
-            expect(() => validator.refreshJwks()).not.toThrow()
-        })
-    })
-
-    describe('toOAuthError', () => {
-        it('should convert expired error code to TokenExpiredError', () => {
-            const error = TokenValidator.toOAuthError({
-                valid: false,
-                error: 'Token has expired',
-                errorCode: AUTH_ERROR_CODES.TOKEN_EXPIRED,
-            })
-            expect(error.name).toBe('TokenExpiredError')
-        })
-
-        it('should convert signature error code to InvalidSignatureError', () => {
-            const error = TokenValidator.toOAuthError({
-                valid: false,
-                error: 'Signature failed',
-                errorCode: AUTH_ERROR_CODES.SIGNATURE_INVALID,
-            })
-            expect(error.name).toBe('InvalidSignatureError')
-        })
-
-        it('should convert generic error to InvalidTokenError', () => {
-            const error = TokenValidator.toOAuthError({
-                valid: false,
-                error: 'Something went wrong',
-                errorCode: AUTH_ERROR_CODES.TOKEN_INVALID,
-            })
-            expect(error.name).toBe('InvalidTokenError')
-        })
-    })
-})

package/tests/codemode/api.test.ts

@@ -1,396 +0,0 @@
-/**
- * Code Mode API Bridge Tests
- *
- * Tests for JournalApi, toolNameToMethodName, and createSandboxBindings:
- * - Tool name → camelCase conversion
- * - Group API creation
- * - Positional argument support
- * - Method aliases
- * - help() discoverability
- * - Top-level aliases
- * - Codemode tool exclusion (no recursion)
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest'
-import { JournalApi, toolNameToMethodName, createJournalApi } from '../../src/codemode/api.js'
-import type { ToolDefinition } from '../../src/types/index.js'
-
-// =============================================================================
-// Test Fixtures
-// =============================================================================
-
-function createMockTool(
-    name: string,
-    group: string,
-    handler?: (params: unknown) => unknown
-): ToolDefinition {
-    return {
-        name,
-        title: name,
-        description: `Test tool: ${name}`,
-        group: group as ToolDefinition['group'],
-        inputSchema: {} as ToolDefinition['inputSchema'],
-        outputSchema: {} as ToolDefinition['outputSchema'],
-        annotations: { readOnlyHint: true },
-        handler: handler ?? ((params: unknown) => Promise.resolve({ success: true, params })),
-    }
-}
-
-function createMinimalToolSet(): ToolDefinition[] {
-    return [
-        createMockTool('create_entry', 'core'),
-        createMockTool('create_entry_minimal', 'core'),
-        createMockTool('get_entry_by_id', 'core'),
-        createMockTool('get_recent_entries', 'core'),
-        createMockTool('search_entries', 'search'),
-        createMockTool('semantic_search', 'search'),
-        createMockTool('get_statistics', 'analytics'),
-        createMockTool('link_entries', 'relationships'),
-        createMockTool('export_entries', 'export'),
-        createMockTool('update_entry', 'admin'),
-        createMockTool('delete_entry', 'admin'),
-        createMockTool('get_github_issues', 'github'),
-        createMockTool('backup_journal', 'backup'),
-        createMockTool('team_create_entry', 'team'),
-    ]
-}
-
-// =============================================================================
-// toolNameToMethodName
-// =============================================================================
-
-describe('toolNameToMethodName', () => {
-    it('should convert snake_case to camelCase', () => {
-        expect(toolNameToMethodName('create_entry', 'core')).toBe('createEntry')
-    })
-
-    it('should handle multi-word names', () => {
-        expect(toolNameToMethodName('get_recent_entries', 'core')).toBe('getRecentEntries')
-    })
-
-    it('should handle single-word names', () => {
-        expect(toolNameToMethodName('export_entries', 'export')).toBe('exportEntries')
-    })
-
-    it('should keep prefix for github tools', () => {
-        expect(toolNameToMethodName('get_github_issues', 'github')).toBe('getGithubIssues')
-    })
-
-    it('should keep prefix for team tools', () => {
-        expect(toolNameToMethodName('team_create_entry', 'team')).toBe('teamCreateEntry')
-    })
-
-    it('should handle search tools', () => {
-        expect(toolNameToMethodName('search_entries', 'search')).toBe('searchEntries')
-        expect(toolNameToMethodName('semantic_search', 'search')).toBe('semanticSearch')
-    })
-
-    it('should handle admin tools', () => {
-        expect(toolNameToMethodName('update_entry', 'admin')).toBe('updateEntry')
-        expect(toolNameToMethodName('delete_entry', 'admin')).toBe('deleteEntry')
-    })
-
-    it('should handle backup tools', () => {
-        expect(toolNameToMethodName('backup_journal', 'backup')).toBe('backupJournal')
-        expect(toolNameToMethodName('list_backups', 'backup')).toBe('listBackups')
-    })
-})
-
-// =============================================================================
-// JournalApi
-// =============================================================================
-
-describe('JournalApi', () => {
-    let api: JournalApi
-
-    beforeEach(() => {
-        api = new JournalApi(createMinimalToolSet())
-    })
-
-    // =========================================================================
-    // Group Creation
-    // =========================================================================
-
-    describe('group creation', () => {
-        it('should create all 9 group namespaces', () => {
-            expect(api.core).toBeDefined()
-            expect(api.search).toBeDefined()
-            expect(api.analytics).toBeDefined()
-            expect(api.relationships).toBeDefined()
-            expect(api.export).toBeDefined()
-            expect(api.admin).toBeDefined()
-            expect(api.github).toBeDefined()
-            expect(api.backup).toBeDefined()
-            expect(api.team).toBeDefined()
-        })
-
-        it('should populate groups with methods', () => {
-            expect(typeof api.core['createEntry']).toBe('function')
-            expect(typeof api.search['searchEntries']).toBe('function')
-            expect(typeof api.analytics['getStatistics']).toBe('function')
-        })
-
-        it('should exclude codemode tools', () => {
-            const toolsWithCodemode = [
-                ...createMinimalToolSet(),
-                createMockTool('mj_execute_code', 'codemode'),
-            ]
-            const apiWithCodemode = new JournalApi(toolsWithCodemode)
-            // Codemode group should not appear in groups
-            expect(apiWithCodemode.getGroups()).not.toContain('codemode')
-        })
-    })
-
-    // =========================================================================
-    // Method Invocation
-    // =========================================================================
-
-    describe('method invocation', () => {
-        it('should call handler with object params', async () => {
-            const result = await api.core['createEntry']!({ content: 'test' })
-            expect(result).toBeDefined()
-        })
-
-        it('should call handler with positional string arg', async () => {
-            const handler = vi.fn().mockResolvedValue({ success: true })
-            const tools = [createMockTool('create_entry', 'core', handler)]
-            const testApi = new JournalApi(tools)
-            await testApi.core['createEntry']!('My note')
-            expect(handler).toHaveBeenCalledWith({ content: 'My note' })
-        })
-
-        it('should call handler with positional number arg', async () => {
-            const handler = vi.fn().mockResolvedValue({ success: true })
-            const tools = [createMockTool('get_entry_by_id', 'core', handler)]
-            const testApi = new JournalApi(tools)
-            await testApi.core['getEntryById']!(42)
-            expect(handler).toHaveBeenCalledWith({ entry_id: 42 })
-        })
-
-        it('should pass through empty params for no-arg calls', async () => {
-            const handler = vi.fn().mockResolvedValue({ success: true })
-            const tools = [createMockTool('get_statistics', 'analytics', handler)]
-            const testApi = new JournalApi(tools)
-            await testApi.analytics['getStatistics']!()
-            expect(handler).toHaveBeenCalledWith({})
-        })
-
-        it('should handle boolean positional args mapped properly', async () => {
-            const handler = vi.fn().mockResolvedValue({ success: true })
-            const tools = [createMockTool('test_boolean', 'core', handler)] // assume no mapped param, fallback to arg
-            const testApi = new JournalApi(tools)
-            await testApi.core['testBoolean']!(true)
-            expect(handler).toHaveBeenCalledWith(true) // Fallback when no POSITIONAL_PARAM_MAP exists
-        })
-
-        it('should handle positional array mapping with length > 0 for a single arg', async () => {
-            const handler = vi.fn().mockResolvedValue({ success: true })
-            const tools = [createMockTool('search_by_date_range', 'search', handler)]
-            const testApi = new JournalApi(tools)
-            // searchByDateRange -> ['start_date', 'end_date']
-            // Passing 1 arg should map just 'start_date'
-            await testApi.search['searchByDateRange']!('2026-03-01')
-            expect(handler).toHaveBeenCalledWith({ start_date: '2026-03-01' })
-        })
-
-        it('should fallback to {content, query} for unmapped string args', async () => {
-            const handler = vi.fn().mockResolvedValue({ success: true })
-            const tools = [createMockTool('unknown_string_tool', 'core', handler)]
-            const testApi = new JournalApi(tools)
-            await testApi.core['unknownStringTool']!('some query string')
-            expect(handler).toHaveBeenCalledWith({
-                content: 'some query string',
-                query: 'some query string',
-            })
-        })
-
-        it('should return arg[0] if mapping is undefined for multi-arg calls', async () => {
-            const handler = vi.fn().mockResolvedValue({ success: true })
-            const tools = [createMockTool('unknown_multi_tool', 'core', handler)]
-            const testApi = new JournalApi(tools)
-            await testApi.core['unknownMultiTool']!('arg1', 'arg2', 'arg3')
-            expect(handler).toHaveBeenCalledWith('arg1')
-        })
-
-        it('should map multiple positional args correctly using Array mapping', async () => {
-            const handler = vi.fn().mockResolvedValue({ success: true })
-            const tools = [createMockTool('link_entries', 'relationships', handler)]
-            const testApi = new JournalApi(tools)
-            // POSITIONAL_PARAM_MAP['link_entries'] is ['from_entry_id', 'to_entry_id', 'relationship_type']
-            await testApi.relationships['linkEntries']!(1, 2, 'blocks', {
-                description: 'test options',
-            })
-            expect(handler).toHaveBeenCalledWith({
-                from_entry_id: 1,
-                to_entry_id: 2,
-                relationship_type: 'blocks',
-                description: 'test options',
-            })
-        })
-
-        it('should merge trailing options correctly for single string mapping with multi-args', async () => {
-            const handler = vi.fn().mockResolvedValue({ success: true })
-            const tools = [createMockTool('search_entries', 'search', handler)]
-            const testApi = new JournalApi(tools)
-            await testApi.search['searchEntries']!('query text', { limit: 10 })
-            expect(handler).toHaveBeenCalledWith({ query: 'query text', limit: 10 })
-        })
-
-        it('should merge trailing options object for multi-arg calls', async () => {
-            const handler = vi.fn().mockResolvedValue({ success: true })
-            const tools = [createMockTool('search_entries', 'search', handler)]
-            const testApi = new JournalApi(tools)
-            // search_entries maps first pos arg to "query"
-            await testApi.search['searchEntries']!('test', { tags: ['a'] })
-            expect(handler).toHaveBeenCalledWith({ query: 'test', tags: ['a'] })
-        })
-
-        it('should handle normalizeParams edge cases with arrays', async () => {
-            const handler = vi.fn().mockResolvedValue({ success: true })
-            const tools = [createMockTool('search_entries', 'search', handler)]
-            const testApi = new JournalApi(tools)
-            await testApi.search['searchEntries']!([
-                'array arg does not become query',
-                'or options merge in certain branches',
-            ])
-            // The first argument is an array, so positional checks might just pass it or fail gracefully. Wait, search_entries maps first arg to "query", but if arg is an array, it skips single-primitive checks and tries to merge if there is a positional param map string.
-            // For a single array arg, it just passes it through right?
-            expect(handler).toHaveBeenCalled()
-        })
-    })
-
-    // =========================================================================
-    // Aliases
-    // =========================================================================
-
-    describe('method aliases', () => {
-        it('should have core aliases', () => {
-            expect(api.core['create']).toBeDefined()
-            expect(api.core['create']).toBe(api.core['createEntry'])
-        })
-
-        it('should have search aliases', () => {
-            expect(api.search['find']).toBeDefined()
-            expect(api.search['find']).toBe(api.search['searchEntries'])
-        })
-
-        it('should have backup aliases', () => {
-            expect(api.backup['save']).toBeDefined()
-            expect(api.backup['save']).toBe(api.backup['backupJournal'])
-        })
-    })
-
-    // =========================================================================
-    // help()
-    // =========================================================================
-
-    describe('help()', () => {
-        it('should provide group-level help', async () => {
-            const help = (await api.core['help']!()) as {
-                group: string
-                methods: string[]
-                examples: string[]
-            }
-            expect(help.group).toBe('core')
-            expect(help.methods).toContain('createEntry')
-            expect(help.methods).not.toContain('help') // help itself is excluded
-        })
-
-        it('should include examples in help output', async () => {
-            const help = (await api.core['help']!()) as { examples: string[] }
-            expect(help.examples.length).toBeGreaterThan(0)
-            expect(help.examples.some((e) => e.includes('createEntry'))).toBe(true)
-        })
-    })
-
-    // =========================================================================
-    // getGroups / getGroupMethods
-    // =========================================================================
-
-    describe('getGroups', () => {
-        it('should return sorted group names', () => {
-            const groups = api.getGroups()
-            expect(groups.length).toBeGreaterThan(0)
-            expect(groups).toContain('core')
-            expect(groups).toContain('search')
-            // Verify sorted
-            const sorted = [...groups].sort()
-            expect(groups).toEqual(sorted)
-        })
-    })
-
-    describe('getGroupMethods', () => {
-        it('should return method names for a group', () => {
-            const methods = api.getGroupMethods('core')
-            expect(methods).toContain('createEntry')
-            expect(methods).not.toContain('help')
-        })
-
-        it('should return empty for unknown group', () => {
-            const methods = api.getGroupMethods('nonexistent' as 'core')
-            expect(methods).toEqual([])
-        })
-    })
-
-    // =========================================================================
-    // createSandboxBindings
-    // =========================================================================
-
-    describe('createSandboxBindings', () => {
-        it('should include all group namespaces', () => {
-            const bindings = api.createSandboxBindings()
-            expect(bindings['core']).toBeDefined()
-            expect(bindings['search']).toBeDefined()
-            expect(bindings['analytics']).toBeDefined()
-            expect(bindings['relationships']).toBeDefined()
-            expect(bindings['export']).toBeDefined()
-            expect(bindings['admin']).toBeDefined()
-            expect(bindings['github']).toBeDefined()
-            expect(bindings['backup']).toBeDefined()
-            expect(bindings['team']).toBeDefined()
-        })
-
-        it('should include top-level convenience aliases', () => {
-            const bindings = api.createSandboxBindings()
-            expect(typeof bindings['createEntry']).toBe('function')
-            expect(typeof bindings['getRecentEntries']).toBe('function')
-            expect(typeof bindings['searchEntries']).toBe('function')
-            expect(typeof bindings['getStatistics']).toBe('function')
-        })
-
-        it('should include top-level help()', () => {
-            const bindings = api.createSandboxBindings()
-            expect(typeof bindings['help']).toBe('function')
-        })
-
-        it('should return top-level help with groups and totalMethods', async () => {
-            const bindings = api.createSandboxBindings()
-            const help = (await (bindings['help'] as () => Promise<unknown>)()) as {
-                groups: string[]
-                totalMethods: number
-                usage: string
-            }
-            expect(help.groups.length).toBeGreaterThan(0)
-            expect(help.totalMethods).toBeGreaterThan(0)
-            expect(help.usage).toContain('mj.')
-        })
-    })
-})
-
-// =============================================================================
-// createJournalApi factory
-// =============================================================================
-
-describe('createJournalApi', () => {
-    it('should create a JournalApi instance', () => {
-        const api = createJournalApi(createMinimalToolSet())
-        expect(api).toBeInstanceOf(JournalApi)
-    })
-
-    it('should work identically to constructor', () => {
-        const tools = createMinimalToolSet()
-        const api1 = new JournalApi(tools)
-        const api2 = createJournalApi(tools)
-        expect(api1.getGroups()).toEqual(api2.getGroups())
-    })
-})