@cybermem/mcp 0.14.15 → 0.16.0

package/e2e/api.spec.ts

@@ -1,259 +1,205 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { expect, test } from "@playwright/test";
+import { spawn } from "child_process";
+import path from "path";
 
-const BASE_URL = process.env.MCP_URL
-  ? process.env.MCP_URL.replace(/\/mcp$/, "")
-  : "http://localhost:8626";
+import { FastMCPHandshakeTransport } from "./utils/FastMCPHandshakeTransport";
 
-// Tailscale environments require auth token
-const isLocalhost =
-  BASE_URL.includes("localhost") || BASE_URL.includes("127.0.0.1");
-const CYBERMEM_TOKEN = process.env.CYBERMEM_TOKEN || "";
-
-// Helper to build headers with optional auth
-function getHeaders(clientName: string): Record<string, string> {
-  const headers: Record<string, string> = { "X-Client-Name": clientName };
-  if (!isLocalhost && CYBERMEM_TOKEN) {
-    headers["X-API-Key"] = CYBERMEM_TOKEN;
-  }
-  return headers;
-}
+const PORT = 3102;
+const BASE_URL = `http://localhost:${PORT}`;
 
 // CRITICAL: MCP CRUD tests MUST run in serial order (each depends on the previous)
 test.describe.configure({ mode: "serial" });
 
-test.describe("MCP:E2E (Core CRUD)", () => {
+test.describe("MCP:E2E (Protocol Tool Calls)", () => {
+  let client: Client;
+  let transport: FastMCPHandshakeTransport;
   let memoryId: string;
-  const crudLog: Array<{
-    operation: string;
-    endpoint: string;
-    payload?: object;
-    status: number;
-    response: object;
-  }> = [];
-
-  test.beforeAll(async ({}, testInfo) => {
+  let serverProcess: any;
+
+  test.beforeAll(async () => {
+    // Spawn server
+    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:" },
+      },
+    );
+
+    await new Promise<void>((resolve, reject) => {
+      serverProcess.stderr?.on("data", (data: any) => {
+        const output = data.toString();
+        if (
+          output.includes(`CyberMem MCP running on http://localhost:${PORT}`)
+        ) {
+          resolve();
+        }
+      });
+      serverProcess.on("error", reject);
+      setTimeout(() => reject(new Error("Server start timeout")), 60000);
+    });
+
     console.log(`🔧 Testing against: ${BASE_URL}`);
 
-    // Attach environment info
-    await testInfo.attach("🔧 Test Environment", {
-      body: `Base URL: ${BASE_URL}\nTimestamp: ${new Date().toISOString()}\nClient: antigravity-client\nVersion: 0.13.0`,
-      contentType: "text/plain",
-    });
+    // Initialize MCP Client
+    client = new Client(
+      { name: "e2e-tester", version: "1.0.0" },
+      { capabilities: {} },
+    );
+
+    const sseUrl = new URL(`${BASE_URL}/mcp`);
+    const headers: Record<string, string> = {
+      "X-Client-Name": "antigravity-e2e",
+    };
+
+    transport = new FastMCPHandshakeTransport(sseUrl, headers);
+
+    console.log(`🔗 Connecting to MCP via Handshake: ${sseUrl.toString()}`);
+    await client.connect(transport);
+    console.log("✅ MCP Client connected");
+  });
+
+  test.afterAll(async () => {
+    if (transport) {
+      await transport.close();
+    }
+    if (serverProcess) {
+      serverProcess.kill();
+    }
+    // Clean up port 3102 just in case
+    spawn("sh", ["-c", `lsof -ti:${PORT} | xargs kill -9 || true`]);
   });
 
-  test("1. Create Memory (POST /add)", async ({ request }, testInfo) => {
+  test("1. Create Memory (add_memory)", async ({}, testInfo) => {
     const payload = {
-      content: `E2E Verification ${new Date().toISOString()}`,
-      tags: ["e2e", "automated"],
+      content: `E2E Protocol Verification ${new Date().toISOString()}`,
+      tags: ["e2e", "protocol", "mcp"],
     };
 
-    await test.step("📤 CRUD — POST /add — Create new memory", async () => {
-      console.log("📤 POST /add");
-      console.log("   Payload:", JSON.stringify(payload, null, 2));
-
-      const response = await request.post(`${BASE_URL}/add`, {
-        data: payload,
-        headers: {
-          ...getHeaders("antigravity-client"),
-          "X-Client-Version": "0.13.0",
-        },
-        timeout: 30000, // 30s timeout
-      });
+    await test.step("📤 Tool Call — add_memory", async () => {
+      console.log("📤 Calling tool: add_memory");
 
-      // Handle non-JSON responses gracefully
-      const status = response.status();
-      let body: any;
-
-      try {
-        body = await response.json();
-      } catch {
-        const text = await response.text();
-        throw new Error(
-          `Non-JSON response (status ${status}): ${text.substring(0, 200)}`,
-        );
-      }
-
-      console.log("   Status:", status);
-      console.log("   Response:", JSON.stringify(body, null, 2));
-
-      crudLog.push({
-        operation: "CREATE",
-        endpoint: "POST /add",
-        payload,
-        status,
-        response: body,
+      const result = await client.callTool({
+        name: "add_memory",
+        arguments: payload,
       });
 
-      expect(status).toBe(200);
+      console.log("   Result:", JSON.stringify(result, null, 2));
+
+      expect(result.isError).toBeFalsy();
+      const content = result.content as any[];
+      const body = JSON.parse(content[0].text);
       expect(body.id).toBeTruthy();
       memoryId = body.id;
       console.log(`   ✅ Memory ID: ${memoryId}`);
     });
 
-    // Attach CRUD operation to trace
-    await testInfo.attach("📝 CRUD — CREATE", {
-      body: `Endpoint: POST /add\n\nRequest:\n${JSON.stringify(payload, null, 2)}\n\nResponse:\n${JSON.stringify(crudLog[crudLog.length - 1]?.response, null, 2)}`,
+    await testInfo.attach("📝 Tool Call — CREATE", {
+      body: `Tool: add_memory\n\nArguments:\n${JSON.stringify(
+        payload,
+        null,
+        2,
+      )}`,
       contentType: "text/plain",
     });
   });
 
-  test("2. Read Memory (POST /query)", async ({ request }, testInfo) => {
-    await test.step("⏳ Wait — Vector Indexing Delay — 1 second", async () => {
+  test("2. Read Memory (query_memory)", async ({}, testInfo) => {
+    await test.step("⏳ Wait — Vector Indexing Delay", async () => {
       await new Promise((r) => setTimeout(r, 1000));
     });
 
-    const payload = { query: "Verification", k: 1 };
+    const payload = { query: "Protocol Verification", k: 1 };
 
-    await test.step("📤 CRUD — POST /query — Semantic search", async () => {
-      console.log("📤 POST /query");
-      console.log("   Payload:", JSON.stringify(payload, null, 2));
+    await test.step("📤 Tool Call — query_memory", async () => {
+      console.log("📤 Calling tool: query_memory");
 
-      const response = await request.post(`${BASE_URL}/query`, {
-        data: payload,
-        headers: getHeaders("antigravity-client"),
+      const result = await client.callTool({
+        name: "query_memory",
+        arguments: payload,
       });
 
-      const body = await response.json();
-      console.log("   Status:", response.status());
-      console.log("   Response:", JSON.stringify(body, null, 2));
+      console.log("   Result:", JSON.stringify(result, null, 2));
 
-      crudLog.push({
-        operation: "READ",
-        endpoint: "POST /query",
-        payload,
-        status: response.status(),
-        response: body,
-      });
-
-      expect(response.status()).toBe(200);
+      expect(result.isError).toBeFalsy();
+      const content = result.content as any[];
+      const body = JSON.parse(content[0].text);
       expect(Array.isArray(body)).toBe(true);
+      expect(body.length).toBeGreaterThan(0);
       console.log(`   ✅ Returned ${body.length} result(s)`);
     });
-
-    await testInfo.attach("📖 CRUD — READ", {
-      body: `Endpoint: POST /query\n\nRequest:\n${JSON.stringify(payload, null, 2)}\n\nResponse:\n${JSON.stringify(crudLog[crudLog.length - 1]?.response, null, 2)}`,
-      contentType: "text/plain",
-    });
   });
 
-  test("3. Update Memory (PATCH /memory/:id)", async ({
-    request,
-  }, testInfo) => {
+  test("3. Update Memory (update_memory)", async ({}, testInfo) => {
     test.skip(!memoryId, "Skipped — memoryId was not created in Step 1");
 
     const payload = {
-      content: `Updated E2E Context ${new Date().toISOString()}`,
-      tags: ["e2e", "updated"],
+      id: memoryId,
+      content: `Updated E2E Context via Protocol ${new Date().toISOString()}`,
+      tags: ["e2e", "protocol", "updated"],
     };
 
-    await test.step(`📤 CRUD — PATCH /memory/${memoryId} — Update content`, async () => {
-      console.log(`📤 PATCH /memory/${memoryId}`);
-      console.log("   Payload:", JSON.stringify(payload, null, 2));
+    await test.step("📤 Tool Call — update_memory", async () => {
+      console.log(`📤 Calling tool: update_memory for ${memoryId}`);
 
-      const response = await request.patch(`${BASE_URL}/memory/${memoryId}`, {
-        data: payload,
-        headers: getHeaders("antigravity-client"),
+      const result = await client.callTool({
+        name: "update_memory",
+        arguments: payload,
       });
 
-      const body = await response.json();
-      console.log("   Status:", response.status());
-      console.log("   Response:", JSON.stringify(body, null, 2));
+      console.log("   Result:", JSON.stringify(result, null, 2));
 
-      crudLog.push({
-        operation: "UPDATE",
-        endpoint: `PATCH /memory/${memoryId}`,
-        payload,
-        status: response.status(),
-        response: body,
-      });
-
-      expect(response.status()).toBe(200);
+      expect(result.isError).toBeFalsy();
       console.log(`   ✅ Memory updated successfully`);
     });
-
-    await testInfo.attach("✏️ CRUD — UPDATE", {
-      body: `Endpoint: PATCH /memory/${memoryId}\n\nRequest:\n${JSON.stringify(payload, null, 2)}\n\nResponse:\n${JSON.stringify(crudLog[crudLog.length - 1]?.response, null, 2)}`,
-      contentType: "text/plain",
-    });
   });
 
-  test("4. Reinforce Memory (POST /memory/:id/reinforce)", async ({
-    request,
-  }, testInfo) => {
+  test("4. Reinforce Memory (reinforce_memory)", async ({}, testInfo) => {
     test.skip(!memoryId, "Skipped — memoryId was not created in Step 1");
 
-    const payload = { boost: 0.5 };
+    const payload = { id: memoryId, boost: 0.5 };
 
-    await test.step(`📤 CRUD — POST /memory/${memoryId}/reinforce — Boost salience`, async () => {
-      console.log(`📤 POST /memory/${memoryId}/reinforce`);
-      console.log("   Payload:", JSON.stringify(payload, null, 2));
+    await test.step("📤 Tool Call — reinforce_memory", async () => {
+      console.log(`📤 Calling tool: reinforce_memory for ${memoryId}`);
 
-      const response = await request.post(
-        `${BASE_URL}/memory/${memoryId}/reinforce`,
-        {
-          data: payload,
-          headers: getHeaders("antigravity-client"),
-        },
-      );
-
-      const body = await response.json();
-      console.log("   Status:", response.status());
-      console.log("   Response:", JSON.stringify(body, null, 2));
-
-      crudLog.push({
-        operation: "REINFORCE",
-        endpoint: `POST /memory/${memoryId}/reinforce`,
-        payload,
-        status: response.status(),
-        response: body,
+      const result = await client.callTool({
+        name: "reinforce_memory",
+        arguments: payload,
       });
 
-      expect(response.status()).toBe(200);
-      console.log(`   ✅ Memory reinforced successfully`);
-    });
+      console.log("   Result:", JSON.stringify(result, null, 2));
 
-    await testInfo.attach("⚡ CRUD — REINFORCE", {
-      body: `Endpoint: POST /memory/${memoryId}/reinforce\n\nRequest:\n${JSON.stringify(payload, null, 2)}\n\nResponse:\n${JSON.stringify(crudLog[crudLog.length - 1]?.response, null, 2)}`,
-      contentType: "text/plain",
+      expect(result.isError).toBeFalsy();
+      console.log(`   ✅ Memory reinforced successfully`);
     });
   });
 
-  test("5. Delete Memory (DELETE /memory/:id)", async ({
-    request,
-  }, testInfo) => {
+  test("5. Delete Memory (delete_memory)", async ({}, testInfo) => {
     test.skip(!memoryId, "Skipped — memoryId was not created in Step 1");
 
-    await test.step(`📤 CRUD — DELETE /memory/${memoryId} — Hard delete from DB`, async () => {
-      console.log(`📤 DELETE /memory/${memoryId}`);
+    await test.step("📤 Tool Call — delete_memory", async () => {
+      console.log(`📤 Calling tool: delete_memory for ${memoryId}`);
 
-      const response = await request.delete(`${BASE_URL}/memory/${memoryId}`, {
-        headers: getHeaders("antigravity-client"),
+      const result = await client.callTool({
+        name: "delete_memory",
+        arguments: { id: memoryId },
       });
 
-      const body = await response.json();
-      console.log("   Status:", response.status());
-      console.log("   Response:", JSON.stringify(body, null, 2));
+      console.log("   Result:", JSON.stringify(result, null, 2));
 
-      crudLog.push({
-        operation: "DELETE",
-        endpoint: `DELETE /memory/${memoryId}`,
-        status: response.status(),
-        response: body,
-      });
-
-      expect(response.status()).toBe(200);
+      expect(result.isError).toBeFalsy();
       console.log(`   ✅ Memory deleted successfully`);
     });
-
-    await testInfo.attach("🗑️ CRUD — DELETE", {
-      body: `Endpoint: DELETE /memory/${memoryId}\n\nResponse:\n${JSON.stringify(crudLog[crudLog.length - 1]?.response, null, 2)}\n\n--- FULL CRUD LOG ---\n${crudLog.map((c) => `${c.operation}: ${c.endpoint} → ${c.status}`).join("\n")}`,
-      contentType: "text/plain",
-    });
-
-    // Attach full CRUD summary at the end
-    await testInfo.attach("📊 CRUD Lifecycle Complete", {
-      body: `Memory ID: ${memoryId}\n\nOperations Performed:\n${crudLog.map((c) => `✅ ${c.operation}: ${c.endpoint} → HTTP ${c.status}`).join("\n")}\n\nStorage State: CLEANED (memory deleted)`,
-      contentType: "text/plain",
-    });
   });
 });

package/e2e/sse_transport.spec.ts

@@ -2,14 +2,13 @@ import { expect, test } from "@playwright/test";
 import { ChildProcess, spawn } from "child_process";
 import path from "path";
 
-test.describe("MCP SSE Transport", () => {
+test.describe("MCP SSE Transport Handshake", () => {
   let serverProcess: ChildProcess;
-  const PORT = 3101; // Use unique port for this test
+  const PORT = 3101;
 
   test.setTimeout(120000);
 
   test.beforeAll(async () => {
-    // Start the server in http mode
     const serverPath = path.join(__dirname, "../dist/index.js");
     serverProcess = spawn(
       "node",
@@ -28,11 +27,9 @@ test.describe("MCP SSE Transport", () => {
       },
     );
 
-    // 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}`)
         ) {
@@ -45,37 +42,80 @@ test.describe("MCP SSE Transport", () => {
   });
 
   test.afterAll(() => {
-    serverProcess.kill();
+    if (serverProcess && !serverProcess.killed) {
+      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");
+  test("should establishment session and call tool via handshake", async () => {
+    const CLIENT_NAME = "e2e-handshake-tester";
 
-    // Read stream for a bit to ensure it doesn't close immediately due to error
-    const reader = response.body?.getReader();
-    expect(reader).toBeDefined();
+    // 1. Handshake (POST initialize)
+    const initResponse = await fetch(`http://localhost:${PORT}/mcp`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        "X-Client-Name": CLIENT_NAME,
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "e2e", version: "1.0.0" },
+        },
+      }),
+    });
 
-    const decoder = new TextDecoder();
-    let endpointFound = false;
+    expect(initResponse.status).toBe(200);
+    const sessionId = initResponse.headers.get("mcp-session-id");
+    const initBody = await initResponse.json();
+    console.log(
+      "[Test] Init Headers:",
+      JSON.stringify(Object.fromEntries(initResponse.headers.entries())),
+    );
+    console.log("[Test] Init Body:", JSON.stringify(initBody));
+    expect(sessionId).toBeDefined();
 
-    // 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;
-      }
-    }
+    // 2. Open Stream (GET)
+    const streamResponse = await fetch(`http://localhost:${PORT}/mcp`, {
+      headers: {
+        Accept: "text/event-stream",
+        "mcp-session-id": sessionId!,
+      },
+    });
+    expect(streamResponse.status).toBe(200);
+    const reader = streamResponse.body?.getReader();
 
-    expect(endpointFound).toBe(true);
+    // 3. Call Tool (POST)
+    const toolResponse = await fetch(`http://localhost:${PORT}/mcp`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        "mcp-session-id": sessionId!,
+        "X-Client-Name": CLIENT_NAME,
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: {
+          name: "add_memory",
+          arguments: { content: "Handshake Test Memory" },
+        },
+      }),
+    });
 
-    // Cleanup connection
-    await reader?.cancel();
+    expect(toolResponse.status).toBe(200);
+    const toolBody = await toolResponse.json();
+    console.log("[Test] Tool Result:", JSON.stringify(toolBody));
+    expect(toolBody.result).toBeDefined();
 
-    // Check if server process is still running (didn't crash)
-    expect(serverProcess.exitCode).toBeNull();
+    // Cleanup
+    await reader?.cancel();
   });
 });