memory-journal-mcp 6.1.2 → 6.2.1

package/tests/codemode/auto-return.test.ts

@@ -1,167 +0,0 @@
-/**
- * Tests for Code Mode auto-return transform
- */
-
-import { describe, it, expect } from 'vitest'
-import { transformAutoReturn } from '../../src/codemode/auto-return.js'
-
-describe('transformAutoReturn', () => {
-    describe('single expressions', () => {
-        it('should prepend return to a bare function call', () => {
-            expect(transformAutoReturn('mj.help()')).toBe('return mj.help()')
-        })
-
-        it('should prepend return to an await expression', () => {
-            expect(transformAutoReturn('await mj.core.recent()')).toBe(
-                'return await mj.core.recent()'
-            )
-        })
-
-        it('should prepend return to a variable reference', () => {
-            expect(transformAutoReturn('result')).toBe('return result')
-        })
-
-        it('should prepend return to a numeric literal', () => {
-            expect(transformAutoReturn('42')).toBe('return 42')
-        })
-
-        it('should prepend return to a string literal', () => {
-            expect(transformAutoReturn('"hello"')).toBe('return "hello"')
-        })
-
-        it('should prepend return to a method chain', () => {
-            expect(transformAutoReturn('mj.search.searchEntries({ query: "test" })')).toBe(
-                'return mj.search.searchEntries({ query: "test" })'
-            )
-        })
-    })
-
-    describe('multi-statement code', () => {
-        it('should only prepend return to the last statement (semicolon-separated)', () => {
-            const code = 'const r = await mj.core.recent(); r'
-            const result = transformAutoReturn(code)
-            expect(result).toBe('const r = await mj.core.recent();\nreturn r')
-        })
-
-        it('should only prepend return to the last statement (newline-separated)', () => {
-            const code = 'const r = await mj.core.recent()\nr'
-            const result = transformAutoReturn(code)
-            // Split preserves the newline separator, plus adds \n before return
-            expect(result).toBe('const r = await mj.core.recent()\n\nreturn r')
-        })
-
-        it('should handle multi-line workflow ending with expression', () => {
-            const code = [
-                'const search = await mj.search.searchEntries({ query: "test" })',
-                'const stats = await mj.analytics.getStatistics()',
-                '{ search, stats }',
-            ].join('\n')
-            const result = transformAutoReturn(code)
-            // `{ search, stats }` starts with `{` — ambiguous (block vs object literal)
-            // so the heuristic correctly leaves it unreturned (safe default).
-            // Users should use `return { search, stats }` explicitly for object literals.
-            expect(result).toBe(code)
-        })
-
-        it('should return last expression when not ambiguous with a block', () => {
-            const code = [
-                'const search = await mj.search.searchEntries({ query: "test" })',
-                'const stats = await mj.analytics.getStatistics()',
-                'search.entries.length',
-            ].join('\n')
-            const result = transformAutoReturn(code)
-            expect(result).toContain('return search.entries.length')
-            expect(result).toContain('const search = await mj.search.searchEntries')
-        })
-    })
-
-    describe('statements that must NOT be returned', () => {
-        it('should not modify explicit return', () => {
-            expect(transformAutoReturn('return 42')).toBe('return 42')
-        })
-
-        it('should not modify throw', () => {
-            expect(transformAutoReturn('throw new Error("fail")')).toBe('throw new Error("fail")')
-        })
-
-        it('should not modify const declaration', () => {
-            expect(transformAutoReturn('const x = 42')).toBe('const x = 42')
-        })
-
-        it('should not modify let declaration', () => {
-            expect(transformAutoReturn('let x = 42')).toBe('let x = 42')
-        })
-
-        it('should not modify var declaration', () => {
-            expect(transformAutoReturn('var x = 42')).toBe('var x = 42')
-        })
-
-        it('should not modify if statement', () => {
-            expect(transformAutoReturn('if (true) { foo() }')).toBe('if (true) { foo() }')
-        })
-
-        it('should not modify for loop', () => {
-            expect(transformAutoReturn('for (const x of xs) { foo(x) }')).toBe(
-                'for (const x of xs) { foo(x) }'
-            )
-        })
-
-        it('should not modify while loop', () => {
-            expect(transformAutoReturn('while (true) { break }')).toBe('while (true) { break }')
-        })
-
-        it('should not modify try/catch', () => {
-            expect(transformAutoReturn('try { foo() } catch (e) { bar() }')).toBe(
-                'try { foo() } catch (e) { bar() }'
-            )
-        })
-
-        it('should not modify function declaration', () => {
-            expect(transformAutoReturn('function foo() { return 1 }')).toBe(
-                'function foo() { return 1 }'
-            )
-        })
-
-        it('should not modify class declaration', () => {
-            expect(transformAutoReturn('class Foo {}')).toBe('class Foo {}')
-        })
-
-        it('should not modify single-line comments', () => {
-            expect(transformAutoReturn('// comment')).toBe('// comment')
-        })
-    })
-
-    describe('edge cases', () => {
-        it('should return empty string unchanged', () => {
-            expect(transformAutoReturn('')).toBe('')
-        })
-
-        it('should return whitespace-only unchanged', () => {
-            expect(transformAutoReturn('   ')).toBe('   ')
-        })
-
-        it('should handle trailing whitespace', () => {
-            expect(transformAutoReturn('mj.help()   ')).toBe('return mj.help()')
-        })
-
-        it('should handle trailing semicolon', () => {
-            // Last statement after the final semicolon is empty, so no transform
-            const code = 'mj.help();'
-            const result = transformAutoReturn(code)
-            // The semicolon makes the "last statement" empty, so it falls
-            // back to returning code unchanged
-            expect(result).toBe('mj.help();')
-        })
-
-        it('should not return closing brace of a block', () => {
-            const code = 'if (true) {\n  foo()\n}'
-            expect(transformAutoReturn(code)).toBe(code)
-        })
-
-        it('should handle multi-statement ending with function call after semicolon', () => {
-            const code = 'const x = 1; mj.help()'
-            const result = transformAutoReturn(code)
-            expect(result).toBe('const x = 1;\nreturn mj.help()')
-        })
-    })
-})

package/tests/codemode/codemode-tool-handlers.test.ts

@@ -1,197 +0,0 @@
-/**
- * Code Mode Tool Handler Tests
- *
- * Tests for the mj_execute_code tool handler focusing on:
- * - Tool definition structure (name, schema, annotations)
- * - Security validation rejection (blocked patterns, empty code)
- * - Schema validation (missing params)
- *
- * Note: Actual sandbox code execution is tested via Playwright E2E tests.
- * In the vitest unit test environment, worker_threads can't resolve the
- * compiled worker-script.js (vitest runs TypeScript source directly), and
- * the VM sandbox has async Promise interop issues with vitest's module system.
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { getTools, callTool } from '../../src/handlers/tools/index.js'
-import { DatabaseAdapter } from '../../src/database/sqlite-adapter/index.js'
-
-describe('mj_execute_code Tool Handler', () => {
-    let db: DatabaseAdapter
-    const testDbPath = './test-codemode-handler.db'
-
-    beforeAll(async () => {
-        db = new DatabaseAdapter(testDbPath)
-        await db.initialize()
-    })
-
-    afterAll(() => {
-        db.close()
-        try {
-            const fs = require('node:fs')
-            if (fs.existsSync(testDbPath)) fs.unlinkSync(testDbPath)
-        } catch {
-            // Ignore cleanup errors
-        }
-    })
-
-    // =========================================================================
-    // Tool Definition
-    // =========================================================================
-
-    describe('tool definition', () => {
-        it('should be included in tool listing', () => {
-            const tools = getTools(db, null)
-            const names = tools.map((t) => (t as { name: string }).name)
-            expect(names).toContain('mj_execute_code')
-        })
-
-        it('should have inputSchema (no outputSchema — uses text response path)', () => {
-            const tools = getTools(db, null)
-            const codeTool = tools.find(
-                (t) => (t as { name: string }).name === 'mj_execute_code'
-            ) as { inputSchema: object; outputSchema?: object } | undefined
-            expect(codeTool?.inputSchema).toBeDefined()
-            expect(codeTool?.outputSchema).toBeUndefined()
-        })
-
-        it('should have correct description mentioning sandbox and API', () => {
-            const tools = getTools(db, null)
-            const codeTool = tools.find(
-                (t) => (t as { name: string }).name === 'mj_execute_code'
-            ) as { description: string } | undefined
-            expect(codeTool?.description).toContain('sandbox')
-            expect(codeTool?.description).toContain('mj.*')
-        })
-
-        it('should have annotations with readOnlyHint=false', () => {
-            const tools = getTools(db, null)
-            const codeTool = tools.find(
-                (t) => (t as { name: string }).name === 'mj_execute_code'
-            ) as { annotations?: { readOnlyHint?: boolean } } | undefined
-            expect(codeTool?.annotations?.readOnlyHint).toBe(false)
-        })
-
-        it('should total 61 tools across all groups', () => {
-            const tools = getTools(db, null)
-            expect(tools.length).toBe(61)
-        })
-    })
-
-    // =========================================================================
-    // Security Validation (pre-sandbox, synchronous path)
-    // =========================================================================
-
-    describe('security validation', () => {
-        it('should reject code with require()', async () => {
-            const result = (await callTool(
-                'mj_execute_code',
-                { code: 'const fs = require("fs")' },
-                db
-            )) as { success: boolean; error: string }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Security validation failed')
-        })
-
-        it('should reject code with process access', async () => {
-            const result = (await callTool('mj_execute_code', { code: 'process.exit(1)' }, db)) as {
-                success: boolean
-                error: string
-            }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Security validation failed')
-        })
-
-        it('should reject code with dynamic import', async () => {
-            const result = (await callTool(
-                'mj_execute_code',
-                { code: 'await import("os")' },
-                db
-            )) as { success: boolean; error: string }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Security validation failed')
-        })
-
-        it('should reject code with eval()', async () => {
-            const result = (await callTool(
-                'mj_execute_code',
-                { code: 'eval("alert(1)")' },
-                db
-            )) as { success: boolean; error: string }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Security validation failed')
-        })
-
-        it('should reject code with Function constructor', async () => {
-            const result = (await callTool(
-                'mj_execute_code',
-                { code: 'new Function ("return 1")' },
-                db
-            )) as { success: boolean; error: string }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Security validation failed')
-        })
-
-        it('should reject code with __proto__ access', async () => {
-            const result = (await callTool(
-                'mj_execute_code',
-                { code: 'const x = {}.__proto__' },
-                db
-            )) as { success: boolean; error: string }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Security validation failed')
-        })
-
-        it('should reject code with child_process', async () => {
-            const result = (await callTool(
-                'mj_execute_code',
-                { code: 'child_process.exec("whoami")' },
-                db
-            )) as { success: boolean; error: string }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Security validation failed')
-        })
-
-        it('should reject code with fs access', async () => {
-            const result = (await callTool(
-                'mj_execute_code',
-                { code: 'fs.readFileSync("/etc/passwd")' },
-                db
-            )) as { success: boolean; error: string }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Security validation failed')
-        })
-    })
-
-    // =========================================================================
-    // Schema Validation (pre-sandbox, Zod parse path)
-    // =========================================================================
-
-    describe('schema validation', () => {
-        it('should reject missing code parameter', async () => {
-            const result = (await callTool('mj_execute_code', {}, db)) as {
-                success: boolean
-                error?: string
-            }
-
-            expect(result.success).toBe(false)
-        })
-
-        it('should reject empty string code', async () => {
-            const result = (await callTool('mj_execute_code', { code: '' }, db)) as {
-                success: boolean
-                error?: string
-            }
-
-            expect(result.success).toBe(false)
-        })
-    })
-})

package/tests/codemode/sandbox-factory.test.ts

@@ -1,152 +0,0 @@
-/**
- * Sandbox Factory Tests
- *
- * Tests for the sandbox mode selection factory:
- * - Default mode management
- * - VM and Worker sandbox creation
- * - Pool creation
- * - Mode info
- * - Available modes listing
- */
-
-import { describe, it, expect, afterEach } from 'vitest'
-import {
-    setDefaultSandboxMode,
-    getDefaultSandboxMode,
-    getAvailableSandboxModes,
-    createSandbox,
-    createSandboxPool,
-    getSandboxModeInfo,
-} from '../../src/codemode/index.js'
-
-describe('Sandbox Factory', () => {
-    // Reset to default after each test
-    afterEach(() => {
-        setDefaultSandboxMode('worker')
-    })
-
-    // =========================================================================
-    // Default Mode
-    // =========================================================================
-
-    describe('default mode', () => {
-        it('should default to worker mode', () => {
-            expect(getDefaultSandboxMode()).toBe('worker')
-        })
-
-        it('should allow setting to vm mode', () => {
-            setDefaultSandboxMode('vm')
-            expect(getDefaultSandboxMode()).toBe('vm')
-        })
-
-        it('should allow setting back to worker mode', () => {
-            setDefaultSandboxMode('vm')
-            setDefaultSandboxMode('worker')
-            expect(getDefaultSandboxMode()).toBe('worker')
-        })
-    })
-
-    // =========================================================================
-    // Available Modes
-    // =========================================================================
-
-    describe('getAvailableSandboxModes', () => {
-        it('should return both vm and worker modes', () => {
-            const modes = getAvailableSandboxModes()
-            expect(modes).toContain('vm')
-            expect(modes).toContain('worker')
-            expect(modes).toHaveLength(2)
-        })
-    })
-
-    // =========================================================================
-    // Sandbox Creation
-    // =========================================================================
-
-    describe('createSandbox', () => {
-        it('should create a VM sandbox when mode is vm', () => {
-            const sandbox = createSandbox('vm')
-            expect(sandbox).toBeDefined()
-            expect(typeof sandbox.execute).toBe('function')
-        })
-
-        it('should create a Worker sandbox when mode is worker', () => {
-            const sandbox = createSandbox('worker')
-            expect(sandbox).toBeDefined()
-            expect(typeof sandbox.execute).toBe('function')
-        })
-
-        it('should use default mode when not specified', () => {
-            setDefaultSandboxMode('vm')
-            const sandbox = createSandbox()
-            expect(sandbox).toBeDefined()
-        })
-
-        it('should throw for unknown mode', () => {
-            expect(() => createSandbox('unknown' as 'vm')).toThrow('Unknown sandbox mode')
-        })
-    })
-
-    // =========================================================================
-    // Pool Creation
-    // =========================================================================
-
-    describe('createSandboxPool', () => {
-        it('should create a VM pool when mode is vm', () => {
-            const pool = createSandboxPool('vm')
-            expect(pool).toBeDefined()
-            expect(typeof pool.execute).toBe('function')
-            expect(typeof pool.getActiveCount).toBe('function')
-            expect(pool.poolId).toBeDefined()
-        })
-
-        it('should create a Worker pool when mode is worker', () => {
-            const pool = createSandboxPool('worker')
-            expect(pool).toBeDefined()
-            expect(typeof pool.execute).toBe('function')
-            expect(pool.poolId).toBeDefined()
-        })
-
-        it('should use default mode when not specified', () => {
-            setDefaultSandboxMode('vm')
-            const pool = createSandboxPool()
-            expect(pool).toBeDefined()
-        })
-
-        it('should throw for unknown mode', () => {
-            expect(() => createSandboxPool('invalid' as 'vm')).toThrow('Unknown sandbox mode')
-        })
-    })
-
-    // =========================================================================
-    // Mode Info
-    // =========================================================================
-
-    describe('getSandboxModeInfo', () => {
-        it('should return VM info', () => {
-            const info = getSandboxModeInfo('vm')
-            expect(info.mode).toBe('vm')
-            expect(info.securityLevel).toBe('basic')
-            expect(info.description).toContain('VM-based')
-            expect(info.isolation).toContain('vm.createContext')
-        })
-
-        it('should return Worker info', () => {
-            const info = getSandboxModeInfo('worker')
-            expect(info.mode).toBe('worker')
-            expect(info.securityLevel).toBe('production')
-            expect(info.description).toContain('Worker-thread')
-            expect(info.isolation).toContain('V8 isolate')
-        })
-
-        it('should use default mode when not specified', () => {
-            setDefaultSandboxMode('vm')
-            const info = getSandboxModeInfo()
-            expect(info.mode).toBe('vm')
-        })
-
-        it('should throw for unknown mode', () => {
-            expect(() => getSandboxModeInfo('bad' as 'vm')).toThrow('Unknown sandbox mode')
-        })
-    })
-})