@cybermem/mcp 0.14.8 → 0.14.11

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @cybermem/mcp
 
+## 0.14.11
+
+### Patch Changes
+
+- [#120](https://github.com/mikhailkogan17/cybermem/pull/120) [`2319994`](https://github.com/mikhailkogan17/cybermem/commit/2319994f096e4063e2ca4bc4ca02eb8b33f192ce) Thanks [@mikhailkogan17-antigravity](https://github.com/mikhailkogan17-antigravity)! - fix(mcp): remove redundant transport.start() call causing SSE crash loop; switch to SSEServerTransport for multi-client support
+  fix(dashboard): update mcp-config API to support SSE and --allow-http
+
 ## 0.14.8
 
 ### Patch Changes

package/dist/index.js

@@ -12,11 +12,23 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const async_hooks_1 = require("async_hooks");
 const cors_1 = __importDefault(require("cors"));
 const express_1 = __importDefault(require("express"));
+const fs_1 = require("fs");
+const path_1 = require("path");
 const zod_1 = require("zod");
 // Async Storage for Request Context (User ID and Client Name)
 const requestContext = new async_hooks_1.AsyncLocalStorage();
 // CLI args processing
 const args = process.argv.slice(2);
+// Read version from package.json
+let PACKAGE_VERSION = "0.0.0";
+try {
+    const packageJsonPath = (0, path_1.join)(__dirname, "../package.json");
+    const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"));
+    PACKAGE_VERSION = packageJson.version;
+}
+catch (error) {
+    console.error("[MCP] Failed to read package.json version", error);
+}
 // Start the server
 startServer();
 async function startServer() {
@@ -97,7 +109,8 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         let client;
         const ctx = requestContext.getStore();
         if (opts.sessionId) {
-            client = "sse-client"; // TODO: Extract real client name from session state
+            // For SSE sessions, prefer the real client name from the request context when available
+            client = ctx?.clientName || "sse-client";
         }
         else if (ctx) {
             client = ctx.clientName || stdioClientName || "unknown";
@@ -114,7 +127,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
                 db.run("INSERT INTO cybermem_access_log (timestamp, client_name, client_version, method, endpoint, operation, status, is_error) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [
                     ts,
                     client,
-                    "0.12.4",
+                    PACKAGE_VERSION,
                     method,
                     endpoint,
                     operation,
@@ -127,13 +140,13 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         catch { }
     };
     // Factory to create configured McpServer instance
-    const createConfiguredServer = () => {
-        const server = new mcp_js_1.McpServer({ name: "cybermem", version: "0.12.4" }, {
+    const createConfiguredServer = (onClientConnected) => {
+        const server = new mcp_js_1.McpServer({ name: "cybermem", version: PACKAGE_VERSION }, {
             instructions: CYBERMEM_INSTRUCTIONS,
         });
-        // access underlying server
-        server._memoryReady =
-            true;
+        // access underlying server to set internal state for direct memory access
+        // Casting to unknown first to allow adding private property
+        server._memoryReady = true;
         server.registerResource("CyberMem Agent Protocol", "cybermem://protocol", { description: "Instructions for AI agents", mimeType: "text/plain" }, async () => ({
             contents: [
                 {
@@ -148,8 +161,15 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
             // For SSE multiple clients, stdioClientName global is less useful,
             // but we can set it for context if running in single-user mode.
             // For multi-user, rely on requestContext.
-            stdioClientName = request.params.clientInfo.name;
-            console.error(`[MCP] Client identified via handshake: ${request.params.clientInfo.name}`);
+            // For SSE multiple clients, rely on per-request context instead of a global.
+            const clientName = request.params.clientInfo.name;
+            if (onClientConnected) {
+                onClientConnected(clientName);
+            }
+            else {
+                stdioClientName = clientName;
+            }
+            console.error(`[MCP] Client identified via handshake: ${clientName}`);
             return {
                 protocolVersion: "2024-11-05",
                 capabilities: {
@@ -158,7 +178,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
                 },
                 serverInfo: {
                     name: "cybermem",
-                    version: "0.12.4",
+                    version: PACKAGE_VERSION,
                 },
             };
         });
@@ -181,7 +201,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         });
         server.registerTool("query_memory", {
             description: "Search memories.",
-            inputSchema: zod_1.z.object({ query: zod_1.z.string(), k: zod_1.z.number().default(50) }),
+            inputSchema: zod_1.z.object({ query: zod_1.z.string(), k: zod_1.z.number().default(5) }),
         }, async (args) => {
             const res = await memory.search(args.query, { limit: args.k });
             await logActivity("read", {
@@ -264,7 +284,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         const app = (0, express_1.default)();
         app.use((0, cors_1.default)());
         app.use(express_1.default.json());
-        app.get("/health", (req, res) => res.json({ ok: true, version: "0.12.4" }));
+        app.get("/health", (req, res) => res.json({ ok: true, version: PACKAGE_VERSION }));
         app.use((req, res, next) => {
             const clientName = req.headers["x-client-name"] || "antigravity-client";
             requestContext.run({ clientName }, next);
@@ -371,7 +391,11 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         app.get("/sse", async (req, res) => {
             console.error("[MCP] Attempting SSE Connection...");
             const transport = new sse_js_1.SSEServerTransport("/message", res);
-            const newServer = createConfiguredServer();
+            const newServer = createConfiguredServer((name) => {
+                const session = sessions.get(transport.sessionId);
+                if (session)
+                    session.clientName = name;
+            });
             try {
                 await newServer.connect(transport);
                 sessions.set(transport.sessionId, { server: newServer, transport });
@@ -383,7 +407,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
                     console.error(`[MCP] SSE Connection Error: ${transport.sessionId}`, err);
                     sessions.delete(transport.sessionId);
                 };
-                await transport.start();
+                // await transport.start(); // FIXED: connect() starts it automatically
             }
             catch (err) {
                 console.error("[MCP] Failed to start SSE transport:", err);
@@ -402,7 +426,10 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
                 return;
             }
             try {
-                await session.transport.handlePostMessage(req, res);
+                const clientName = session.clientName || "sse-client";
+                await requestContext.run({ clientName }, async () => {
+                    await session.transport.handlePostMessage(req, res);
+                });
             }
             catch (err) {
                 console.error(`[MCP] Error handling message for session ${sessionId}:`, err);

package/e2e/sse_transport.spec.ts

@@ -0,0 +1,81 @@
+import { expect, test } from "@playwright/test";
+import { ChildProcess, spawn } from "child_process";
+import path from "path";
+
+test.describe("MCP SSE Transport", () => {
+  let serverProcess: ChildProcess;
+  const PORT = 3101; // Use unique port for this test
+
+  test.setTimeout(120000);
+
+  test.beforeAll(async () => {
+    // Start the server in http mode
+    const serverPath = path.join(__dirname, "../dist/index.js");
+    serverProcess = spawn(
+      "node",
+      [
+        serverPath,
+        "--port",
+        PORT.toString(),
+        "--env",
+        "test",
+        "--db-path",
+        ":memory:",
+      ],
+      {
+        stdio: "pipe",
+        env: { ...process.env, OM_DB_PATH: ":memory:" },
+      },
+    );
+
+    // Wait for server to start
+    await new Promise<void>((resolve, reject) => {
+      serverProcess.stderr?.on("data", (data) => {
+        const output = data.toString();
+        console.log("[Server]", output);
+        if (
+          output.includes(`CyberMem MCP running on http://localhost:${PORT}`)
+        ) {
+          resolve();
+        }
+      });
+      serverProcess.on("error", reject);
+      setTimeout(() => reject(new Error("Server start timeout")), 60000);
+    });
+  });
+
+  test.afterAll(() => {
+    serverProcess.kill();
+  });
+
+  test("should establish SSE connection without crashing", async () => {
+    const response = await fetch(`http://localhost:${PORT}/sse`);
+    expect(response.status).toBe(200);
+    expect(response.headers.get("content-type")).toBe("text/event-stream");
+
+    // Read stream for a bit to ensure it doesn't close immediately due to error
+    const reader = response.body?.getReader();
+    expect(reader).toBeDefined();
+
+    const decoder = new TextDecoder();
+    let endpointFound = false;
+
+    // Read first few chunks
+    for (let i = 0; i < 3; i++) {
+      const { value, done } = await reader!.read();
+      if (done) break;
+      const text = decoder.decode(value);
+      if (text.includes("event: endpoint")) {
+        endpointFound = true;
+      }
+    }
+
+    expect(endpointFound).toBe(true);
+
+    // Cleanup connection
+    await reader?.cancel();
+
+    // Check if server process is still running (didn't crash)
+    expect(serverProcess.exitCode).toBeNull();
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cybermem/mcp",
-  "version": "0.14.8",
+  "version": "0.14.11",
   "description": "CyberMem MCP Server - AI Memory with openmemory-js SDK",
   "main": "dist/index.js",
   "bin": {

package/playwright.config.ts

@@ -11,7 +11,7 @@ export default defineConfig({
   projects: [
     {
       name: "api",
-      testMatch: "api.spec.ts",
+      testMatch: "*.spec.ts",
     },
   ],
 });

package/src/index.ts

@@ -8,12 +8,25 @@ import { InitializeRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { AsyncLocalStorage } from "async_hooks";
 import cors from "cors";
 import express from "express";
+import { readFileSync } from "fs";
+import { join } from "path";
 import { z } from "zod";
 
 // Type definition for OpenMemory Memory class
 interface IMemory {
-  add(content: string, opts?: { tags?: string[]; user_id?: string; [key: string]: unknown }): Promise<unknown>;
-  search(query: string, opts?: { limit?: number; user_id?: string; sectors?: unknown; [key: string]: unknown }): Promise<unknown>;
+  add(
+    content: string,
+    opts?: { tags?: string[]; user_id?: string; [key: string]: unknown },
+  ): Promise<unknown>;
+  search(
+    query: string,
+    opts?: {
+      limit?: number;
+      user_id?: string;
+      sectors?: unknown;
+      [key: string]: unknown;
+    },
+  ): Promise<unknown>;
   get(id: string): Promise<unknown>;
   delete_all(user_id: string): Promise<unknown>;
   wipe(): Promise<unknown>;
@@ -28,6 +41,16 @@ const requestContext = new AsyncLocalStorage<{
 // CLI args processing
 const args = process.argv.slice(2);
 
+// Read version from package.json
+let PACKAGE_VERSION = "0.0.0";
+try {
+  const packageJsonPath = join(__dirname, "../package.json");
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  PACKAGE_VERSION = packageJson.version;
+} catch (error) {
+  console.error("[MCP] Failed to read package.json version", error);
+}
+
 // Start the server
 startServer();
 
@@ -47,8 +70,17 @@ async function startServer() {
   // --- IMPLEMENTATION LOGIC ---
 
   let memory: IMemory | null = null;
-  let sdk_update_memory: ((id: string, content?: string, tags?: string[], metadata?: Record<string, unknown>) => Promise<unknown>) | null = null;
-  let sdk_reinforce_memory: ((id: string, boost?: number) => Promise<unknown>) | null = null;
+  let sdk_update_memory:
+    | ((
+        id: string,
+        content?: string,
+        tags?: string[],
+        metadata?: Record<string, unknown>,
+      ) => Promise<unknown>)
+    | null = null;
+  let sdk_reinforce_memory:
+    | ((id: string, boost?: number) => Promise<unknown>)
+    | null = null;
 
   // LOCAL SDK MODE
   const dbPath = process.env.OM_DB_PATH!;
@@ -122,15 +154,10 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
   const logActivity = async (
     operation: string,
     opts: {
-      details?: unknown;
-      query?: string;
-      memoryId?: string;
-      delta?: string;
-      tags?: string[];
-      sessionId?: string;
       method?: string;
       endpoint?: string;
       status?: number;
+      sessionId?: string;
     } = {},
   ) => {
     // Determine client name (priority: specific > store > default)
@@ -138,7 +165,8 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
     const ctx = requestContext.getStore();
 
     if (opts.sessionId) {
-      client = "sse-client"; // TODO: Extract real client name from session state
+      // For SSE sessions, prefer the real client name from the request context when available
+      client = ctx?.clientName || "sse-client";
     } else if (ctx) {
       client = ctx.clientName || stdioClientName || "unknown";
     } else {
@@ -156,7 +184,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
           [
             ts,
             client,
-            "0.12.4",
+            PACKAGE_VERSION,
             method,
             endpoint,
             operation,
@@ -173,17 +201,19 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
   };
 
   // Factory to create configured McpServer instance
-  const createConfiguredServer = () => {
+  const createConfiguredServer = (
+    onClientConnected?: (name: string) => void,
+  ) => {
     const server = new McpServer(
-      { name: "cybermem", version: "0.12.4" },
+      { name: "cybermem", version: PACKAGE_VERSION },
       {
         instructions: CYBERMEM_INSTRUCTIONS,
       },
     );
 
-    // access underlying server
-    (server as unknown as McpServer & { _memoryReady: boolean })._memoryReady =
-      true;
+    // access underlying server to set internal state for direct memory access
+    // Casting to unknown first to allow adding private property
+    (server as unknown as { _memoryReady: boolean })._memoryReady = true;
 
     server.registerResource(
       "CyberMem Agent Protocol",
@@ -207,10 +237,14 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         // For SSE multiple clients, stdioClientName global is less useful,
         // but we can set it for context if running in single-user mode.
         // For multi-user, rely on requestContext.
-        stdioClientName = request.params.clientInfo.name;
-        console.error(
-          `[MCP] Client identified via handshake: ${request.params.clientInfo.name}`,
-        );
+        // For SSE multiple clients, rely on per-request context instead of a global.
+        const clientName = request.params.clientInfo.name;
+        if (onClientConnected) {
+          onClientConnected(clientName);
+        } else {
+          stdioClientName = clientName;
+        }
+        console.error(`[MCP] Client identified via handshake: ${clientName}`);
         return {
           protocolVersion: "2024-11-05",
           capabilities: {
@@ -219,7 +253,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
           },
           serverInfo: {
             name: "cybermem",
-            version: "0.12.4",
+            version: PACKAGE_VERSION,
           },
         };
       },
@@ -252,7 +286,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
       "query_memory",
       {
         description: "Search memories.",
-        inputSchema: z.object({ query: z.string(), k: z.number().default(50) }),
+        inputSchema: z.object({ query: z.string(), k: z.number().default(5) }),
       },
       async (args: { query: string; k?: number }) => {
         const res = await memory!.search(args.query, { limit: args.k });
@@ -279,7 +313,9 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
       async (args: { id: string; content?: string; tags?: string[] }) => {
         if (!sdk_update_memory) throw new Error("Update not available in SDK");
         if (args.content === undefined && args.tags === undefined) {
-          throw new Error("At least one of 'content' or 'tags' must be provided to update_memory");
+          throw new Error(
+            "At least one of 'content' or 'tags' must be provided to update_memory",
+          );
         }
         const res = await sdk_update_memory(args.id, args.content, args.tags);
         await logActivity("update", {
@@ -357,7 +393,9 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
     const app = express();
     app.use(cors());
     app.use(express.json());
-    app.get("/health", (req, res) => res.json({ ok: true, version: "0.12.4" }));
+    app.get("/health", (req, res) =>
+      res.json({ ok: true, version: PACKAGE_VERSION }),
+    );
 
     app.use((req, res, next) => {
       const clientName =
@@ -467,6 +505,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
       {
         server: McpServer;
         transport: SSEServerTransport;
+        clientName?: string;
       }
     >();
 
@@ -482,7 +521,10 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
     app.get("/sse", async (req, res) => {
       console.error("[MCP] Attempting SSE Connection...");
       const transport = new SSEServerTransport("/message", res);
-      const newServer = createConfiguredServer();
+      const newServer = createConfiguredServer((name) => {
+        const session = sessions.get(transport.sessionId);
+        if (session) session.clientName = name;
+      });
 
       try {
         await newServer.connect(transport);
@@ -500,7 +542,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
           sessions.delete(transport.sessionId);
         };
 
-        await transport.start();
+        // await transport.start(); // FIXED: connect() starts it automatically
       } catch (err) {
         console.error("[MCP] Failed to start SSE transport:", err);
         sessions.delete(transport.sessionId);
@@ -519,7 +561,10 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         return;
       }
       try {
-        await session.transport.handlePostMessage(req, res);
+        const clientName = session.clientName || "sse-client";
+        await requestContext.run({ clientName }, async () => {
+          await session.transport.handlePostMessage(req, res);
+        });
       } catch (err) {
         console.error(
           `[MCP] Error handling message for session ${sessionId}:`,