@cybermem/dashboard 0.14.14 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @cybermem/dashboard
 
+## 0.15.0
+
+### Minor Changes
+
+- [#138](https://github.com/mikhailkogan17/cybermem/pull/138) [`2a201d4`](https://github.com/mikhailkogan17/cybermem/commit/2a201d4c6086dfd3f37dd2fadce75ffe940c4113) Thanks [@mikhailkogan17-antigravity](https://github.com/mikhailkogan17-antigravity)! - Moved server tools usage to FastMCP
+
+## 0.14.15
+
+### Patch Changes
+
+- Automated patch version bump.
+
 ## 0.14.14
 
 ### Patch Changes

package/app/api/audit-logs/route.ts

@@ -91,17 +91,21 @@ export async function GET(request: Request) {
         status = "Error";
       else if (statusCode >= 300) status = "Warning";
 
-      let operation = log.operation.toLowerCase();
-      if (operation === "create") operation = "Write";
-      else if (operation === "read") operation = "Read";
-      else if (operation === "update") operation = "Update";
-      else if (operation === "delete") operation = "Delete";
-      else operation = operation.charAt(0).toUpperCase() + operation.slice(1);
+      const rawTool = log.tool ?? "unknown";
+      let toolDisplayName = String(rawTool).toLowerCase();
+      // Friendly labels for core tools if needed
+      if (toolDisplayName === "add_memory") toolDisplayName = "Write";
+      else if (toolDisplayName === "query_memory") toolDisplayName = "Read";
+      else if (toolDisplayName === "update_memory") toolDisplayName = "Update";
+      else if (toolDisplayName === "delete_memory") toolDisplayName = "Delete";
+      else
+        toolDisplayName =
+          toolDisplayName.charAt(0).toUpperCase() + toolDisplayName.slice(1);
 
       return {
         timestamp: log.timestamp,
         client: normalizeClientName(log.client_name),
-        operation: operation,
+        tool: toolDisplayName,
         status: status,
         method: log.method,
         description: log.endpoint,

package/app/api/metrics/route.ts

@@ -101,10 +101,10 @@ export async function GET(request: Request) {
           "SELECT COUNT(*) as count FROM cybermem_access_log WHERE is_error = 1",
         );
         const lastWrite = await db.get(
-          "SELECT client_name, timestamp FROM cybermem_access_log WHERE operation = 'create' ORDER BY timestamp DESC LIMIT 1",
+          "SELECT client_name, timestamp FROM cybermem_access_log WHERE tool = 'add_memory' ORDER BY timestamp DESC LIMIT 1",
         );
         const lastRead = await db.get(
-          "SELECT client_name, timestamp FROM cybermem_access_log WHERE operation = 'read' ORDER BY timestamp DESC LIMIT 1",
+          "SELECT client_name, timestamp FROM cybermem_access_log WHERE tool = 'query_memory' ORDER BY timestamp DESC LIMIT 1",
         );
         const uniqueClients = await db.get(
           "SELECT COUNT(DISTINCT client_name) as count FROM cybermem_access_log",
@@ -135,10 +135,10 @@ export async function GET(request: Request) {
 
         // Top activity
         const topWriter = await db.get(
-          "SELECT client_name, COUNT(*) as count FROM cybermem_access_log WHERE operation = 'create' GROUP BY client_name ORDER BY count DESC LIMIT 1",
+          "SELECT client_name, COUNT(*) as count FROM cybermem_access_log WHERE tool = 'add_memory' GROUP BY client_name ORDER BY count DESC LIMIT 1",
         );
         const topReader = await db.get(
-          "SELECT client_name, COUNT(*) as count FROM cybermem_access_log WHERE operation = 'read' GROUP BY client_name ORDER BY count DESC LIMIT 1",
+          "SELECT client_name, COUNT(*) as count FROM cybermem_access_log WHERE tool = 'query_memory' GROUP BY client_name ORDER BY count DESC LIMIT 1",
         );
 
         if (topWriter)
@@ -164,27 +164,27 @@ export async function GET(request: Request) {
 
         // Strip any potential native proxy bits from sqlite3 results
         const rawAllLogs = await db.all(
-          `SELECT timestamp, operation, client_name FROM cybermem_access_log WHERE timestamp > ? ORDER BY timestamp ASC`,
+          `SELECT timestamp, tool, client_name FROM cybermem_access_log WHERE timestamp > ? ORDER BY timestamp ASC`,
           [startTime],
         );
         const allLogs = JSON.parse(JSON.stringify(rawAllLogs || []));
 
         const rawBaseCounts = await db.all(
-          `SELECT operation, client_name, COUNT(*) as count FROM cybermem_access_log WHERE timestamp <= ? GROUP BY 1, 2`,
+          `SELECT tool, client_name, COUNT(*) as count FROM cybermem_access_log WHERE timestamp <= ? GROUP BY 1, 2`,
           [startTime],
         );
         const baseCounts = JSON.parse(JSON.stringify(rawBaseCounts || []));
 
-        const buildBeautifulSeries = (targetOp: string) => {
+        const buildBeautifulSeries = (targetTool: string) => {
           const clientTotals: Record<string, number> = {};
           baseCounts
-            .filter((b: any) => b.operation === targetOp)
+            .filter((b: any) => b.tool === targetTool)
             .forEach((b: any) => {
               clientTotals[b.client_name] = b.count;
             });
 
           const series: any[] = [];
-          const opLogs = allLogs.filter((l: any) => l.operation === targetOp);
+          const toolLogs = allLogs.filter((l: any) => l.tool === targetTool);
           const SAMPLES = 60;
           const interval = (now - startTime) / SAMPLES;
           let currentLogIdx = 0;
@@ -192,10 +192,10 @@ export async function GET(request: Request) {
           for (let i = 0; i <= SAMPLES; i++) {
             const timePoint = startTime + i * interval;
             while (
-              currentLogIdx < opLogs.length &&
-              opLogs[currentLogIdx].timestamp <= timePoint
+              currentLogIdx < toolLogs.length &&
+              toolLogs[currentLogIdx].timestamp <= timePoint
             ) {
-              const log = opLogs[currentLogIdx];
+              const log = toolLogs[currentLogIdx];
               clientTotals[log.client_name] =
                 (clientTotals[log.client_name] || 0) + 1;
               currentLogIdx++;
@@ -208,10 +208,10 @@ export async function GET(request: Request) {
           return series;
         };
 
-        timeseries.creates = buildBeautifulSeries("create");
-        timeseries.reads = buildBeautifulSeries("read");
-        timeseries.updates = buildBeautifulSeries("update");
-        timeseries.deletes = buildBeautifulSeries("delete");
+        timeseries.creates = buildBeautifulSeries("add_memory");
+        timeseries.reads = buildBeautifulSeries("query_memory");
+        timeseries.updates = buildBeautifulSeries("update_memory");
+        timeseries.deletes = buildBeautifulSeries("delete_memory");
 
         console.error(`[STATS-API] SQLite + Charts processed successfully.`);
       } catch (dbErr) {

package/components/dashboard/logs/log-viewer.tsx

@@ -87,20 +87,14 @@ export default function LogViewer({
   };
 
   const exportToCSV = () => {
-    const headers = [
-      "Timestamp",
-      "Client",
-      "Operation",
-      "Description",
-      "Status",
-    ];
+    const headers = ["Timestamp", "Client", "Tool", "Description", "Status"];
     const csvContent = [
       headers.join(","),
       ...logs.map((log) =>
         [
           `"${log.date}"`,
           `"${getClientDisplayName(log.client)}"`,
-          `"${log.operation}"`,
+          `"${log.tool}"`,
           `"${log.description}"`,
           `"${log.status}"`,
         ].join(","),
@@ -122,7 +116,7 @@ export default function LogViewer({
       logs.map((log) => ({
         timestamp: log.date,
         client: getClientDisplayName(log.client),
-        operation: log.operation,
+        tool: log.tool,
         description: log.description,
         status: log.status,
       })),
@@ -134,7 +128,9 @@ export default function LogViewer({
     const url = URL.createObjectURL(blob);
     const a = document.createElement("a");
     a.href = url;
-    a.download = `cybermem-audit-${new Date().toISOString().split("T")[0]}.json`;
+    a.download = `cybermem-audit-${
+      new Date().toISOString().split("T")[0]
+    }.json`;
     a.click();
     URL.revokeObjectURL(url);
     setShowExportMenu(false);
@@ -198,7 +194,7 @@ export default function LogViewer({
                 {[
                   { label: "Timestamp", key: "date", width: "w-[180px]" },
                   { label: "Client", key: "client", width: "w-[200px]" },
-                  { label: "Operation", key: "operation", width: "w-[100px]" },
+                  { label: "Tool", key: "tool", width: "w-[100px]" },
                   { label: "Description", key: "description", width: "flex-1" },
                   { label: "Status", key: "status", width: "w-[100px]" },
                 ].map((header) => (
@@ -281,7 +277,7 @@ export default function LogViewer({
                           </div>
                         </td>
                         <td className="py-4 px-3 text-neutral-300">
-                          {log.operation}
+                          {log.tool}
                         </td>
                         <td className="py-4 px-3 text-neutral-400">
                           {log.description}

package/e2e/api.spec.ts

@@ -44,6 +44,114 @@ function runCLI(cmd: string): { stdout: string; success: boolean } {
   }
 }
 
+// MCP JSON-RPC helper using Node fetch (handles SSE responses from FastMCP)
+async function mcpRpc(
+  method: string,
+  params: any = {},
+  id: number | null = 1,
+  sessionId?: string,
+  clientName: string = "antigravity-client",
+): Promise<{ body: any; status: number; sessionId?: string }> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Accept: "application/json, text/event-stream",
+    "X-Client-Name": clientName,
+  };
+  if (!isLocalhost && CYBERMEM_TOKEN) {
+    headers["X-API-Key"] = CYBERMEM_TOKEN;
+  }
+  if (sessionId) headers["Mcp-Session-Id"] = sessionId;
+
+  const payload: any = { jsonrpc: "2.0", method, params: params || {} };
+  if (id !== null) payload.id = id;
+
+  const resp = await fetch(`${MCP_API_URL}/mcp`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload),
+  });
+
+  const newSessionId = resp.headers.get("mcp-session-id") || sessionId;
+  const contentType = resp.headers.get("content-type") || "";
+
+  // For notifications (no id), the server returns 202 with no body
+  if (id === null || resp.status === 202) {
+    return { body: {}, status: resp.status, sessionId: newSessionId };
+  }
+
+  // If JSON, parse directly
+  if (contentType.includes("application/json")) {
+    const body = await resp.json();
+    return { body, status: resp.status, sessionId: newSessionId };
+  }
+
+  // If SSE, parse data lines from the stream
+  if (contentType.includes("text/event-stream")) {
+    const reader = resp.body!.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let result: any = null;
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6).trim();
+            if (data) {
+              try {
+                const parsed = JSON.parse(data);
+                // Take the first response that matches our request id
+                if (parsed.id === id || !result) {
+                  result = parsed;
+                }
+              } catch {
+                /* continuation frame */
+              }
+            }
+          }
+        }
+
+        // Once we have a result, stop reading
+        if (result) {
+          reader.cancel().catch(() => {});
+          break;
+        }
+      }
+    } catch {
+      // Stream ended or was cancelled
+    }
+
+    if (!result) {
+      throw new Error(`No SSE data received for method=${method}`);
+    }
+    return { body: result, status: resp.status, sessionId: newSessionId };
+  }
+
+  // Fallback: try to read as text and parse as JSON
+  const text = await resp.text();
+  try {
+    return {
+      body: JSON.parse(text),
+      status: resp.status,
+      sessionId: newSessionId,
+    };
+  } catch {
+    throw new Error(
+      `Failed to parse MCP response for method=${method}: ${text.slice(
+        0,
+        200,
+      )}`,
+    );
+  }
+}
+
 test.describe("Dashboard:E2E:API (Deep Verification)", () => {
   const TEST_CLIENT = `e2e-api-journey-${Date.now()}`;
 
@@ -72,7 +180,11 @@ test.describe("Dashboard:E2E:API (Deep Verification)", () => {
       expect(body.services.length).toBeGreaterThan(0);
 
       await testInfo.attach("📊 Health Check Result", {
-        body: `Status: ${response.status()}\nOverall: ${body.overall}\nServices: ${body.services.map((s: any) => `${s.name}: ${s.status}`).join(", ")}`,
+        body: `Status: ${response.status()}\nOverall: ${
+          body.overall
+        }\nServices: ${body.services
+          .map((s: any) => `${s.name}: ${s.status}`)
+          .join(", ")}`,
         contentType: "text/plain",
       });
     });
@@ -87,51 +199,106 @@ test.describe("Dashboard:E2E:API (Deep Verification)", () => {
     console.log(`   Test Client: ${TEST_CLIENT}`);
     console.log(`   Content: ${uniqueContent}`);
 
-    // Step 1: Trigger MCP Write
-    await test.step("📤 CRUD — POST /add — Create new memory", async () => {
-      console.log("📤 POST /add (MCP API)");
-      console.log(
-        `   Payload: { content: "${uniqueContent}", tags: ["journey"] }`,
-      );
-
-      const resp = await request.post(`${MCP_API_URL}/add`, {
-        data: { content: uniqueContent, tags: ["journey"] },
-        headers: getHeaders(TEST_CLIENT),
-      });
+    // Step 1: Initialize MCP Session
+    let sessionId: string | undefined;
 
-      console.log(`   Status: ${resp.status()}`);
-      const body = await resp.json();
-      console.log(`   Response: ${JSON.stringify(body, null, 2)}`);
+    await test.step("🤝 MCP — Initialize Session", async () => {
+      console.log("🤝 JSON-RPC: initialize");
+      const initRes = await mcpRpc(
+        "initialize",
+        {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: TEST_CLIENT, version: "1.0.0" },
+        },
+        1,
+        undefined,
+        TEST_CLIENT,
+      );
+      expect(initRes.status).toBe(200);
+      sessionId = initRes.sessionId;
+      console.log(`   Session ID: ${sessionId}`);
+
+      // Send initialized notification
+      await mcpRpc(
+        "notifications/initialized",
+        {},
+        null,
+        sessionId,
+        TEST_CLIENT,
+      );
+    });
 
-      expect(resp.status()).toBe(200);
+    // Step 2: Trigger MCP Write via JSON-RPC
+    await test.step("📤 CRUD — POST /mcp — Create new memory", async () => {
+      console.log("📤 POST /mcp (JSON-RPC: tools/call add_memory)");
+
+      let rpcRes: any;
+      for (let i = 0; i < 3; i++) {
+        rpcRes = await mcpRpc(
+          "tools/call",
+          {
+            name: "add_memory",
+            arguments: {
+              content: uniqueContent,
+              tags: ["journey"],
+            },
+          },
+          2,
+          sessionId,
+          TEST_CLIENT,
+        );
+        if (rpcRes.status === 200 && !rpcRes.body.result?.isError) break;
+        console.log(`   ⚠️ Attempt ${i + 1} failed, retrying...`);
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
 
-      await testInfo.attach("📝 CRUD — CREATE", {
-        body: `Endpoint: POST ${MCP_API_URL}/add\n\nRequest:\n{\n  "content": "${uniqueContent}",\n  "tags": ["journey"]\n}\n\nResponse:\n${JSON.stringify(body, null, 2)}`,
+      console.log(`   Status: ${rpcRes.status}`);
+      console.log(`   Response: ${JSON.stringify(rpcRes.body, null, 2)}`);
+
+      expect(rpcRes.status).toBe(200);
+      expect(
+        rpcRes.body.result,
+        `RPC response result missing. Body: ${JSON.stringify(rpcRes.body)}`,
+      ).toBeDefined();
+      expect(rpcRes.body.result.isError).not.toBe(true);
+
+      await testInfo.attach("📝 CRUD — CREATE (RPC)", {
+        body: `Endpoint: POST ${RAW_MCP_URL}/mcp\nSession: ${sessionId}\nResponse:\n${JSON.stringify(
+          rpcRes.body,
+          null,
+          2,
+        )}`,
         contentType: "text/plain",
       });
     });
 
-    // Step 2: Verify Metrics
+    // Step 3: Verify Metrics in Dashboard
     await test.step("📊 Discovery — Metrics Reflect Write Activity", async () => {
       console.log("📊 GET /api/metrics");
 
-      const resp = await request.get(`${DASHBOARD_URL}/api/metrics`, {
-        headers: getHeaders("antigravity-client"),
+      // Use unique URL to avoid caching issues in playwright if any
+      const metricsUrl = `${DASHBOARD_URL}/api/metrics?t=${Date.now()}`;
+      const metricsResp = await request.get(metricsUrl, {
+        headers: { "X-Client-Name": "e2e-api-metrics-check" },
       });
+      const data = await metricsResp.json();
 
-      const data = await resp.json();
-      console.log(`   Last Writer: ${data.stats.lastWriter.name}`);
+      console.log(`   Last Writer: ${data.stats.lastWriter?.name || "N/A"}`);
       console.log(`   Total Requests: ${data.stats.totalRequests}`);
       console.log(
-        `   Creates Time Series Length: ${data.timeSeries.creates.length}`,
+        `   Creates Time Series Length: ${
+          data.timeSeries?.creates?.length || 0
+        }`,
       );
 
+      // Verify that the dashboard reports the unique E2E test client
       expect(data.stats.lastWriter.name).toContain(TEST_CLIENT);
       expect(data.stats.totalRequests).toBeGreaterThan(0);
 
       await testInfo.attach("📊 Metrics Snapshot", {
-        body: `Last Writer: ${data.stats.lastWriter.name}\nTotal Requests: ${data.stats.totalRequests}\nCreates Time Series: ${data.timeSeries.creates.length} entries`,
-        contentType: "text/plain",
+        body: JSON.stringify(data, null, 2),
+        contentType: "application/json",
       });
     });
 
@@ -153,10 +320,12 @@ test.describe("Dashboard:E2E:API (Deep Verification)", () => {
       }
 
       expect(latestLog).toBeDefined();
-      expect(latestLog.operation).toBe("Write");
+      expect(latestLog.tool).toBe("Write");
 
       await testInfo.attach("📋 Audit Log Entry", {
-        body: `Found: ${latestLog ? "YES" : "NO"}\nClient: ${latestLog?.client}\nOperation: ${latestLog?.operation}\nStatus: ${latestLog?.status}`,
+        body: `Found: ${latestLog ? "YES" : "NO"}\nClient: ${
+          latestLog?.client
+        }\nTool: ${latestLog?.tool}\nStatus: ${latestLog?.status}`,
         contentType: "text/plain",
       });
     });
@@ -164,7 +333,7 @@ test.describe("Dashboard:E2E:API (Deep Verification)", () => {
     console.log("✅ FULL JOURNEY TEST COMPLETE");
 
     await testInfo.attach("✅ Journey Complete", {
-      body: `Test Client: ${TEST_CLIENT}\nContent: ${uniqueContent}\n\nVerified:\n✅ MCP Write (POST /add)\n✅ Metrics (GET /api/metrics) — Last Writer confirmed\n✅ Audit Logs (GET /api/audit-logs) — Entry found`,
+      body: `Test Client: ${TEST_CLIENT}\nContent: ${uniqueContent}\n\nVerified:\n✅ MCP Write (POST /mcp)\n✅ Metrics (GET /api/metrics) — Last Writer confirmed\n✅ Audit Logs (GET /api/audit-logs) — Entry found`,
       contentType: "text/plain",
     });
   });
@@ -189,7 +358,9 @@ test.describe("Dashboard:E2E:API (Deep Verification)", () => {
       expect(config.config.mcpServers).toBeDefined();
 
       await testInfo.attach("⚙️ MCP Config", {
-        body: `Config Type: ${config.configType}\nmcpServers: ${Object.keys(config.config.mcpServers).join(", ")}`,
+        body: `Config Type: ${config.configType}\nmcpServers: ${Object.keys(
+          config.config.mcpServers,
+        ).join(", ")}`,
         contentType: "text/plain",
       });
     });
@@ -211,7 +382,11 @@ test.describe("Dashboard:E2E:API (Deep Verification)", () => {
       expect(settings).toHaveProperty("endpoint");
 
       await testInfo.attach("⚙️ Settings", {
-        body: `Instance Type: ${settings.instanceType}\nEndpoint: ${settings.endpoint}\nAPI Key: ${settings.apiKey ? "***" + settings.apiKey.slice(-4) : "N/A"}`,
+        body: `Instance Type: ${settings.instanceType}\nEndpoint: ${
+          settings.endpoint
+        }\nAPI Key: ${
+          settings.apiKey ? "***" + settings.apiKey.slice(-4) : "N/A"
+        }`,
         contentType: "text/plain",
       });
     });

package/e2e/ui.spec.ts

@@ -48,7 +48,9 @@ async function setupNetworkLogging(
         .map((l) =>
           l.type === "REQUEST"
             ? `📤 ${l.method} ${l.url}`
-            : `📥 ${l.status} ${l.url}${l.body ? `\n   ${l.body.substring(0, 200)}...` : ""}`,
+            : `📥 ${l.status} ${l.url}${
+                l.body ? `\n   ${l.body.substring(0, 200)}...` : ""
+              }`,
         )
         .join("\n"),
       contentType: "text/plain",
@@ -176,11 +178,11 @@ test.describe("Dashboard:E2E:UI (High-Fidelity Mocks)", () => {
                 id: "log-1",
                 timestamp: Date.now(), // Use numeric timestamp for proper formatting
                 client: MOCK_IDENTITY_WRITER,
-                operation: "Write",
+                tool: "Write",
                 method: "POST",
-                endpoint: "/add",
+                endpoint: "/mcp",
                 status: "Success",
-                description: "/add",
+                description: "/mcp",
               },
             ],
             pagination: { currentPage: 1, totalPages: 1, totalItems: 1 },
@@ -239,7 +241,9 @@ test.describe("Dashboard:E2E:UI (High-Fidelity Mocks)", () => {
 
     // Attach applied mocks summary to trace
     await testInfo.attach("📋 Applied Mocks", {
-      body: `Mocks configured for this test:\n\n${appliedMocks.map((m) => `✅ ${m.endpoint}\n   ${m.description}`).join("\n\n")}`,
+      body: `Mocks configured for this test:\n\n${appliedMocks
+        .map((m) => `✅ ${m.endpoint}\n   ${m.description}`)
+        .join("\n\n")}`,
       contentType: "text/plain",
     });
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cybermem/dashboard",
-  "version": "0.14.14",
+  "version": "0.15.0",
   "description": "CyberMem Monitoring Dashboard",
   "homepage": "https://cybermem.dev",
   "repository": {