@cybermem/mcp 0.6.10 → 0.8.3

package/dist/index.js

@@ -1,287 +1,259 @@
 #!/usr/bin/env node
 "use strict";
+/**
+ * CyberMem MCP Server
+ *
+ * Supports two modes:
+ * 1. Local/Server Mode (default): Uses openmemory-js SDK directly.
+ * 2. Remote Client Mode (with --url): Proxies requests to a remote CyberMem server via HTTP.
+ */
 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 streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 const axios_1 = __importDefault(require("axios"));
 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 {
+    startServer();
+}
+async function startServer() {
+    const getArg = (name) => {
+        const idx = args.indexOf(name);
+        return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
+    };
+    const cliClientName = getArg("--client-name") || "cybermem-mcp";
+    const cliUrl = getArg("--url");
+    const cliApiKey = getArg("--api-key");
+    // Protocol Instructions
+    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
-2. Store new insights immediately with add_memory - include FULL content, not summaries
-3. Refresh context: 6h for active topics, 24h for projects, 7d for insights
-4. Always include tags: [topic, year, source:your-client-name]
-5. Priority: CyberMem context > session context > training data
-
-MEMORY FORMAT:
-- content: Full text with all details, metrics, dates. NO truncation.
-- tags: Always include topic category + year + source:client-name
-
-INTEGRITY RULES:
-- Never overwrite without reading first
-- Always include metadata (tags, source)
-- 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",
-        },
-    ],
-}));
-server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
-    if (request.params.uri === "cybermem://protocol") {
-        return {
-            contents: [
-                {
-                    uri: "cybermem://protocol",
-                    mimeType: "text/plain",
-                    text: CYBERMEM_INSTRUCTIONS,
-                },
-            ],
-        };
-    }
-    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",
-        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" },
+1. On session start: call query_memory("user context profile")
+2. Store new insights immediately with add_memory (FULL content)
+3. Always include tags: [topic, year, source:your-client-name]
+For full protocol: https://docs.cybermem.dev/agent-protocol`;
+    const server = new mcp_js_1.McpServer({ name: "cybermem", version: "0.8.2" }, {
+        instructions: CYBERMEM_INSTRUCTIONS,
+    });
+    server.registerResource("CyberMem Agent Protocol", "cybermem://protocol", { description: "Instructions for AI agents", mimeType: "text/plain" }, async () => ({
+        contents: [
+            {
+                uri: "cybermem://protocol",
+                mimeType: "text/plain",
+                text: CYBERMEM_INSTRUCTIONS,
             },
-            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" },
+        ],
+    }));
+    // --- IMPLEMENTATION LOGIC ---
+    let memory = null;
+    let apiClient = null;
+    if (cliUrl) {
+        // REMOTE CLIENT MODE
+        console.error(`Connecting to remote CyberMem at ${cliUrl}`);
+        apiClient = axios_1.default.create({
+            baseURL: cliUrl,
+            headers: {
+                Authorization: `Bearer ${cliApiKey}`,
+                "X-Client-Name": cliClientName,
             },
-            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 },
-        }),
-        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 },
-        }),
-        patch: (url, data, config) => apiClient.patch(url, data, {
-            ...config,
-            headers: { "X-Client-Name": clientName, ...config?.headers },
-        }),
-        delete: (url, config) => apiClient.delete(url, {
-            ...config,
-            headers: { "X-Client-Name": clientName, ...config?.headers },
-        }),
+        });
+    }
+    else {
+        // LOCAL SDK MODE
+        const homedir = process.env.HOME || process.env.USERPROFILE || "";
+        // Default to ~/.cybermem/data if OM_DB_PATH not set
+        if (!process.env.OM_DB_PATH) {
+            process.env.OM_DB_PATH = `${homedir}/.cybermem/data/openmemory.sqlite`;
+        }
+        // Ensure directory exists
+        const fs = require("fs");
+        try {
+            const dbPath = process.env.OM_DB_PATH;
+            const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+            if (dir)
+                fs.mkdirSync(dir, { recursive: true });
+        }
+        catch { }
+        memory = new openmemory_js_1.Memory();
+    }
+    // Helper to add source tag
+    const addSourceTag = (tags = []) => {
+        if (!tags.some((t) => t.startsWith("source:")))
+            tags.push(`source:${cliClientName}`);
+        return tags;
     };
-}
-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}`);
+    // --- TOOLS ---
+    server.registerTool("add_memory", {
+        description: "Store a new memory. " + CYBERMEM_INSTRUCTIONS,
+        inputSchema: zod_1.z.object({
+            content: zod_1.z.string(),
+            user_id: zod_1.z.string().optional(),
+            tags: zod_1.z.array(zod_1.z.string()).optional(),
+        }),
+    }, async (args) => {
+        const tags = addSourceTag(args.tags);
+        if (cliUrl) {
+            const res = await apiClient.post("/add", { ...args, tags });
+            return { content: [{ type: "text", text: JSON.stringify(res.data) }] };
+        }
+        else {
+            const res = await memory.add(args.content, {
+                user_id: args.user_id,
+                tags,
+            });
+            return { content: [{ type: "text", text: JSON.stringify(res) }] };
+        }
+    });
+    server.registerTool("query_memory", {
+        description: "Search memories.",
+        inputSchema: zod_1.z.object({ query: zod_1.z.string(), k: zod_1.z.number().default(5) }),
+    }, async (args) => {
+        if (cliUrl) {
+            const res = await apiClient.post("/query", args);
+            return { content: [{ type: "text", text: JSON.stringify(res.data) }] };
+        }
+        else {
+            const res = await memory.search(args.query, { limit: args.k });
+            return { content: [{ type: "text", text: JSON.stringify(res) }] };
+        }
+    });
+    server.registerTool("list_memories", {
+        description: "List recent memories",
+        inputSchema: zod_1.z.object({ limit: zod_1.z.number().default(10) }),
+    }, async (args) => {
+        if (cliUrl) {
+            // Fallback to /query with empty string if /list not available, or use /all
+            // Old API had /all
+            try {
+                const res = await apiClient.get(`/all?limit=${args.limit}`);
                 return {
-                    content: [{ type: "text", text: JSON.stringify(response.data) }],
+                    content: [{ type: "text", text: JSON.stringify(res.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);
+            catch {
+                const res = await apiClient.post("/query", {
+                    query: "",
+                    k: args.limit,
+                });
                 return {
-                    content: [{ type: "text", text: JSON.stringify(response.data) }],
+                    content: [{ type: "text", text: JSON.stringify(res.data) }],
                 };
             }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
         }
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error: ${error.message}` }],
-            isError: true,
-        };
-    }
-});
-async function run() {
-    const isSse = process.argv.includes("--sse") || !!process.env.PORT;
-    if (isSse) {
+        else {
+            const res = await memory.search("", { limit: args.limit });
+            return { content: [{ type: "text", text: JSON.stringify(res) }] };
+        }
+    });
+    server.registerTool("delete_memory", {
+        description: "Delete memory by ID",
+        inputSchema: zod_1.z.object({ id: zod_1.z.string() }),
+    }, async (args) => {
+        if (cliUrl) {
+            const res = await apiClient.delete(`/${args.id}`);
+            return { content: [{ type: "text", text: JSON.stringify(res.data) }] };
+        }
+        else {
+            return {
+                content: [
+                    { type: "text", text: "Delete not implemented in SDK yet" },
+                ],
+            };
+        }
+    });
+    server.registerTool("update_memory", {
+        description: "Update memory",
+        inputSchema: zod_1.z.object({ id: zod_1.z.string(), content: zod_1.z.string().optional() }),
+    }, async (args) => {
+        return { content: [{ type: "text", text: "Update not implemented" }] };
+    });
+    // --- TRANSPORT ---
+    const useHttp = args.includes("--http") || args.includes("--port");
+    if (useHttp) {
+        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.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");
-            }
+        app.use(express_1.default.json());
+        app.get("/health", (req, res) => res.json({ ok: true, version: "0.8.2", mode: cliUrl ? "proxy" : "sdk" }));
+        // REST API Compatibility (for Remote Clients)
+        // Only enable if in SDK mode (Server)
+        if (!cliUrl && memory) {
+            app.post("/add", async (req, res) => {
+                try {
+                    const { content, user_id, tags } = req.body;
+                    const finalTags = addSourceTag(tags);
+                    const result = await memory.add(content, {
+                        user_id,
+                        tags: finalTags,
+                    });
+                    res.json(result);
+                }
+                catch (e) {
+                    res.status(500).json({ error: e.message });
+                }
+            });
+            app.post("/query", async (req, res) => {
+                try {
+                    const { query, k } = req.body;
+                    const result = await memory.search(query || "", { limit: k || 5 });
+                    res.json(result);
+                }
+                catch (e) {
+                    res.status(500).json({ error: e.message });
+                }
+            });
+            app.get("/all", async (req, res) => {
+                try {
+                    const limit = parseInt(req.query.limit) || 10;
+                    const result = await memory.search("", { limit });
+                    res.json(result);
+                }
+                catch (e) {
+                    res.status(500).json({ error: e.message });
+                }
+            });
+        }
+        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 running on http://localhost:${port}`);
+            });
         });
     }
     else {
         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 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.3",
+  "description": "CyberMem MCP Server - AI Memory with openmemory-js SDK",
   "main": "dist/index.js",
   "bin": {
     "cybermem-mcp": "./dist/index.js"
@@ -39,7 +39,9 @@
     "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",