@cybermem/mcp 0.6.10 → 0.8.1

package/src/index.ts

@@ -1,42 +1,73 @@
 #!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+/**
+ * CyberMem MCP Server
+ *
+ * MCP server for AI agents to interact with CyberMem memory system.
+ * Uses openmemory-js SDK directly (no HTTP, embedded SQLite).
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-    CallToolRequestSchema,
-    ListResourcesRequestSchema,
-    ListToolsRequestSchema,
-    ReadResourceRequestSchema,
-    Tool,
-} from "@modelcontextprotocol/sdk/types.js";
-import axios from "axios";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import cors from "cors";
 import dotenv from "dotenv";
 import express from "express";
+import { Memory } from "openmemory-js";
+import { z } from "zod";
+import { login, logout, showStatus } from "./auth.js";
 
 dotenv.config();
 
-// Parse CLI args for remote mode
+// Handle CLI auth commands first
 const args = process.argv.slice(2);
-const getArg = (name: string): string | undefined => {
-  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")) {
+  login()
+    .then(() => process.exit(0))
+    .catch((err) => {
+      console.error("Login failed:", err.message);
+      process.exit(1);
+    });
+} else if (args.includes("--logout")) {
+  logout();
+  process.exit(0);
+} else if (args.includes("--status")) {
+  showStatus();
+  process.exit(0);
+} else {
+  // Continue with MCP server startup
+  startServer();
+}
+
+async function startServer() {
+  // Parse CLI args
+  const getArg = (name: string): string | undefined => {
+    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 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
@@ -55,41 +86,36 @@ 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 Server(
-  {
-    name: "cybermem",
-    version: "0.6.8",
-  },
-  {
-    capabilities: {
-      tools: {},
-      resources: {}, // Enable resources for protocol document
+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 McpServer(
+    {
+      name: "cybermem",
+      version: "0.8.0",
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {},
+      },
+      instructions: CYBERMEM_INSTRUCTIONS,
     },
-    instructions: CYBERMEM_INSTRUCTIONS,
-  },
-);
+  );
 
-// Register resources handler for protocol document
-server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-  resources: [
+  // Register resources
+  server.registerResource(
+    "CyberMem Agent Protocol",
+    "cybermem://protocol",
     {
-      uri: "cybermem://protocol",
-      name: "CyberMem Agent Protocol",
       description: "Instructions for AI agents using CyberMem memory system",
       mimeType: "text/plain",
     },
-  ],
-}));
-
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-  if (request.params.uri === "cybermem://protocol") {
-    return {
+    async () => ({
       contents: [
         {
           uri: "cybermem://protocol",
@@ -97,228 +123,167 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
           text: CYBERMEM_INSTRUCTIONS,
         },
       ],
-    };
-  }
-  throw new Error(`Unknown resource: ${request.params.uri}`);
-});
-
-const tools: Tool[] = [
-  {
-    name: "add_memory",
-    description: `Store a new memory in CyberMem. ${PROTOCOL_REMINDER}`,
-    inputSchema: {
-      type: "object",
-      properties: {
-        content: {
-          type: "string",
-          description:
+    }),
+  );
+
+  // Register tools using openmemory-js SDK
+  server.registerTool(
+    "add_memory",
+    {
+      description: `Store a new memory in CyberMem. ${PROTOCOL_REMINDER}`,
+      inputSchema: z.object({
+        content: z
+          .string()
+          .describe(
             "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"],
+          ),
+        user_id: z.string().optional(),
+        tags: z
+          .array(z.string())
+          .optional()
+          .describe("Always include [topic, year, source:your-client-name]"),
+      }),
     },
-  },
-  {
-    name: "list_memories",
-    description: "List recent memories",
-    inputSchema: {
-      type: "object",
-      properties: {
-        limit: { type: "number", default: 10 },
-      },
+    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) }],
+      };
     },
-  },
-  {
-    name: "delete_memory",
-    description: "Delete a memory by ID",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "string" },
-      },
-      required: ["id"],
+  );
+
+  server.registerTool(
+    "query_memory",
+    {
+      description: `Search for relevant memories. On session start, call query_memory("user context profile") first.`,
+      inputSchema: z.object({
+        query: z.string(),
+        k: z.number().default(5),
+      }),
     },
-  },
-  {
-    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"],
+    async (args) => {
+      const results = await memory.search(args.query, { limit: args.k });
+      return {
+        content: [{ type: "text", text: JSON.stringify(results) }],
+      };
     },
-  },
-];
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools,
-}));
-
-// Create axios instance
-const apiClient = axios.create({
-  baseURL: API_URL,
-  headers: {
-    Authorization: `Bearer ${API_KEY}`,
-  },
-});
-
-// Helper to get client with context
-function getClient(customHeaders: Record<string, string> = {}) {
-  // 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: string, config?: any) =>
-      apiClient.get(url, {
-        ...config,
-        headers: { "X-Client-Name": clientName, ...config?.headers },
-      }),
-    post: (url: string, data?: any, config?: any) =>
-      apiClient.post(url, data, {
-        ...config,
-        headers: { "X-Client-Name": clientName, ...config?.headers },
-      }),
-    put: (url: string, data?: any, config?: any) =>
-      apiClient.put(url, data, {
-        ...config,
-        headers: { "X-Client-Name": clientName, ...config?.headers },
-      }),
-    patch: (url: string, data?: any, config?: any) =>
-      apiClient.patch(url, data, {
-        ...config,
-        headers: { "X-Client-Name": clientName, ...config?.headers },
-      }),
-    delete: (url: string, config?: any) =>
-      apiClient.delete(url, {
-        ...config,
-        headers: { "X-Client-Name": clientName, ...config?.headers },
+  );
+
+  server.registerTool(
+    "list_memories",
+    {
+      description: "List recent memories",
+      inputSchema: z.object({
+        limit: 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.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
+  server.registerTool(
+    "delete_memory",
+    {
+      description: "Delete a memory by ID",
+      inputSchema: z.object({
+        id: 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}`,
+          },
+        ],
+      };
+    },
+  );
 
-  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 as { id: string };
-        await getClient().delete(`/${id}`);
-        return { content: [{ type: "text", text: `Memory ${id} deleted` }] };
-      }
-      case "update_memory": {
-        const { id, ...updates } = args as { id: string; [key: string]: any };
-        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: any) {
-    return {
-      content: [{ type: "text", text: `Error: ${error.message}` }],
-      isError: true,
-    };
-  }
-});
+  server.registerTool(
+    "update_memory",
+    {
+      description: "Update a memory by ID",
+      inputSchema: z.object({
+        id: z.string(),
+        content: z.string().optional(),
+        tags: z.array(z.string()).optional(),
+      }),
+    },
+    async (args) => {
+      // TODO: Implement update in SDK
+      return {
+        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;
+  // Determine transport mode
+  const transportArg = args.find(
+    (arg) => arg === "--stdio" || arg === "--http",
+  );
+  const useHttp = transportArg === "--http" || args.includes("--port");
 
-  if (isSse) {
+  if (useHttp) {
+    // HTTP mode for testing/development
+    const port = parseInt(getArg("--port") || "3100", 10);
     const app = express();
-    app.use(cors());
-    const port = process.env.PORT || 8627;
 
-    let transport: SSEServerTransport | null = null;
+    app.use(cors());
+    app.use(express.json());
 
-    app.get("/sse", async (req, res) => {
-      // Extract client name from header
-      const clientName = req.headers["x-client-name"] as string;
-      if (clientName) {
-        currentClientName = clientName;
-      }
+    app.get("/health", (_req, res) => {
+      res.json({ ok: true, version: "0.8.0", mode: "sdk" });
+    });
 
-      transport = new SSEServerTransport("/messages", res);
-      await server.connect(transport);
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => crypto.randomUUID(),
     });
 
-    app.post("/messages", async (req, res) => {
-      // Also check headers on messages
-      const clientName = req.headers["x-client-name"] as string;
-      if (clientName) {
-        currentClientName = clientName;
-      }
+    app.all("/mcp", async (req, res) => {
+      await transport.handleRequest(req, res, req.body);
+    });
 
-      if (transport) {
-        await transport.handlePostMessage(req, res);
-      } else {
-        res.status(400).send("Session not established");
-      }
+    app.all("/sse", 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`);
+    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 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/src/openmemory-js.d.ts

@@ -0,0 +1,23 @@
+declare module "openmemory-js" {
+  export interface MemoryOptions {
+    user_id?: string;
+    tags?: string[];
+    [key: string]: any;
+  }
+
+  export interface SearchOptions {
+    user_id?: string;
+    limit?: number;
+    sectors?: string[];
+  }
+
+  export class Memory {
+    constructor(user_id?: string);
+    add(content: string, opts?: MemoryOptions): Promise<any>;
+    get(id: string): Promise<any>;
+    search(query: string, opts?: SearchOptions): Promise<any[]>;
+    delete_all(user_id?: string): Promise<void>;
+    wipe(): Promise<void>;
+    source(name: string): any;
+  }
+}