@cybermem/mcp 0.6.8 → 0.8.1

package/dist/auth.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * CyberMem MCP Auth Module
+ *
+ * Token storage and browser-based OAuth login flow.
+ */
+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 });
+exports.getToken = getToken;
+exports.isLoggedIn = isLoggedIn;
+exports.getUserInfo = getUserInfo;
+exports.logout = logout;
+exports.showStatus = showStatus;
+exports.login = login;
+const fs = __importStar(require("fs"));
+const http = __importStar(require("http"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const AUTH_DIR = path.join(os.homedir(), ".cybermem");
+const TOKEN_FILE = path.join(AUTH_DIR, "token.json");
+const AUTH_URL = process.env.CYBERMEM_AUTH_URL || "https://cybermem.dev";
+/**
+ * Ensure the .cybermem directory exists
+ */
+function ensureAuthDir() {
+    if (!fs.existsSync(AUTH_DIR)) {
+        fs.mkdirSync(AUTH_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Get stored token if valid
+ */
+function getToken() {
+    try {
+        if (!fs.existsSync(TOKEN_FILE)) {
+            return null;
+        }
+        const data = JSON.parse(fs.readFileSync(TOKEN_FILE, "utf-8"));
+        // Check expiration
+        if (new Date(data.expires_at) < new Date()) {
+            console.error("Token expired, please run --login");
+            return null;
+        }
+        return data.access_token;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if user is logged in with valid token
+ */
+function isLoggedIn() {
+    return getToken() !== null;
+}
+/**
+ * Get user info from stored token
+ */
+function getUserInfo() {
+    try {
+        if (!fs.existsSync(TOKEN_FILE)) {
+            return null;
+        }
+        const data = JSON.parse(fs.readFileSync(TOKEN_FILE, "utf-8"));
+        return { email: data.email, name: data.name };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save token to disk
+ */
+function saveToken(token, expiresIn, email, name) {
+    ensureAuthDir();
+    const expiresAt = new Date(Date.now() + expiresIn * 1000);
+    const data = {
+        access_token: token,
+        expires_at: expiresAt.toISOString(),
+        email,
+        name,
+    };
+    fs.writeFileSync(TOKEN_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+/**
+ * Remove stored token
+ */
+function logout() {
+    if (fs.existsSync(TOKEN_FILE)) {
+        fs.unlinkSync(TOKEN_FILE);
+        console.log("✅ Logged out successfully");
+    }
+    else {
+        console.log("Already logged out");
+    }
+}
+/**
+ * Show current auth status
+ */
+function showStatus() {
+    const token = getToken();
+    const userInfo = getUserInfo();
+    if (token && userInfo) {
+        console.log("✅ Logged in as:", userInfo.email || userInfo.name || "Unknown");
+        if (userInfo.name)
+            console.log("   Name:", userInfo.name);
+    }
+    else {
+        console.log("❌ Not logged in");
+        console.log("   Run: npx @cybermem/mcp --login");
+    }
+}
+/**
+ * Start OAuth login flow
+ * Opens browser and waits for callback with token
+ */
+async function login() {
+    return new Promise((resolve, reject) => {
+        // Find available port
+        const server = http.createServer();
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                reject(new Error("Failed to start callback server"));
+                return;
+            }
+            const port = address.port;
+            const callbackUrl = `http://localhost:${port}/callback`;
+            const authUrl = `${AUTH_URL}/api/auth/signin?callbackUrl=${encodeURIComponent(`${AUTH_URL}/api/auth/cli/callback?redirect=${encodeURIComponent(callbackUrl)}`)}`;
+            console.log("🔐 Opening browser for GitHub login...");
+            console.log(`   If browser doesn't open, visit: ${authUrl}`);
+            // Open browser
+            const open = async (url) => {
+                const { exec } = await import("child_process");
+                const cmd = process.platform === "darwin"
+                    ? `open "${url}"`
+                    : process.platform === "win32"
+                        ? `start "${url}"`
+                        : `xdg-open "${url}"`;
+                exec(cmd);
+            };
+            open(authUrl);
+            // Handle callback
+            server.on("request", async (req, res) => {
+                if (!req.url?.startsWith("/callback")) {
+                    res.writeHead(404);
+                    res.end("Not found");
+                    return;
+                }
+                const url = new URL(req.url, `http://localhost:${port}`);
+                const token = url.searchParams.get("token");
+                if (!token) {
+                    res.writeHead(400);
+                    res.end("Missing token");
+                    server.close();
+                    reject(new Error("No token received"));
+                    return;
+                }
+                // Decode token to get user info (JWT payload)
+                let email;
+                let name;
+                try {
+                    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+                    email = payload.email;
+                    name = payload.name;
+                }
+                catch {
+                    // Ignore decode errors
+                }
+                // Save token (30 days expiry)
+                saveToken(token, 30 * 24 * 60 * 60, email, name);
+                // Send success page
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(`
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <title>CyberMem - Logged In</title>
+            <style>
+              body { font-family: system-ui; text-align: center; padding: 50px; background: #0a0a0a; color: #fff; }
+              h1 { color: #22c55e; }
+              .logo { font-size: 48px; margin-bottom: 20px; }
+            </style>
+          </head>
+          <body>
+            <div class="logo">🧠</div>
+            <h1>Successfully Logged In!</h1>
+            <p>You can close this window and return to your terminal.</p>
+            <p style="color: #888;">Logged in as: ${email || name || "Unknown"}</p>
+          </body>
+          </html>
+        `);
+                console.log("");
+                console.log("✅ Successfully logged in as:", email || name || "Unknown");
+                console.log("   Token saved to:", TOKEN_FILE);
+                server.close();
+                resolve();
+            });
+            // Timeout after 5 minutes
+            setTimeout(() => {
+                server.close();
+                reject(new Error("Login timeout - no callback received"));
+            }, 5 * 60 * 1000);
+        });
+    });
+}

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,182 +84,152 @@ INTEGRITY RULES:
 - Sync before critical decisions
 - Last-write-wins for conflicts
 
-For full protocol: https://cybermem.dev/docs/agent-protocol`;
-const server = new index_js_1.Server({
-    name: "cybermem",
-    version: "0.6.5",
-}, {
-    capabilities: {
-        tools: {},
-    },
-    instructions: CYBERMEM_INSTRUCTIONS,
-});
-const tools = [
-    {
-        name: "add_memory",
-        description: "Store a new memory in CyberMem",
-        inputSchema: {
-            type: "object",
-            properties: {
-                content: { type: "string" },
-                user_id: { type: "string" },
-                tags: { type: "array", items: { type: "string" } },
-            },
-            required: ["content"],
+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: {},
         },
-    },
-    {
-        name: "query_memory",
-        description: "Search for relevant memories",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: { type: "string" },
-                k: { type: "number", default: 5 },
+        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,
             },
-            required: ["query"],
-        },
-    },
-    {
-        name: "list_memories",
+        ],
+    }));
+    // 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 {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+        };
+    });
+    server.registerTool("query_memory", {
+        description: `Search for relevant memories. On session start, call query_memory("user context profile") first.`,
+        inputSchema: zod_1.z.object({
+            query: zod_1.z.string(),
+            k: zod_1.z.number().default(5),
+        }),
+    }, 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: {
-            type: "object",
-            properties: {
-                limit: { type: "number", default: 10 },
-            },
-        },
-    },
-    {
-        name: "delete_memory",
+        inputSchema: zod_1.z.object({
+            limit: zod_1.z.number().default(10),
+        }),
+    }, 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: {
-            type: "object",
-            properties: {
-                id: { type: "string" },
-            },
-            required: ["id"],
-        },
-    },
-    {
-        name: "update_memory",
+        inputSchema: zod_1.z.object({
+            id: zod_1.z.string(),
+        }),
+    }, 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: {
-            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 } }),
-        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 } }),
-    };
-}
-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) {
+        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(),
+        }),
+    }, 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" });
+        });
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            sessionIdGenerator: () => crypto.randomUUID(),
         });
-        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.all("/mcp", async (req, res) => {
+            await transport.handleRequest(req, res, req.body);
         });
-        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("/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.8",
-  "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",