@cybermem/mcp 0.6.10 → 0.8.1

package/dist/index.js

@@ -1,35 +1,71 @@
 #!/usr/bin/env node
 "use strict";
+/**
+ * CyberMem MCP Server
+ *
+ * MCP server for AI agents to interact with CyberMem memory system.
+ * Uses openmemory-js SDK directly (no HTTP, embedded SQLite).
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const axios_1 = __importDefault(require("axios"));
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 const cors_1 = __importDefault(require("cors"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const express_1 = __importDefault(require("express"));
+const openmemory_js_1 = require("openmemory-js");
+const zod_1 = require("zod");
+const auth_js_1 = require("./auth.js");
 dotenv_1.default.config();
-// Parse CLI args for remote mode
+// Handle CLI auth commands first
 const args = process.argv.slice(2);
-const getArg = (name) => {
-    const idx = args.indexOf(name);
-    return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
-};
-const cliUrl = getArg("--url");
-const cliApiKey = getArg("--api-key");
-const cliClientName = getArg("--client-name");
-// Use CLI args first, then env, then defaults
-// Default to local CyberMem backend (via Traefik on port 8626)
-const API_URL = cliUrl || process.env.CYBERMEM_URL || "http://localhost:8626/memory";
-const API_KEY = cliApiKey || process.env.OM_API_KEY || "";
-// Track client name per session
-let currentClientName = cliClientName || "cybermem-mcp";
-// CyberMem Agent Protocol - instructions sent to clients on handshake
-const CYBERMEM_INSTRUCTIONS = `CyberMem is a persistent context daemon for AI agents.
+if (args.includes("--login")) {
+    (0, auth_js_1.login)()
+        .then(() => process.exit(0))
+        .catch((err) => {
+        console.error("Login failed:", err.message);
+        process.exit(1);
+    });
+}
+else if (args.includes("--logout")) {
+    (0, auth_js_1.logout)();
+    process.exit(0);
+}
+else if (args.includes("--status")) {
+    (0, auth_js_1.showStatus)();
+    process.exit(0);
+}
+else {
+    // Continue with MCP server startup
+    startServer();
+}
+async function startServer() {
+    // Parse CLI args
+    const getArg = (name) => {
+        const idx = args.indexOf(name);
+        return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
+    };
+    const cliClientName = getArg("--client-name");
+    // Track client name per session (used in tags)
+    const currentClientName = cliClientName || "cybermem-mcp";
+    // Configure openmemory-js SDK data path
+    // Use ~/.cybermem/data/ so db-exporter can mount it
+    const homedir = process.env.HOME || process.env.USERPROFILE || "";
+    const dataDir = `${homedir}/.cybermem/data`;
+    process.env.OM_DB_PATH = `${dataDir}/openmemory.sqlite`;
+    // Ensure data directory exists
+    const fs = require("fs");
+    try {
+        fs.mkdirSync(dataDir, { recursive: true });
+    }
+    catch { }
+    // Initialize openmemory-js SDK (embedded SQLite)
+    const memory = new openmemory_js_1.Memory();
+    // CyberMem Agent Protocol - instructions sent to clients on handshake
+    const CYBERMEM_INSTRUCTIONS = `CyberMem is a persistent context daemon for AI agents.
 
 PROTOCOL:
 1. On session start: call query_memory("user context profile") to load persona
@@ -48,240 +84,152 @@ INTEGRITY RULES:
 - Sync before critical decisions
 - Last-write-wins for conflicts
 
-For full protocol: https://cybermem.dev/docs/agent-protocol`;
-// Short protocol reminder for tool descriptions (derived from main instructions)
-const PROTOCOL_REMINDER = "CyberMem Protocol: Store FULL content (no summaries), always include tags [topic, year, source:client-name]. Query 'user context profile' on session start.";
-const server = new index_js_1.Server({
-    name: "cybermem",
-    version: "0.6.8",
-}, {
-    capabilities: {
-        tools: {},
-        resources: {}, // Enable resources for protocol document
-    },
-    instructions: CYBERMEM_INSTRUCTIONS,
-});
-// Register resources handler for protocol document
-server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => ({
-    resources: [
-        {
-            uri: "cybermem://protocol",
-            name: "CyberMem Agent Protocol",
-            description: "Instructions for AI agents using CyberMem memory system",
-            mimeType: "text/plain",
+For full protocol: https://docs.cybermem.dev/agent-protocol`;
+    // Short protocol reminder for tool descriptions
+    const PROTOCOL_REMINDER = "CyberMem Protocol: Store FULL content (no summaries), always include tags [topic, year, source:client-name]. Query 'user context profile' on session start.";
+    // Create McpServer instance
+    const server = new mcp_js_1.McpServer({
+        name: "cybermem",
+        version: "0.8.0",
+    }, {
+        capabilities: {
+            tools: {},
+            resources: {},
         },
-    ],
-}));
-server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
-    if (request.params.uri === "cybermem://protocol") {
+        instructions: CYBERMEM_INSTRUCTIONS,
+    });
+    // Register resources
+    server.registerResource("CyberMem Agent Protocol", "cybermem://protocol", {
+        description: "Instructions for AI agents using CyberMem memory system",
+        mimeType: "text/plain",
+    }, async () => ({
+        contents: [
+            {
+                uri: "cybermem://protocol",
+                mimeType: "text/plain",
+                text: CYBERMEM_INSTRUCTIONS,
+            },
+        ],
+    }));
+    // Register tools using openmemory-js SDK
+    server.registerTool("add_memory", {
+        description: `Store a new memory in CyberMem. ${PROTOCOL_REMINDER}`,
+        inputSchema: zod_1.z.object({
+            content: zod_1.z
+                .string()
+                .describe("Full content with all details - NO truncation or summarization"),
+            user_id: zod_1.z.string().optional(),
+            tags: zod_1.z
+                .array(zod_1.z.string())
+                .optional()
+                .describe("Always include [topic, year, source:your-client-name]"),
+        }),
+    }, async (args) => {
+        // Add source tag automatically
+        const tags = args.tags || [];
+        if (!tags.some((t) => t.startsWith("source:"))) {
+            tags.push(`source:${currentClientName}`);
+        }
+        const result = await memory.add(args.content, {
+            user_id: args.user_id,
+            tags,
+        });
         return {
-            contents: [
-                {
-                    uri: "cybermem://protocol",
-                    mimeType: "text/plain",
-                    text: CYBERMEM_INSTRUCTIONS,
-                },
-            ],
+            content: [{ type: "text", text: JSON.stringify(result) }],
         };
-    }
-    throw new Error(`Unknown resource: ${request.params.uri}`);
-});
-const tools = [
-    {
-        name: "add_memory",
-        description: `Store a new memory in CyberMem. ${PROTOCOL_REMINDER}`,
-        inputSchema: {
-            type: "object",
-            properties: {
-                content: {
-                    type: "string",
-                    description: "Full content with all details - NO truncation or summarization",
-                },
-                user_id: { type: "string" },
-                tags: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Always include [topic, year, source:your-client-name]",
-                },
-            },
-            required: ["content"],
-        },
-    },
-    {
-        name: "query_memory",
+    });
+    server.registerTool("query_memory", {
         description: `Search for relevant memories. On session start, call query_memory("user context profile") first.`,
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: { type: "string" },
-                k: { type: "number", default: 5 },
-            },
-            required: ["query"],
-        },
-    },
-    {
-        name: "list_memories",
-        description: "List recent memories",
-        inputSchema: {
-            type: "object",
-            properties: {
-                limit: { type: "number", default: 10 },
-            },
-        },
-    },
-    {
-        name: "delete_memory",
-        description: "Delete a memory by ID",
-        inputSchema: {
-            type: "object",
-            properties: {
-                id: { type: "string" },
-            },
-            required: ["id"],
-        },
-    },
-    {
-        name: "update_memory",
-        description: "Update a memory by ID",
-        inputSchema: {
-            type: "object",
-            properties: {
-                id: { type: "string" },
-                content: { type: "string" },
-                tags: { type: "array", items: { type: "string" } },
-                metadata: { type: "object" },
-            },
-            required: ["id"],
-        },
-    },
-];
-server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-    tools,
-}));
-// Create axios instance
-const apiClient = axios_1.default.create({
-    baseURL: API_URL,
-    headers: {
-        Authorization: `Bearer ${API_KEY}`,
-    },
-});
-// Helper to get client with context
-function getClient(customHeaders = {}) {
-    // Get client name from MCP protocol (sent during initialize) or fallback to CLI arg
-    const clientVersion = server.getClientVersion();
-    const clientName = customHeaders["X-Client-Name"] || clientVersion?.name || currentClientName;
-    return {
-        ...apiClient,
-        get: (url, config) => apiClient.get(url, {
-            ...config,
-            headers: { "X-Client-Name": clientName, ...config?.headers },
+        inputSchema: zod_1.z.object({
+            query: zod_1.z.string(),
+            k: zod_1.z.number().default(5),
         }),
-        post: (url, data, config) => apiClient.post(url, data, {
-            ...config,
-            headers: { "X-Client-Name": clientName, ...config?.headers },
-        }),
-        put: (url, data, config) => apiClient.put(url, data, {
-            ...config,
-            headers: { "X-Client-Name": clientName, ...config?.headers },
+    }, async (args) => {
+        const results = await memory.search(args.query, { limit: args.k });
+        return {
+            content: [{ type: "text", text: JSON.stringify(results) }],
+        };
+    });
+    server.registerTool("list_memories", {
+        description: "List recent memories",
+        inputSchema: zod_1.z.object({
+            limit: zod_1.z.number().default(10),
         }),
-        patch: (url, data, config) => apiClient.patch(url, data, {
-            ...config,
-            headers: { "X-Client-Name": clientName, ...config?.headers },
+    }, async (args) => {
+        // Use search with empty query to list recent
+        const results = await memory.search("", { limit: args.limit || 10 });
+        return {
+            content: [{ type: "text", text: JSON.stringify(results) }],
+        };
+    });
+    server.registerTool("delete_memory", {
+        description: "Delete a memory by ID",
+        inputSchema: zod_1.z.object({
+            id: zod_1.z.string(),
         }),
-        delete: (url, config) => apiClient.delete(url, {
-            ...config,
-            headers: { "X-Client-Name": clientName, ...config?.headers },
+    }, async (args) => {
+        // openmemory-js doesn't have delete by ID, use wipe for now
+        // TODO: Implement delete_by_id in SDK or via direct DB query
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Delete not yet implemented in SDK. Memory ID: ${args.id}`,
+                },
+            ],
+        };
+    });
+    server.registerTool("update_memory", {
+        description: "Update a memory by ID",
+        inputSchema: zod_1.z.object({
+            id: zod_1.z.string(),
+            content: zod_1.z.string().optional(),
+            tags: zod_1.z.array(zod_1.z.string()).optional(),
         }),
-    };
-}
-server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-        switch (name) {
-            case "add_memory": {
-                const response = await getClient().post("/add", args);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(response.data) }],
-                };
-            }
-            case "query_memory": {
-                const response = await getClient().post("/query", args);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(response.data) }],
-                };
-            }
-            case "list_memories": {
-                const limit = args?.limit || 10;
-                const response = await getClient().get(`/all?l=${limit}`);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(response.data) }],
-                };
-            }
-            case "delete_memory": {
-                const { id } = args;
-                await getClient().delete(`/${id}`);
-                return { content: [{ type: "text", text: `Memory ${id} deleted` }] };
-            }
-            case "update_memory": {
-                const { id, ...updates } = args;
-                const response = await getClient().patch(`/${id}`, updates);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(response.data) }],
-                };
-            }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
-    }
-    catch (error) {
+    }, async (args) => {
+        // TODO: Implement update in SDK
         return {
-            content: [{ type: "text", text: `Error: ${error.message}` }],
-            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Update not yet implemented in SDK. Memory ID: ${args.id}`,
+                },
+            ],
         };
-    }
-});
-async function run() {
-    const isSse = process.argv.includes("--sse") || !!process.env.PORT;
-    if (isSse) {
+    });
+    // Determine transport mode
+    const transportArg = args.find((arg) => arg === "--stdio" || arg === "--http");
+    const useHttp = transportArg === "--http" || args.includes("--port");
+    if (useHttp) {
+        // HTTP mode for testing/development
+        const port = parseInt(getArg("--port") || "3100", 10);
         const app = (0, express_1.default)();
         app.use((0, cors_1.default)());
-        const port = process.env.PORT || 8627;
-        let transport = null;
-        app.get("/sse", async (req, res) => {
-            // Extract client name from header
-            const clientName = req.headers["x-client-name"];
-            if (clientName) {
-                currentClientName = clientName;
-            }
-            transport = new sse_js_1.SSEServerTransport("/messages", res);
-            await server.connect(transport);
+        app.use(express_1.default.json());
+        app.get("/health", (_req, res) => {
+            res.json({ ok: true, version: "0.8.0", mode: "sdk" });
         });
-        app.post("/messages", async (req, res) => {
-            // Also check headers on messages
-            const clientName = req.headers["x-client-name"];
-            if (clientName) {
-                currentClientName = clientName;
-            }
-            if (transport) {
-                await transport.handlePostMessage(req, res);
-            }
-            else {
-                res.status(400).send("Session not established");
-            }
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            sessionIdGenerator: () => crypto.randomUUID(),
         });
-        app.listen(port, () => {
-            console.error(`CyberMem MCP Server running on SSE at http://localhost:${port}`);
-            console.error(`  - SSE endpoint: http://localhost:${port}/sse`);
-            console.error(`  - Message endpoint: http://localhost:${port}/messages`);
+        app.all("/mcp", async (req, res) => {
+            await transport.handleRequest(req, res, req.body);
+        });
+        app.all("/sse", async (req, res) => {
+            await transport.handleRequest(req, res, req.body);
+        });
+        server.connect(transport).then(() => {
+            app.listen(port, () => {
+                console.log(`CyberMem MCP (SDK mode) running on http://localhost:${port}`);
+                console.log("Health: /health | MCP: /mcp");
+            });
         });
     }
     else {
+        // STDIO mode (default for MCP clients)
         const transport = new stdio_js_1.StdioServerTransport();
-        await server.connect(transport);
-        console.error("CyberMem MCP Server running on stdio");
+        server.connect(transport).then(() => {
+            console.error("CyberMem MCP (SDK mode) connected via STDIO");
+        });
     }
 }
-run().catch((error) => {
-    console.error("Fatal error running server:", error);
-    process.exit(1);
-});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cybermem/mcp",
-  "version": "0.6.10",
-  "description": "CyberMem MCP Server (TypeScript)",
+  "version": "0.8.1",
+  "description": "CyberMem MCP Server - AI Memory with openmemory-js SDK",
   "main": "dist/index.js",
   "bin": {
     "cybermem-mcp": "./dist/index.js"
@@ -36,10 +36,11 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "axios": "^1.13.2",
     "cors": "^2.8.5",
     "dotenv": "^16.0.0",
-    "express": "^5.2.1"
+    "express": "^5.2.1",
+    "openmemory-js": "^1.3.2",
+    "zod": "^3.25.76"
   },
   "devDependencies": {
     "@types/cors": "^2.8.19",