mcp-memory-keeper 0.12.1 → 0.13.0

package/dist/__tests__/e2e/server-e2e.test.js

@@ -0,0 +1,341 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/**
+ * End-to-end tests for the MCP Memory Keeper server.
+ *
+ * These tests spawn the actual server process over stdio, send real MCP
+ * protocol messages, and validate the responses. Unlike integration tests
+ * that instantiate internal classes directly, these exercise the full stack:
+ * transport → protocol → handler → database → response.
+ *
+ * @see https://github.com/mkreyman/mcp-memory-keeper/issues/33
+ */
+// Valid JSON Schema types per the spec
+const VALID_JSON_SCHEMA_TYPES = new Set([
+    'string',
+    'number',
+    'integer',
+    'boolean',
+    'array',
+    'object',
+    'null',
+]);
+let serverProcess = null;
+let tempDir;
+let msgId = 0;
+let outputBuffer = '';
+/** Send a JSON-RPC message to the server and wait for a response with the matching id. */
+function sendRequest(method, params = {}, timeoutMs = 5000) {
+    return new Promise((resolve, reject) => {
+        const id = ++msgId;
+        const timeout = setTimeout(() => {
+            reject(new Error(`Timeout waiting for response to ${method} (id=${id})`));
+        }, timeoutMs);
+        const onData = (data) => {
+            outputBuffer += data.toString();
+            const lines = outputBuffer.split('\n');
+            // Keep the last incomplete line in the buffer
+            outputBuffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const msg = JSON.parse(line);
+                    if (msg.id === id) {
+                        clearTimeout(timeout);
+                        serverProcess?.stdout?.removeListener('data', onData);
+                        resolve(msg);
+                    }
+                }
+                catch {
+                    // Not JSON, skip
+                }
+            }
+        };
+        serverProcess?.stdout?.on('data', onData);
+        serverProcess?.stdin?.write(JSON.stringify({ jsonrpc: '2.0', method, params, id }) + '\n');
+    });
+}
+/**
+ * Recursively validate a JSON Schema property definition.
+ * Returns an array of human-readable violation strings.
+ */
+function validateSchemaProperty(prop, path, toolName) {
+    const violations = [];
+    // Every property should have a type
+    if (!prop.type) {
+        violations.push(`${toolName}: ${path} — missing 'type'`);
+        return violations; // Can't validate further without type
+    }
+    // Type must be a valid JSON Schema type
+    if (!VALID_JSON_SCHEMA_TYPES.has(prop.type)) {
+        violations.push(`${toolName}: ${path} — invalid type '${prop.type}'`);
+    }
+    // Arrays must have items
+    if (prop.type === 'array' && !prop.items) {
+        violations.push(`${toolName}: ${path} — type 'array' missing 'items'`);
+    }
+    // If enum is present, values should match the declared type
+    if (prop.enum && prop.type) {
+        for (const val of prop.enum) {
+            if (prop.type === 'string' && typeof val !== 'string') {
+                violations.push(`${toolName}: ${path} — enum value '${val}' is not a string`);
+            }
+            if (prop.type === 'number' && typeof val !== 'number') {
+                violations.push(`${toolName}: ${path} — enum value '${val}' is not a number`);
+            }
+        }
+    }
+    // Required must reference existing properties
+    if (prop.type === 'object' && prop.required && prop.properties) {
+        for (const req of prop.required) {
+            if (!(req in prop.properties)) {
+                violations.push(`${toolName}: ${path} — required field '${req}' not found in properties`);
+            }
+        }
+    }
+    // Recurse into object properties
+    if (prop.type === 'object' && prop.properties) {
+        for (const [key, value] of Object.entries(prop.properties)) {
+            violations.push(...validateSchemaProperty(value, `${path}.${key}`, toolName));
+        }
+    }
+    // Recurse into array items
+    if (prop.type === 'array' && prop.items && typeof prop.items === 'object') {
+        violations.push(...validateSchemaProperty(prop.items, `${path}.items`, toolName));
+    }
+    return violations;
+}
+(0, globals_1.describe)('MCP Server E2E Tests', () => {
+    (0, globals_1.beforeAll)(async () => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-e2e-'));
+        serverProcess = (0, child_process_1.spawn)('node', [path.join(__dirname, '../../../dist/index.js')], {
+            env: { ...process.env, DATA_DIR: tempDir },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        if (global.testProcesses) {
+            global.testProcesses.push(serverProcess);
+        }
+        // Initialize the MCP session
+        const initResponse = await sendRequest('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'e2e-test', version: '1.0.0' },
+        });
+        (0, globals_1.expect)(initResponse.result).toHaveProperty('protocolVersion');
+        // Send initialized notification (no response expected)
+        serverProcess?.stdin?.write(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }) + '\n');
+        // Brief pause for server to process the notification
+        await new Promise(resolve => setTimeout(resolve, 200));
+    }, 10000);
+    (0, globals_1.afterAll)(async () => {
+        if (serverProcess && !serverProcess.killed) {
+            serverProcess.kill('SIGTERM');
+            await new Promise(resolve => {
+                const timeout = setTimeout(() => {
+                    serverProcess?.kill('SIGKILL');
+                    resolve();
+                }, 3000);
+                serverProcess?.on('exit', () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+            });
+            serverProcess?.removeAllListeners();
+        }
+        serverProcess = null;
+        try {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    });
+    // ─── ListTools Schema Validation ────────────────────────────────────
+    (0, globals_1.describe)('tools/list — schema validation', () => {
+        let tools;
+        (0, globals_1.beforeAll)(async () => {
+            const response = await sendRequest('tools/list');
+            (0, globals_1.expect)(response.result).toHaveProperty('tools');
+            tools = response.result.tools;
+        });
+        (0, globals_1.it)('should return a non-empty list of tools', () => {
+            (0, globals_1.expect)(tools.length).toBeGreaterThan(0);
+        });
+        (0, globals_1.it)('every tool should have name, description, and inputSchema', () => {
+            for (const tool of tools) {
+                (0, globals_1.expect)(tool).toHaveProperty('name');
+                (0, globals_1.expect)(tool).toHaveProperty('description');
+                (0, globals_1.expect)(tool).toHaveProperty('inputSchema');
+                (0, globals_1.expect)(typeof tool.name).toBe('string');
+                (0, globals_1.expect)(typeof tool.description).toBe('string');
+                (0, globals_1.expect)(tool.name.length).toBeGreaterThan(0);
+                (0, globals_1.expect)(tool.description.length).toBeGreaterThan(0);
+            }
+        });
+        (0, globals_1.it)('every tool name should follow the context_ convention', () => {
+            for (const tool of tools) {
+                (0, globals_1.expect)(tool.name).toMatch(/^context_[a-z_]+$/);
+            }
+        });
+        (0, globals_1.it)('every inputSchema should be type object with properties', () => {
+            for (const tool of tools) {
+                (0, globals_1.expect)(tool.inputSchema.type).toBe('object');
+                (0, globals_1.expect)(tool.inputSchema).toHaveProperty('properties');
+                (0, globals_1.expect)(typeof tool.inputSchema.properties).toBe('object');
+            }
+        });
+        (0, globals_1.it)('no tool names should be duplicated', () => {
+            const names = tools.map((t) => t.name);
+            (0, globals_1.expect)(new Set(names).size).toBe(names.length);
+        });
+        (0, globals_1.it)('every array property should have items declared (issue #33)', () => {
+            const violations = [];
+            for (const tool of tools) {
+                violations.push(...validateSchemaProperty(tool.inputSchema, 'inputSchema', tool.name).filter(v => v.includes("missing 'items'")));
+            }
+            (0, globals_1.expect)(violations).toHaveLength(0);
+        });
+        (0, globals_1.it)('every property type should be a valid JSON Schema type', () => {
+            const violations = [];
+            for (const tool of tools) {
+                violations.push(...validateSchemaProperty(tool.inputSchema, 'inputSchema', tool.name).filter(v => v.includes('invalid type')));
+            }
+            (0, globals_1.expect)(violations).toHaveLength(0);
+        });
+        (0, globals_1.it)('every required field should reference an existing property', () => {
+            const violations = [];
+            for (const tool of tools) {
+                violations.push(...validateSchemaProperty(tool.inputSchema, 'inputSchema', tool.name).filter(v => v.includes('not found in properties')));
+            }
+            (0, globals_1.expect)(violations).toHaveLength(0);
+        });
+        (0, globals_1.it)('enum values should match their declared type', () => {
+            const violations = [];
+            for (const tool of tools) {
+                violations.push(...validateSchemaProperty(tool.inputSchema, 'inputSchema', tool.name).filter(v => v.includes('enum value')));
+            }
+            (0, globals_1.expect)(violations).toHaveLength(0);
+        });
+        (0, globals_1.it)('full schema validation should find zero violations across all tools', () => {
+            const allViolations = [];
+            for (const tool of tools) {
+                allViolations.push(...validateSchemaProperty(tool.inputSchema, 'inputSchema', tool.name));
+            }
+            if (allViolations.length > 0) {
+                throw new Error(`Found ${allViolations.length} schema violation(s):\n${allViolations.map(v => `  ${v}`).join('\n')}`);
+            }
+        });
+    });
+    // ─── Tool Call Smoke Tests ──────────────────────────────────────────
+    (0, globals_1.describe)('tools/call — smoke tests', () => {
+        (0, globals_1.it)('should save and retrieve a context item', async () => {
+            // Save
+            const saveResponse = await sendRequest('tools/call', {
+                name: 'context_save',
+                arguments: {
+                    key: 'e2e_test_key',
+                    value: 'e2e_test_value',
+                    category: 'note',
+                },
+            });
+            (0, globals_1.expect)(saveResponse.result).toHaveProperty('content');
+            const saveText = saveResponse.result.content[0].text;
+            (0, globals_1.expect)(saveText).toContain('e2e_test_key');
+            // Retrieve
+            const getResponse = await sendRequest('tools/call', {
+                name: 'context_get',
+                arguments: { key: 'e2e_test_key' },
+            });
+            (0, globals_1.expect)(getResponse.result).toHaveProperty('content');
+            const getResult = JSON.parse(getResponse.result.content[0].text);
+            (0, globals_1.expect)(getResult.items).toBeDefined();
+            (0, globals_1.expect)(getResult.items.length).toBeGreaterThan(0);
+            (0, globals_1.expect)(getResult.items[0].value).toBe('e2e_test_value');
+        });
+        (0, globals_1.it)('should search for saved items', async () => {
+            const response = await sendRequest('tools/call', {
+                name: 'context_search',
+                arguments: { query: 'e2e_test' },
+            });
+            (0, globals_1.expect)(response.result).toHaveProperty('content');
+            const text = response.result.content[0].text;
+            (0, globals_1.expect)(text).toContain('e2e_test');
+        });
+        (0, globals_1.it)('should return status', async () => {
+            const response = await sendRequest('tools/call', {
+                name: 'context_status',
+                arguments: {},
+            });
+            (0, globals_1.expect)(response.result).toHaveProperty('content');
+            const text = response.result.content[0].text;
+            // Status response contains session info regardless of format
+            (0, globals_1.expect)(text.length).toBeGreaterThan(0);
+            (0, globals_1.expect)(text).toMatch(/session|item/i);
+        });
+        (0, globals_1.it)('should reject unknown tools with an error', async () => {
+            const response = await sendRequest('tools/call', {
+                name: 'nonexistent_tool',
+                arguments: {},
+            });
+            // MCP SDK wraps handler errors
+            (0, globals_1.expect)(response.error || response.result?.isError).toBeTruthy();
+        });
+        (0, globals_1.it)('should handle missing required arguments gracefully', async () => {
+            const response = await sendRequest('tools/call', {
+                name: 'context_save',
+                arguments: {},
+            });
+            (0, globals_1.expect)(response.result).toHaveProperty('content');
+            const text = response.result.content[0].text;
+            // Should return an error message, not crash
+            (0, globals_1.expect)(text.toLowerCase()).toMatch(/error|required|key/i);
+        });
+    });
+    // ─── Tool Profile Filtering ────────────────────────────────────────
+    (0, globals_1.describe)('tool profile filtering', () => {
+        (0, globals_1.it)('default profile should expose all tools', async () => {
+            const response = await sendRequest('tools/list');
+            // Default is "full" profile with 38 tools
+            (0, globals_1.expect)(response.result.tools.length).toBe(38);
+        });
+    });
+});

package/dist/__tests__/integration/issue33-array-items-schema.test.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Issue #33: full tool profile exposes a schema that breaks some OpenAI-compatible providers
+ *
+ * Some providers reject tool schemas where an array property lacks an `items` declaration.
+ * Per JSON Schema spec, `items` is required for `type: 'array'` to fully describe the schema.
+ *
+ * This test scans src/index.ts and verifies that every property with `type: 'array'`
+ * has an `items` declaration within the same schema block.
+ *
+ * @see https://github.com/mkreyman/mcp-memory-keeper/issues/33
+ */
+/**
+ * Scan the source for tool definitions and find array properties missing `items`.
+ * Skips block comments to avoid false positives from commented-out schemas.
+ * Line numbers refer to the original source file for accurate debugging.
+ */
+function findArrayPropertiesMissingItems(src) {
+    const violations = [];
+    const lines = src.split('\n');
+    let currentTool = '';
+    let inBlockComment = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Track block comment state
+        if (inBlockComment) {
+            if (line.includes('*/')) {
+                inBlockComment = false;
+            }
+            continue;
+        }
+        if (line.includes('/*')) {
+            inBlockComment = true;
+            if (line.includes('*/')) {
+                inBlockComment = false;
+            }
+            continue;
+        }
+        // Track which tool we're inside
+        const toolMatch = line.match(/name:\s*'(context_[a-z_]+)'/);
+        if (toolMatch) {
+            currentTool = toolMatch[1];
+        }
+        // Find array type declarations
+        if (!line.match(/type:\s*'array'/))
+            continue;
+        if (!currentTool)
+            continue;
+        // Find the property name (check current line first for single-line declarations)
+        let propertyName = '(unknown)';
+        const currentLinePropMatch = line.match(/(\w+)\s*:\s*\{/);
+        if (currentLinePropMatch) {
+            propertyName = currentLinePropMatch[1];
+        }
+        else {
+            for (let j = i - 1; j >= Math.max(0, i - 5); j--) {
+                const propMatch = lines[j].match(/(\w+)\s*:\s*\{/);
+                if (propMatch) {
+                    propertyName = propMatch[1];
+                    break;
+                }
+            }
+        }
+        // Check current line first (handles single-line array declarations)
+        let foundItems = line.includes('items');
+        let depth = 0;
+        for (let j = i + 1; !foundItems && j < Math.min(lines.length, i + 50); j++) {
+            const fwdLine = lines[j];
+            for (const ch of fwdLine) {
+                if (ch === '{')
+                    depth++;
+                if (ch === '}')
+                    depth--;
+            }
+            if (fwdLine.match(/^\s*items\s*:/)) {
+                foundItems = true;
+                break;
+            }
+            if (depth < 0)
+                break;
+        }
+        if (!foundItems) {
+            violations.push({
+                tool: currentTool,
+                property: propertyName,
+                line: i + 1,
+            });
+        }
+    }
+    return violations;
+}
+(0, globals_1.describe)('Issue #33: Array properties must declare items', () => {
+    const indexPath = path.join(__dirname, '..', '..', 'index.ts');
+    const src = fs.readFileSync(indexPath, 'utf-8');
+    (0, globals_1.it)('should find tool definitions in source', () => {
+        const toolNames = src.match(/name:\s*'context_[a-z_]+'/g);
+        (0, globals_1.expect)(toolNames).not.toBeNull();
+        (0, globals_1.expect)(toolNames.length).toBeGreaterThan(0);
+    });
+    (0, globals_1.it)('every array property in every tool schema must have an items declaration', () => {
+        const violations = findArrayPropertiesMissingItems(src);
+        (0, globals_1.expect)(violations).toHaveLength(0);
+    });
+    (0, globals_1.it)('context_delegate.input.insights specifically must have items', () => {
+        const lines = src.split('\n');
+        let inDelegate = false;
+        let insightsLine = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].match(/name:\s*'context_delegate'/)) {
+                inDelegate = true;
+            }
+            if (inDelegate &&
+                i > 0 &&
+                lines[i].match(/name:\s*'context_/) &&
+                !lines[i].match(/context_delegate/)) {
+                break;
+            }
+            if (inDelegate && lines[i].match(/insights\s*:\s*\{/)) {
+                insightsLine = i;
+                break;
+            }
+        }
+        (0, globals_1.expect)(insightsLine).toBeGreaterThan(-1);
+        const insightsBlock = lines.slice(insightsLine, insightsLine + 5).join('\n');
+        (0, globals_1.expect)(insightsBlock).toContain("type: 'array'");
+        (0, globals_1.expect)(insightsBlock).toMatch(/items\s*:/);
+    });
+});