@cybermem/mcp 0.14.15 → 0.15.0

package/e2e/sse_transport_multi.spec.ts

@@ -1,26 +1,18 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { expect, test } from "@playwright/test";
-import { ChildProcess, spawn } from "child_process";
+import { spawn } from "child_process";
 import path from "path";
 
-/**
- * MCP SSE Transport Multi-Session Test
- *
- * This test validates:
- * 1. Multiple concurrent SSE connections
- * 2. Handling of missing X-Client-Name headers
- * 3. Rapid connection establishment and teardown behavior
- * 4. Graceful handling of malformed SSE requests and overall server health
- *
- * Purpose: Prevent SSE transport regressions identified in 0.12-0.14 releases
- */
-test.describe("MCP SSE Transport - Multi-Session", () => {
-  let serverProcess: ChildProcess;
-  const PORT = 3102; // Unique port to avoid conflicts
-
-  test.setTimeout(120000);
+import { FastMCPHandshakeTransport } from "./utils/FastMCPHandshakeTransport";
+
+const PORT = 3103;
+const BASE_URL = `http://localhost:${PORT}`;
+
+test.describe("FastMCP SSE: Multi-Client Isolation", () => {
+  let serverProcess: any;
 
   test.beforeAll(async () => {
-    // Start the server in http mode with in-memory DB
+    // Spawn server with :memory: DB for isolation
     const serverPath = path.join(__dirname, "../dist/index.js");
     serverProcess = spawn(
       "node",
@@ -39,146 +31,90 @@ test.describe("MCP SSE Transport - Multi-Session", () => {
       },
     );
 
-    // Wait for server to start
     await new Promise<void>((resolve, reject) => {
-      let output = "";
-      const timeout = setTimeout(() => {
-        reject(new Error(`Server start timeout. Output: ${output}`));
-      }, 60000);
-
-      serverProcess.stderr?.on("data", (data) => {
-        const text = data.toString();
-        output += text;
-        console.log("[Server]", text);
-        if (text.includes(`CyberMem MCP running on http://localhost:${PORT}`)) {
-          clearTimeout(timeout);
+      serverProcess.stderr?.on("data", (data: any) => {
+        const output = data.toString();
+        if (
+          output.includes(`CyberMem MCP running on http://localhost:${PORT}`)
+        ) {
           resolve();
         }
       });
-
-      serverProcess.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      });
+      serverProcess.on("error", reject);
+      setTimeout(() => reject(new Error("Server start timeout")), 30000);
     });
   });
 
   test.afterAll(() => {
-    if (serverProcess && !serverProcess.killed) {
+    if (serverProcess) {
       serverProcess.kill();
     }
+    // Final cleanup of port just in case
+    spawn("sh", ["-c", `lsof -ti:${PORT} | xargs kill -9 || true`]);
   });
 
-  test("should handle multiple concurrent SSE connections", async () => {
-    const connections: Array<{
-      response: Response;
-      reader: ReadableStreamDefaultReader<Uint8Array>;
-    }> = [];
-
-    // Open 3 concurrent SSE connections
-    for (let i = 0; i < 3; i++) {
-      const response = await fetch(`http://localhost:${PORT}/sse`, {
-        headers: { "X-Client-Name": `test-client-${i}` },
-      });
-      expect(response.status).toBe(200);
-      expect(response.headers.get("content-type")).toBe("text/event-stream");
-
-      const reader = response.body!.getReader();
-      connections.push({ response, reader });
-    }
-
-    // Verify all connections receive endpoint events
-    const decoder = new TextDecoder();
-    for (let i = 0; i < connections.length; i++) {
-      let endpointFound = false;
-      const { reader } = connections[i];
-
-      for (let j = 0; j < 3; j++) {
-        const { value, done } = await reader.read();
-        if (done) break;
-        const text = decoder.decode(value);
-        console.log(`[Connection ${i}]`, text);
-        if (text.includes("event: endpoint")) {
-          endpointFound = true;
-          break;
-        }
-      }
-
-      expect(endpointFound).toBe(true);
+  test("Should support multiple clients with isolated sessions", async () => {
+    const clients: Client[] = [];
+    const transients: FastMCPHandshakeTransport[] = [];
+    const clientCount = 3;
+
+    console.log(`🚀 Starting Multi-Client Test (${clientCount} clients)`);
+
+    // 1. Establish sessions for all clients
+    for (let i = 0; i < clientCount; i++) {
+      const client = new Client(
+        { name: `multi-client-${i}`, version: "1.0.0" },
+        { capabilities: {} },
+      );
+      const transport = new FastMCPHandshakeTransport(
+        new URL(`${BASE_URL}/mcp`),
+        {
+          "X-Client-Name": `client-${i}`,
+        },
+      );
+
+      console.log(`  [Client ${i}] Connecting...`);
+      await client.connect(transport);
+      console.log(
+        `  [Client ${i}] Connected. Session ID: ${transport.sessionId}`,
+      );
+
+      clients.push(client);
+      transients.push(transport);
     }
 
-    // Cleanup all connections
-    for (const { reader } of connections) {
-      await reader.cancel();
-    }
+    // 2. Perform tool calls and verify identity propagation
+    for (let i = 0; i < clientCount; i++) {
+      const content = `Memory from client ${i} at ${new Date().toISOString()}`;
+      console.log(`  [Client ${i}] Calling add_memory...`);
 
-    // Server should still be running
-    expect(serverProcess.exitCode).toBeNull();
-  });
+      const result = await clients[i].callTool({
+        name: "add_memory",
+        arguments: { content, tags: ["multi", `client-${i}`] },
+      });
 
-  test("should handle connection with missing X-Client-Name header", async () => {
-    // Connection should still work but may not have proper client identification
-    const response = await fetch(`http://localhost:${PORT}/sse`);
-    expect(response.status).toBe(200);
-    expect(response.headers.get("content-type")).toBe("text/event-stream");
-
-    const reader = response.body!.getReader();
-    const decoder = new TextDecoder();
-    let endpointFound = false;
-
-    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;
-        break;
-      }
+      expect(result.isError).toBeFalsy();
+      console.log(`  [Client ${i}] ✅ Tool call successful`);
     }
 
-    expect(endpointFound).toBe(true);
-    await reader.cancel();
-  });
-
-  test("should handle rapid connection establishment and teardown", async () => {
-    // Simulate client reconnection scenarios
-    for (let i = 0; i < 5; i++) {
-      const response = await fetch(`http://localhost:${PORT}/sse`, {
-        headers: { "X-Client-Name": `rapid-test-${i}` },
+    // 3. Verify all clients can still query (sessions persist)
+    for (let i = 0; i < clientCount; i++) {
+      console.log(`  [Client ${i}] Querying memories...`);
+      const result = await clients[i].callTool({
+        name: "query_memory",
+        arguments: { query: `client-${i}`, k: 1 },
       });
-      expect(response.status).toBe(200);
-
-      const reader = response.body!.getReader();
 
-      // Read one chunk then immediately disconnect
-      await reader.read();
-      await reader.cancel();
+      const body = JSON.parse((result.content as any[])[0].text);
+      expect(body.length).toBeGreaterThan(0);
+      console.log(
+        `  [Client ${i}] ✅ Query successful, found ${body.length} records`,
+      );
     }
 
-    // Server should still be healthy
-    const healthResponse = await fetch(`http://localhost:${PORT}/health`);
-    expect(healthResponse.status).toBe(200);
-  });
-
-  test("should handle malformed SSE requests gracefully", async () => {
-    // POST to /sse should not crash the server
-    const postResponse = await fetch(`http://localhost:${PORT}/sse`, {
-      method: "POST",
-    });
-    // POST may return 404/405/400 depending on SDK version — just verify it's not 200
-    expect(postResponse.status).not.toBe(200);
-
-    // GET with suspicious headers should still work
-    const getResponse = await fetch(`http://localhost:${PORT}/sse`, {
-      method: "GET",
-      headers: { "X-Forwarded-For": "attacker.com" },
-    });
-    expect(getResponse.status).toBe(200);
-    const reader = getResponse.body!.getReader();
-    await reader.cancel();
-
-    // Server should still be healthy after both requests
-    const healthResponse = await fetch(`http://localhost:${PORT}/health`);
-    expect(healthResponse.status).toBe(200);
+    // 4. Cleanup
+    for (const transport of transients) {
+      await transport.close();
+    }
   });
 });

package/e2e/utils/FastMCPHandshakeTransport.ts

@@ -0,0 +1,183 @@
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import {
+    JSONRPCMessage,
+    JSONRPCMessageSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+/**
+ * Shared transport for FastMCP httpStream mode.
+ * Uses manual fetch reader instead of EventSource for Node.js reliability.
+ *
+ * Extracted into a shared utility to avoid duplication across test files.
+ */
+export class FastMCPHandshakeTransport implements Transport {
+  public sessionId: string | undefined = undefined;
+  private endpoint: URL;
+  private headers: Record<string, string>;
+  private abortController: AbortController | null = null;
+  private isClosing = false;
+  private streamReady: Promise<void> | null = null;
+
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+
+  constructor(
+    endpoint: URL,
+    headers: Record<string, string> = {},
+    private clientName: string = "test-client",
+  ) {
+    this.endpoint = endpoint;
+    this.headers = headers;
+  }
+
+  async start(): Promise<void> {
+    // 1. Handshake (POST)
+    const initResponse = await fetch(this.endpoint.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        ...this.headers,
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: "handshake",
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: this.clientName, version: "1.0.0" },
+        },
+      }),
+    });
+
+    if (!initResponse.ok) {
+      throw new Error(`Handshake failed: ${initResponse.status}`);
+    }
+
+    this.sessionId = initResponse.headers.get("mcp-session-id") || undefined;
+    if (!this.sessionId) {
+      throw new Error("No mcp-session-id received");
+    }
+
+    // 2. Start Stream (GET)
+    this.abortController = new AbortController();
+    const streamResponse = await fetch(this.endpoint.toString(), {
+      headers: {
+        ...this.headers,
+        Accept: "text/event-stream",
+        "mcp-session-id": this.sessionId,
+      },
+      signal: this.abortController.signal,
+    });
+
+    if (!streamResponse.ok) {
+      throw new Error(`Stream establishment failed: ${streamResponse.status}`);
+    }
+
+    // Event-driven stream readiness: resolve when the first chunk is received
+    let resolveStreamReady: () => void;
+    this.streamReady = new Promise((r) => {
+      resolveStreamReady = r;
+    });
+
+    this.readStream(streamResponse.body!, () => resolveStreamReady()).catch(
+      (err) => {
+        if (!this.isClosing) {
+          console.error("   [Transport] Stream error:", err);
+          this.onerror?.(err);
+        }
+      },
+    );
+
+    // Wait for stream to be established (first chunk received or timeout)
+    await Promise.race([
+      this.streamReady,
+      new Promise((r) => setTimeout(r, 2000)),
+    ]);
+  }
+
+  private async readStream(
+    body: ReadableStream<Uint8Array>,
+    onFirstChunk?: () => void,
+  ) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let firstChunkReceived = false;
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        // Signal stream readiness on first data
+        if (!firstChunkReceived) {
+          firstChunkReceived = true;
+          onFirstChunk?.();
+        }
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+
+        for (const line of lines) {
+          if (line.trim() === "") continue;
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6).trim();
+            if (data) {
+              try {
+                const message = JSONRPCMessageSchema.parse(JSON.parse(data));
+                this.onmessage?.(message);
+              } catch (err) {
+                // Not a valid JSON-RPC message, skip
+              }
+            }
+          }
+        }
+      }
+    } catch (err) {
+      if (!this.isClosing) {
+        console.error("   [Transport] Reader error:", err);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  async send(message: JSONRPCMessage): Promise<void> {
+    if (!this.sessionId) throw new Error("Not connected");
+
+    const response = await fetch(this.endpoint.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        "mcp-session-id": this.sessionId,
+        ...this.headers,
+      },
+      body: JSON.stringify(message),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to send message: ${response.status}`);
+    }
+
+    // If result is in the response (enableJsonResponse: true), emit it
+    if (response.headers.get("Content-Type")?.includes("application/json")) {
+      try {
+        const body = await response.json();
+        this.onmessage?.(body);
+      } catch (err) {
+        // Not JSON or empty (e.g. 202 accepted) - ignore
+      }
+    }
+  }
+
+  async close(): Promise<void> {
+    this.isClosing = true;
+    this.abortController?.abort();
+    this.onclose?.();
+  }
+}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@cybermem/mcp",
-  "version": "0.14.15",
+  "version": "0.15.0",
   "description": "CyberMem MCP Server - AI Memory with openmemory-js SDK",
   "main": "dist/index.js",
   "bin": {
     "cybermem-mcp": "./dist/index.js"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && npm run postbuild",
+    "postbuild": "node scripts/postbuild.js",
     "start": "node dist/index.js",
     "dev": "ts-node src/index.ts",
     "lint": "tsc --noEmit",
@@ -38,22 +39,18 @@
     "access": "public"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "cors": "^2.8.5",
     "dotenv": "^16.0.0",
-    "express": "^5.2.1",
-    "open": "^11.0.0",
+    "fastmcp": "^3.33.0",
     "openmemory-js": "1.3.0",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7",
     "zod": "^3.25.76"
   },
   "devDependencies": {
+    "@modelcontextprotocol/inspector": "^0.19.0",
     "@playwright/test": "^1.57.0",
-    "@types/cors": "^2.8.19",
-    "@types/express": "^5.0.6",
     "@types/node": "^18.0.0",
-    "@modelcontextprotocol/inspector": "^0.19.0",
+    "eventsource": "^4.1.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.0.0"
   }

package/scripts/postbuild.js

@@ -0,0 +1,24 @@
+const fs = require("fs");
+const path = require("path");
+
+const distFile = path.join(__dirname, "..", "dist", "index.js");
+if (!fs.existsSync(distFile)) {
+  console.error("dist/index.js not found");
+  process.exit(1);
+}
+
+let content = fs.readFileSync(distFile, "utf8");
+const shebang = "#!/usr/bin/env node\n";
+
+if (!content.startsWith(shebang)) {
+  console.log("Adding shebang to dist/index.js");
+  content = shebang + content;
+  fs.writeFileSync(distFile, content);
+}
+
+try {
+  fs.chmodSync(distFile, 0o755);
+  console.log("Set executable permissions for dist/index.js");
+} catch (err) {
+  console.warn("Could not set executable permissions:", err.message);
+}