@cybermem/mcp 0.14.6 → 0.14.10

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @cybermem/mcp
 
+## 0.14.9
+
+### 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
+
+- Automated patch version bump.
+
+## 0.14.7
+
+### Patch Changes
+
+- [#114](https://github.com/mikhailkogan17/cybermem/pull/114) [`7871ba9`](https://github.com/mikhailkogan17/cybermem/commit/7871ba96c9008a8188a84bc379e9687e716ed9e9) Thanks [@mikhailkogan17-antigravity](https://github.com/mikhailkogan17-antigravity)! - fix(mcp): switch to SSEServerTransport for multi-client support
+  fix(dashboard): update mcp-config API to support SSE and --allow-http
+
 ## 0.14.6
 
 ### Patch Changes

package/dist/index.js

@@ -6,17 +6,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("./console-fix.js");
 require("./env.js");
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 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() {
@@ -29,45 +41,6 @@ async function startServer() {
         console.error("[MCP] Running in Staging environment");
         process.env.CYBERMEM_ENV = "staging";
     }
-    let stdioClientName = undefined;
-    // 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")
-2. Store new insights immediately with add_memory (STABLE data)
-3. For corrections: use update_memory (STRUCTURAL mutation, high cost)
-4. To prevent decay: use reinforce_memory (METABOLIC boost, low cost)
-5. 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.12.4" }, {
-        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,
-            },
-        ],
-    }));
-    // Capture client info from handshake
-    // @ts-ignore - access underlying server
-    server.server.setRequestHandler(types_js_1.InitializeRequestSchema, async (request) => {
-        stdioClientName = request.params.clientInfo.name;
-        console.error(`[MCP] Client identified via handshake: ${stdioClientName}`);
-        return {
-            protocolVersion: "2024-11-05",
-            capabilities: {
-                tools: { listChanged: true },
-                resources: { subscribe: true },
-            },
-            serverInfo: {
-                name: "cybermem",
-                version: "0.12.4",
-            },
-        };
-    });
     // --- IMPLEMENTATION LOGIC ---
     let memory = null;
     let sdk_update_memory = null;
@@ -88,7 +61,6 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         sdk_update_memory = hsg.update_memory;
         sdk_reinforce_memory = hsg.reinforce_memory;
         memory = new Memory();
-        server._memoryReady = true;
         // Initialize Tables
         const sqlite3 = await import("sqlite3");
         const db = new sqlite3.default.Database(dbPath);
@@ -122,24 +94,40 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
             });
         });
     };
+    let stdioClientName = undefined;
+    // 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")
+2. Store new insights immediately with add_memory (STABLE data)
+3. For corrections: use update_memory (STRUCTURAL mutation, high cost)
+4. To prevent decay: use reinforce_memory (METABOLIC boost, low cost)
+5. Always include tags: [topic, year, source:your-client-name]
+For full protocol: https://docs.cybermem.dev/agent-protocol`;
     const logActivity = async (operation, opts = {}) => {
-        if (!memory)
-            return;
-        const { client: providedClient, method = "POST", endpoint = "/mcp", status = 200, } = opts;
+        // Determine client name (priority: specific > store > default)
+        let client;
         const ctx = requestContext.getStore();
-        const client = providedClient ||
-            ctx?.clientName ||
-            stdioClientName ||
-            "antigravity-client";
+        if (opts.sessionId) {
+            // 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 {
+            client = stdioClientName || "unknown";
+        }
+        const { method = "POST", endpoint = "/mcp", status = 200 } = opts;
         try {
-            const db = (await initLoggingDb());
+            const db = await initLoggingDb();
             const ts = Date.now();
             const is_error = status >= 400 ? 1 : 0;
             db.serialize(() => {
                 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,
@@ -151,92 +139,143 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         }
         catch { }
     };
-    // TOOLS
-    server.registerTool("add_memory", {
-        description: "Store a new memory. Use for high-quality, stable data. " +
-            CYBERMEM_INSTRUCTIONS,
-        inputSchema: zod_1.z.object({
-            content: zod_1.z.string(),
-            tags: zod_1.z.array(zod_1.z.string()).optional(),
-        }),
-    }, async (args) => {
-        const res = await memory.add(args.content, { tags: args.tags });
-        await logActivity("create", {
-            method: "POST",
-            endpoint: "/memory/add",
-            status: 200,
+    // Factory to create configured McpServer instance
+    const createConfiguredServer = (onClientConnected) => {
+        const server = new mcp_js_1.McpServer({ name: "cybermem", version: PACKAGE_VERSION }, {
+            instructions: CYBERMEM_INSTRUCTIONS,
         });
-        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) => {
-        const res = await memory.search(args.query, { limit: args.k });
-        await logActivity("read", {
-            method: "POST",
-            endpoint: "/memory/query",
-            status: 200,
+        // 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: [
+                {
+                    uri: "cybermem://protocol",
+                    mimeType: "text/plain",
+                    text: CYBERMEM_INSTRUCTIONS,
+                },
+            ],
+        }));
+        // access underlying server
+        server.server.setRequestHandler(types_js_1.InitializeRequestSchema, async (request) => {
+            // 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.
+            // 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: {
+                    tools: { listChanged: true },
+                    resources: { subscribe: true },
+                },
+                serverInfo: {
+                    name: "cybermem",
+                    version: PACKAGE_VERSION,
+                },
+            };
         });
-        return { content: [{ type: "text", text: JSON.stringify(res) }] };
-    });
-    server.registerTool("update_memory", {
-        description: "Mutate existing memory (content/tags). HIGH COST: re-embeds and re-links. Use for corrections.",
-        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) => {
-        if (!sdk_update_memory)
-            throw new Error("Update not available in SDK");
-        const res = await sdk_update_memory(args.id, args.content, args.tags);
-        await logActivity("update", {
-            method: "PATCH",
-            endpoint: `/memory/${args.id}`,
-            status: 200,
+        // TOOLS
+        server.registerTool("add_memory", {
+            description: "Store a new memory. Use for high-quality, stable data. " +
+                CYBERMEM_INSTRUCTIONS,
+            inputSchema: zod_1.z.object({
+                content: zod_1.z.string(),
+                tags: zod_1.z.array(zod_1.z.string()).optional(),
+            }),
+        }, async (args) => {
+            const res = await memory.add(args.content, { tags: args.tags });
+            await logActivity("create", {
+                method: "POST",
+                endpoint: "/memory/add",
+                status: 200,
+            });
+            return { content: [{ type: "text", text: JSON.stringify(res) }] };
         });
-        return { content: [{ type: "text", text: JSON.stringify(res) }] };
-    });
-    server.registerTool("reinforce_memory", {
-        description: "Metabolic boost (salience). LOW COST: prevents decay without mutation. Use for active topics.",
-        inputSchema: zod_1.z.object({ id: zod_1.z.string(), boost: zod_1.z.number().default(0.1) }),
-    }, async (args) => {
-        if (!sdk_reinforce_memory)
-            throw new Error("Reinforce not available in SDK");
-        await sdk_reinforce_memory(args.id, args.boost);
-        await logActivity("update", {
-            method: "POST",
-            endpoint: `/memory/${args.id}/reinforce`,
-            status: 200,
+        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) => {
+            const res = await memory.search(args.query, { limit: args.k });
+            await logActivity("read", {
+                method: "POST",
+                endpoint: "/memory/query",
+                status: 200,
+            });
+            return { content: [{ type: "text", text: JSON.stringify(res) }] };
         });
-        return { content: [{ type: "text", text: "Reinforced" }] };
-    });
-    server.registerTool("delete_memory", {
-        description: "Delete memory",
-        inputSchema: zod_1.z.object({ id: zod_1.z.string() }),
-    }, async (args) => {
-        const dbPath = process.env.OM_DB_PATH;
-        const sqlite3 = await import("sqlite3");
-        const db = new sqlite3.default.Database(dbPath);
-        return new Promise((resolve, reject) => {
-            db.serialize(() => {
-                db.run("DELETE FROM memories WHERE id = ?", [args.id]);
-                db.run("DELETE FROM vectors WHERE id = ?", [args.id], async (err) => {
-                    db.close();
-                    await logActivity("delete", {
-                        method: "DELETE",
-                        endpoint: `/memory/${args.id}`,
-                        status: err ? 500 : 200,
+        server.registerTool("update_memory", {
+            description: "Mutate existing memory (content/tags). HIGH COST: re-embeds and re-links. Use for corrections.",
+            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) => {
+            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");
+            }
+            const res = await sdk_update_memory(args.id, args.content, args.tags);
+            await logActivity("update", {
+                method: "PATCH",
+                endpoint: `/memory/${args.id}`,
+                status: 200,
+            });
+            return { content: [{ type: "text", text: JSON.stringify(res) }] };
+        });
+        server.registerTool("reinforce_memory", {
+            description: "Metabolic boost (salience). LOW COST: prevents decay without mutation. Use for active topics.",
+            inputSchema: zod_1.z.object({
+                id: zod_1.z.string(),
+                boost: zod_1.z.number().default(0.1),
+            }),
+        }, async (args) => {
+            if (!sdk_reinforce_memory)
+                throw new Error("Reinforce not available in SDK");
+            const res = await sdk_reinforce_memory(args.id, args.boost);
+            await logActivity("update", {
+                method: "POST",
+                endpoint: `/memory/${args.id}/reinforce`,
+                status: 200,
+            });
+            return { content: [{ type: "text", text: JSON.stringify(res) }] };
+        });
+        server.registerTool("delete_memory", {
+            description: "Delete memory",
+            inputSchema: zod_1.z.object({ id: zod_1.z.string() }),
+        }, async (args) => {
+            const dbPath = process.env.OM_DB_PATH;
+            const sqlite3 = await import("sqlite3");
+            const db = new sqlite3.default.Database(dbPath);
+            return new Promise((resolve, reject) => {
+                db.serialize(() => {
+                    db.run("DELETE FROM memories WHERE id = ?", [args.id]);
+                    db.run("DELETE FROM vectors WHERE id = ?", [args.id], async (err) => {
+                        db.close();
+                        await logActivity("delete", {
+                            method: "DELETE",
+                            endpoint: `/memory/${args.id}`,
+                            status: err ? 500 : 200,
+                        });
+                        if (err)
+                            reject(err);
+                        else
+                            resolve({ content: [{ type: "text", text: "Deleted" }] });
                     });
-                    if (err)
-                        reject(err);
-                    else
-                        resolve({ content: [{ type: "text", text: "Deleted" }] });
                 });
             });
         });
-    });
+        return server;
+    };
     // EXPRESS SERVER
     // HTTP server mode for Docker/Traefik deployment
     const useHttp = args.includes("--http") || args.includes("--port");
@@ -245,11 +284,10 @@ 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);
-            // next(); // DELETED! Correctly handled by requestContext.run
         });
         if (memory) {
             app.post("/add", async (req, res) => {
@@ -342,17 +380,70 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
                 });
             });
         }
-        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
-            sessionIdGenerator: () => crypto.randomUUID(),
+        // MULTI-SESSION SSE SUPPORT
+        const sessions = new Map();
+        // Legacy MCP endpoint - 410 Gone
+        app.all("/mcp", (req, res) => {
+            res
+                .status(410)
+                .send("Endpoint /mcp is deprecated. Please update your client configuration to use /sse for Server-Sent Events.");
         });
-        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.error(`CyberMem MCP running on http://localhost:${port}`));
+        app.get("/sse", async (req, res) => {
+            console.error("[MCP] Attempting SSE Connection...");
+            const transport = new sse_js_1.SSEServerTransport("/message", res);
+            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 });
+                transport.onclose = () => {
+                    console.error(`[MCP] SSE Connection Closed: ${transport.sessionId}`);
+                    sessions.delete(transport.sessionId);
+                };
+                transport.onerror = (err) => {
+                    console.error(`[MCP] SSE Connection Error: ${transport.sessionId}`, err);
+                    sessions.delete(transport.sessionId);
+                };
+                // await transport.start(); // FIXED: connect() starts it automatically
+            }
+            catch (err) {
+                console.error("[MCP] Failed to start SSE transport:", err);
+                sessions.delete(transport.sessionId);
+                // If headers haven't been sent, send 500
+                if (!res.headersSent) {
+                    res.status(500).send("Internal Server Error during SSE handshake");
+                }
+            }
+        });
+        app.post("/message", async (req, res) => {
+            const sessionId = req.query.sessionId;
+            const session = sessions.get(sessionId);
+            if (!session) {
+                res.status(404).send("Session not found");
+                return;
+            }
+            try {
+                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);
+                if (!res.headersSent) {
+                    res.status(500).send("Internal Server Error processing message");
+                }
+            }
         });
+        app.listen(port, () => console.error(`CyberMem MCP running on http://localhost:${port}`));
     }
     else {
+        // STDIO
         const transport = new stdio_js_1.StdioServerTransport();
+        const server = createConfiguredServer();
         server
             .connect(transport)
             .then(() => console.error("CyberMem MCP connected via STDIO"));

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.6",
+  "version": "0.14.10",
   "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

@@ -2,14 +2,36 @@ import "./console-fix.js";
 import "./env.js";
 
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 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>;
+  get(id: string): Promise<unknown>;
+  delete_all(user_id: string): Promise<unknown>;
+  wipe(): Promise<unknown>;
+}
+
 // Async Storage for Request Context (User ID and Client Name)
 const requestContext = new AsyncLocalStorage<{
   userId?: string;
@@ -19,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();
 
@@ -35,63 +67,20 @@ async function startServer() {
     process.env.CYBERMEM_ENV = "staging";
   }
 
-  let stdioClientName: string | undefined = undefined;
-
-  // 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")
-2. Store new insights immediately with add_memory (STABLE data)
-3. For corrections: use update_memory (STRUCTURAL mutation, high cost)
-4. To prevent decay: use reinforce_memory (METABOLIC boost, low cost)
-5. Always include tags: [topic, year, source:your-client-name]
-For full protocol: https://docs.cybermem.dev/agent-protocol`;
-
-  const server = new McpServer(
-    { name: "cybermem", version: "0.12.4" },
-    {
-      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,
-        },
-      ],
-    }),
-  );
-
-  // Capture client info from handshake
-  // @ts-ignore - access underlying server
-  server.server.setRequestHandler(InitializeRequestSchema, async (request) => {
-    stdioClientName = request.params.clientInfo.name;
-    console.error(`[MCP] Client identified via handshake: ${stdioClientName}`);
-    return {
-      protocolVersion: "2024-11-05",
-      capabilities: {
-        tools: { listChanged: true },
-        resources: { subscribe: true },
-      },
-      serverInfo: {
-        name: "cybermem",
-        version: "0.12.4",
-      },
-    };
-  });
-
   // --- IMPLEMENTATION LOGIC ---
 
-  let memory: any = null;
-  let sdk_update_memory: any = null;
-  let sdk_reinforce_memory: any = null;
+  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;
 
   // LOCAL SDK MODE
   const dbPath = process.env.OM_DB_PATH!;
@@ -107,8 +96,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
     const hsg = await import("openmemory-js/dist/memory/hsg.js");
     sdk_update_memory = hsg.update_memory;
     sdk_reinforce_memory = hsg.reinforce_memory;
-    memory = new Memory();
-    (server as any)._memoryReady = true;
+    memory = new Memory() as IMemory;
 
     // Initialize Tables
     const sqlite3 = await import("sqlite3");
@@ -151,30 +139,43 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
     });
   };
 
+  let stdioClientName: string | undefined = undefined;
+
+  // 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")
+2. Store new insights immediately with add_memory (STABLE data)
+3. For corrections: use update_memory (STRUCTURAL mutation, high cost)
+4. To prevent decay: use reinforce_memory (METABOLIC boost, low cost)
+5. Always include tags: [topic, year, source:your-client-name]
+For full protocol: https://docs.cybermem.dev/agent-protocol`;
+
   const logActivity = async (
     operation: string,
     opts: {
-      client?: string;
       method?: string;
       endpoint?: string;
       status?: number;
+      sessionId?: string;
     } = {},
   ) => {
-    if (!memory) return;
-    const {
-      client: providedClient,
-      method = "POST",
-      endpoint = "/mcp",
-      status = 200,
-    } = opts;
+    // Determine client name (priority: specific > store > default)
+    let client: string;
     const ctx = requestContext.getStore();
-    const client =
-      providedClient ||
-      ctx?.clientName ||
-      stdioClientName ||
-      "antigravity-client";
+
+    if (opts.sessionId) {
+      // 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 {
+      client = stdioClientName || "unknown";
+    }
+
+    const { method = "POST", endpoint = "/mcp", status = 200 } = opts;
     try {
-      const db = (await initLoggingDb()) as any;
+      const db = await initLoggingDb();
       const ts = Date.now();
       const is_error = status >= 400 ? 1 : 0;
       db.serialize(() => {
@@ -183,7 +184,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
           [
             ts,
             client,
-            "0.12.4",
+            PACKAGE_VERSION,
             method,
             endpoint,
             operation,
@@ -199,120 +200,190 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
     } catch {}
   };
 
-  // TOOLS
-  server.registerTool(
-    "add_memory",
-    {
-      description:
-        "Store a new memory. Use for high-quality, stable data. " +
-        CYBERMEM_INSTRUCTIONS,
-      inputSchema: z.object({
-        content: z.string(),
-        tags: z.array(z.string()).optional(),
-      }),
-    },
-    async (args: any) => {
-      const res = await memory!.add(args.content, { tags: args.tags });
-      await logActivity("create", {
-        method: "POST",
-        endpoint: "/memory/add",
-        status: 200,
-      });
-      return { content: [{ type: "text", text: JSON.stringify(res) }] };
-    },
-  );
+  // Factory to create configured McpServer instance
+  const createConfiguredServer = (
+    onClientConnected?: (name: string) => void,
+  ) => {
+    const server = new McpServer(
+      { name: "cybermem", version: PACKAGE_VERSION },
+      {
+        instructions: CYBERMEM_INSTRUCTIONS,
+      },
+    );
 
-  server.registerTool(
-    "query_memory",
-    {
-      description: "Search memories.",
-      inputSchema: z.object({ query: z.string(), k: z.number().default(5) }),
-    },
-    async (args: any) => {
-      const res = await memory!.search(args.query, { limit: args.k });
-      await logActivity("read", {
-        method: "POST",
-        endpoint: "/memory/query",
-        status: 200,
-      });
-      return { content: [{ type: "text", text: JSON.stringify(res) }] };
-    },
-  );
-
-  server.registerTool(
-    "update_memory",
-    {
-      description:
-        "Mutate existing memory (content/tags). HIGH COST: re-embeds and re-links. Use for corrections.",
-      inputSchema: z.object({
-        id: z.string(),
-        content: z.string().optional(),
-        tags: z.array(z.string()).optional(),
+    // 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",
+      "cybermem://protocol",
+      { description: "Instructions for AI agents", mimeType: "text/plain" },
+      async () => ({
+        contents: [
+          {
+            uri: "cybermem://protocol",
+            mimeType: "text/plain",
+            text: CYBERMEM_INSTRUCTIONS,
+          },
+        ],
       }),
-    },
-    async (args: any) => {
-      if (!sdk_update_memory) throw new Error("Update not available in SDK");
-      const res = await sdk_update_memory(args.id, args.content, args.tags);
-      await logActivity("update", {
-        method: "PATCH",
-        endpoint: `/memory/${args.id}`,
-        status: 200,
-      });
-      return { content: [{ type: "text", text: JSON.stringify(res) }] };
-    },
-  );
-
-  server.registerTool(
-    "reinforce_memory",
-    {
-      description:
-        "Metabolic boost (salience). LOW COST: prevents decay without mutation. Use for active topics.",
-      inputSchema: z.object({ id: z.string(), boost: z.number().default(0.1) }),
-    },
-    async (args: any) => {
-      if (!sdk_reinforce_memory)
-        throw new Error("Reinforce not available in SDK");
-      await sdk_reinforce_memory(args.id, args.boost);
-      await logActivity("update", {
-        method: "POST",
-        endpoint: `/memory/${args.id}/reinforce`,
-        status: 200,
-      });
-      return { content: [{ type: "text", text: "Reinforced" }] };
-    },
-  );
+    );
 
-  server.registerTool(
-    "delete_memory",
-    {
-      description: "Delete memory",
-      inputSchema: z.object({ id: z.string() }),
-    },
-    async (args: any) => {
-      const dbPath = process.env.OM_DB_PATH!;
-      const sqlite3 = await import("sqlite3");
-      const db = new sqlite3.default.Database(dbPath);
-      return new Promise((resolve, reject) => {
-        db.serialize(() => {
-          db.run("DELETE FROM memories WHERE id = ?", [args.id]);
-          db.run(
-            "DELETE FROM vectors WHERE id = ?",
-            [args.id],
-            async (err: any) => {
-              db.close();
-              await logActivity("delete", {
-                method: "DELETE",
-                endpoint: `/memory/${args.id}`,
-                status: err ? 500 : 200,
-              });
-              if (err) reject(err);
-              else resolve({ content: [{ type: "text", text: "Deleted" }] });
-            },
+    // access underlying server
+    server.server.setRequestHandler(
+      InitializeRequestSchema,
+      async (request) => {
+        // 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.
+        // 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: {
+            tools: { listChanged: true },
+            resources: { subscribe: true },
+          },
+          serverInfo: {
+            name: "cybermem",
+            version: PACKAGE_VERSION,
+          },
+        };
+      },
+    );
+
+    // TOOLS
+    server.registerTool(
+      "add_memory",
+      {
+        description:
+          "Store a new memory. Use for high-quality, stable data. " +
+          CYBERMEM_INSTRUCTIONS,
+        inputSchema: z.object({
+          content: z.string(),
+          tags: z.array(z.string()).optional(),
+        }),
+      },
+      async (args: { content: string; tags?: string[] }) => {
+        const res = await memory!.add(args.content, { tags: args.tags });
+        await logActivity("create", {
+          method: "POST",
+          endpoint: "/memory/add",
+          status: 200,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(res) }] };
+      },
+    );
+
+    server.registerTool(
+      "query_memory",
+      {
+        description: "Search memories.",
+        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 });
+        await logActivity("read", {
+          method: "POST",
+          endpoint: "/memory/query",
+          status: 200,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(res) }] };
+      },
+    );
+
+    server.registerTool(
+      "update_memory",
+      {
+        description:
+          "Mutate existing memory (content/tags). HIGH COST: re-embeds and re-links. Use for corrections.",
+        inputSchema: z.object({
+          id: z.string(),
+          content: z.string().optional(),
+          tags: z.array(z.string()).optional(),
+        }),
+      },
+      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",
           );
+        }
+        const res = await sdk_update_memory(args.id, args.content, args.tags);
+        await logActivity("update", {
+          method: "PATCH",
+          endpoint: `/memory/${args.id}`,
+          status: 200,
         });
-      });
-    },
-  );
+        return { content: [{ type: "text", text: JSON.stringify(res) }] };
+      },
+    );
+
+    server.registerTool(
+      "reinforce_memory",
+      {
+        description:
+          "Metabolic boost (salience). LOW COST: prevents decay without mutation. Use for active topics.",
+        inputSchema: z.object({
+          id: z.string(),
+          boost: z.number().default(0.1),
+        }),
+      },
+      async (args: { id: string; boost?: number }) => {
+        if (!sdk_reinforce_memory)
+          throw new Error("Reinforce not available in SDK");
+        const res = await sdk_reinforce_memory(args.id, args.boost);
+        await logActivity("update", {
+          method: "POST",
+          endpoint: `/memory/${args.id}/reinforce`,
+          status: 200,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(res) }] };
+      },
+    );
+
+    server.registerTool(
+      "delete_memory",
+      {
+        description: "Delete memory",
+        inputSchema: z.object({ id: z.string() }),
+      },
+      async (args: { id: string }) => {
+        const dbPath = process.env.OM_DB_PATH!;
+        const sqlite3 = await import("sqlite3");
+        const db = new sqlite3.default.Database(dbPath);
+        return new Promise((resolve, reject) => {
+          db.serialize(() => {
+            db.run("DELETE FROM memories WHERE id = ?", [args.id]);
+            db.run(
+              "DELETE FROM vectors WHERE id = ?",
+              [args.id],
+              async (err: Error | null) => {
+                db.close();
+                await logActivity("delete", {
+                  method: "DELETE",
+                  endpoint: `/memory/${args.id}`,
+                  status: err ? 500 : 200,
+                });
+                if (err) reject(err);
+                else resolve({ content: [{ type: "text", text: "Deleted" }] });
+              },
+            );
+          });
+        });
+      },
+    );
+
+    return server;
+  };
 
   // EXPRESS SERVER
   // HTTP server mode for Docker/Traefik deployment
@@ -322,13 +393,14 @@ 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 =
         (req.headers["x-client-name"] as string) || "antigravity-client";
       requestContext.run({ clientName }, next);
-      // next(); // DELETED! Correctly handled by requestContext.run
     });
 
     if (memory) {
@@ -427,25 +499,90 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
       });
     }
 
-    const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => crypto.randomUUID(),
+    // MULTI-SESSION SSE SUPPORT
+    const sessions = new Map<
+      string,
+      {
+        server: McpServer;
+        transport: SSEServerTransport;
+        clientName?: string;
+      }
+    >();
+
+    // Legacy MCP endpoint - 410 Gone
+    app.all("/mcp", (req, res) => {
+      res
+        .status(410)
+        .send(
+          "Endpoint /mcp is deprecated. Please update your client configuration to use /sse for Server-Sent Events.",
+        );
     });
-    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.error(`CyberMem MCP running on http://localhost:${port}`),
-      );
+    app.get("/sse", async (req, res) => {
+      console.error("[MCP] Attempting SSE Connection...");
+      const transport = new SSEServerTransport("/message", res);
+      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 });
+
+        transport.onclose = () => {
+          console.error(`[MCP] SSE Connection Closed: ${transport.sessionId}`);
+          sessions.delete(transport.sessionId);
+        };
+        transport.onerror = (err: Error) => {
+          console.error(
+            `[MCP] SSE Connection Error: ${transport.sessionId}`,
+            err,
+          );
+          sessions.delete(transport.sessionId);
+        };
+
+        // await transport.start(); // FIXED: connect() starts it automatically
+      } catch (err) {
+        console.error("[MCP] Failed to start SSE transport:", err);
+        sessions.delete(transport.sessionId);
+        // If headers haven't been sent, send 500
+        if (!res.headersSent) {
+          res.status(500).send("Internal Server Error during SSE handshake");
+        }
+      }
     });
+
+    app.post("/message", async (req, res) => {
+      const sessionId = req.query.sessionId as string;
+      const session = sessions.get(sessionId);
+      if (!session) {
+        res.status(404).send("Session not found");
+        return;
+      }
+      try {
+        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,
+        );
+        if (!res.headersSent) {
+          res.status(500).send("Internal Server Error processing message");
+        }
+      }
+    });
+
+    app.listen(port, () =>
+      console.error(`CyberMem MCP running on http://localhost:${port}`),
+    );
   } else {
+    // STDIO
     const transport = new StdioServerTransport();
+    const server = createConfiguredServer();
     server
       .connect(transport)
       .then(() => console.error("CyberMem MCP connected via STDIO"));