@cybermem/mcp 0.8.3 → 0.8.5

package/dist/env.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Environment Initialization for CyberMem MCP
+ * Must be imported first to set side-effect vars.
+ */
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+process.env.OM_TIER = process.env.OM_TIER || "hybrid";
+process.env.OM_PORT = process.env.OM_PORT || "0";
+process.env.PORT = process.env.PORT || "0";

package/dist/index.js

@@ -1,5 +1,10 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env.js");
 /**
  * CyberMem MCP Server
  *
@@ -7,25 +12,35 @@
  * 1. Local/Server Mode (default): Uses openmemory-js SDK directly.
  * 2. Remote Client Mode (with --url): Proxies requests to a remote CyberMem server via HTTP.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.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 axios_1 = __importDefault(require("axios"));
 const cors_1 = __importDefault(require("cors"));
-const dotenv_1 = __importDefault(require("dotenv"));
 const express_1 = __importDefault(require("express"));
-const openmemory_js_1 = require("openmemory-js");
 const zod_1 = require("zod");
-const auth_js_1 = require("./auth.js");
-dotenv_1.default.config();
+const auth_1 = require("./auth");
+// Redirect all stdout to stderr IMMEDIATELY to protect Stdio protocol
+const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+process.stdout.write = (chunk, encoding, callback) => {
+    const str = typeof chunk === "string" ? chunk : chunk.toString();
+    // Allow ONLY protocol messages (must be JSON-RPC)
+    if (str.includes('"jsonrpc":')) {
+        return originalStdoutWrite(chunk, encoding, callback);
+    }
+    return process.stderr.write(chunk, encoding, callback);
+};
+// Also redirect console outputs
+console.log = console.error;
+console.info = console.error;
+// Async Storage for Request Context (User ID and Client Name)
+const requestContext = new async_hooks_1.AsyncLocalStorage();
 // Handle CLI auth commands first
 const args = process.argv.slice(2);
 if (args.includes("--login")) {
-    (0, auth_js_1.login)()
+    (0, auth_1.login)()
         .then(() => process.exit(0))
         .catch((err) => {
         console.error("Login failed:", err.message);
@@ -33,11 +48,11 @@ if (args.includes("--login")) {
     });
 }
 else if (args.includes("--logout")) {
-    (0, auth_js_1.logout)();
+    (0, auth_1.logout)();
     process.exit(0);
 }
 else if (args.includes("--status")) {
-    (0, auth_js_1.showStatus)();
+    (0, auth_1.showStatus)();
     process.exit(0);
 }
 else {
@@ -48,9 +63,9 @@ async function startServer() {
         const idx = args.indexOf(name);
         return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
     };
-    const cliClientName = getArg("--client-name") || "cybermem-mcp";
     const cliUrl = getArg("--url");
-    const cliApiKey = getArg("--api-key");
+    const cliToken = getArg("--token") || getArg("--api-key") || (cliUrl ? (0, auth_1.getToken)() : undefined);
+    let stdioClientName = undefined;
     // Protocol Instructions
     const CYBERMEM_INSTRUCTIONS = `CyberMem is a persistent context daemon for AI agents.
 PROTOCOL:
@@ -58,7 +73,7 @@ PROTOCOL:
 2. Store new insights immediately with add_memory (FULL content)
 3. 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.8.2" }, {
+    const server = new mcp_js_1.McpServer({ name: "cybermem", version: "0.7.5" }, {
         instructions: CYBERMEM_INSTRUCTIONS,
     });
     server.registerResource("CyberMem Agent Protocol", "cybermem://protocol", { description: "Instructions for AI agents", mimeType: "text/plain" }, async () => ({
@@ -70,6 +85,23 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
             },
         ],
     }));
+    // 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.7.5",
+            },
+        };
+    });
     // --- IMPLEMENTATION LOGIC ---
     let memory = null;
     let apiClient = null;
@@ -79,35 +111,145 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         apiClient = axios_1.default.create({
             baseURL: cliUrl,
             headers: {
-                Authorization: `Bearer ${cliApiKey}`,
-                "X-Client-Name": cliClientName,
+                "X-API-Key": cliToken,
+                Accept: "application/json, text/event-stream",
+                "Content-Type": "application/json",
             },
         });
+        // Dynamically inject client name from context or discovery
+        apiClient.interceptors.request.use((config) => {
+            const ctx = requestContext.getStore();
+            config.headers["X-Client-Name"] =
+                ctx?.clientName || stdioClientName || "unknown-mcp-client";
+            return config;
+        });
     }
     else {
         // LOCAL SDK MODE
         const homedir = process.env.HOME || process.env.USERPROFILE || "";
-        // Default to ~/.cybermem/data if OM_DB_PATH not set
-        if (!process.env.OM_DB_PATH) {
-            process.env.OM_DB_PATH = `${homedir}/.cybermem/data/openmemory.sqlite`;
-        }
+        // FORCE absolute standardized path for consistency across components
+        const path = await import("path");
+        const dbPath = path.resolve(homedir, ".cybermem/data/openmemory.sqlite");
+        process.env.OM_DB_PATH = dbPath;
         // Ensure directory exists
-        const fs = require("fs");
+        const fs = await import("fs");
         try {
-            const dbPath = process.env.OM_DB_PATH;
-            const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+            const dir = path.dirname(dbPath);
             if (dir)
                 fs.mkdirSync(dir, { recursive: true });
         }
         catch { }
-        memory = new openmemory_js_1.Memory();
+        try {
+            // Dynamic import to ensure env vars are set before loading SDK
+            // We import from dist/core/memory directly to avoid triggering the server side-effects in openmemory-js/dist/index.js
+            // @ts-ignore
+            const { Memory } = await import("openmemory-js/dist/core/memory.js");
+            memory = new Memory();
+            server._memoryReady = true;
+            // --- INITIALIZE LOGGING TABLES ---
+            const sqlite3 = await import("sqlite3");
+            const db = new sqlite3.default.Database(dbPath);
+            db.configure("busyTimeout", 5000);
+            db.serialize(() => {
+                db.run("PRAGMA journal_mode=WAL;", (err) => {
+                    if (err)
+                        console.error("[MCP] Init WAL error:", err.message);
+                });
+                db.run(`CREATE TABLE IF NOT EXISTS cybermem_stats (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            client_name TEXT NOT NULL,
+            operation TEXT NOT NULL,
+            count INTEGER DEFAULT 0,
+            errors INTEGER DEFAULT 0,
+            last_updated INTEGER NOT NULL,
+            UNIQUE(client_name, operation)
+        );`, (err) => {
+                    if (err)
+                        console.error("[MCP] Init stats table error:", err.message);
+                });
+                db.run(`CREATE TABLE IF NOT EXISTS cybermem_access_log (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp INTEGER NOT NULL,
+            client_name TEXT NOT NULL,
+            client_version TEXT,
+            method TEXT NOT NULL,
+            endpoint TEXT NOT NULL,
+            operation TEXT NOT NULL,
+            status TEXT NOT NULL,
+            is_error INTEGER DEFAULT 0
+        );`, (err) => {
+                    if (err)
+                        console.error("[MCP] Init access_log table error:", err.message);
+                });
+            });
+            db.close();
+        }
+        catch (e) {
+            console.error("Failed to initialize OpenMemory SDK:", e);
+            server._memoryReady = false;
+        }
     }
-    // Helper to add source tag
+    // Helper to log activity to SQLite (Local SDK Mode only)
+    const logActivity = async (operation, opts = {}) => {
+        if (cliUrl || !memory)
+            return;
+        const { client: providedClient, method = "POST", endpoint = "/mcp", status = 200, } = opts;
+        const ctx = requestContext.getStore();
+        const client = providedClient || ctx?.clientName || stdioClientName || "unknown-client";
+        try {
+            const dbPath = process.env.OM_DB_PATH;
+            const sqlite3 = await import("sqlite3");
+            const db = new sqlite3.default.Database(dbPath);
+            db.configure("busyTimeout", 5000);
+            const ts = Date.now();
+            const is_error = status >= 400 ? 1 : 0;
+            console.error(`[MCP] Logging ${operation} for ${client} (status: ${status})`);
+            db.serialize(() => {
+                // Log to access_log
+                db.run(`INSERT INTO cybermem_access_log
+          (timestamp, client_name, client_version, method, endpoint, operation, status, is_error)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    ts,
+                    client,
+                    "0.7.0",
+                    method,
+                    endpoint,
+                    operation,
+                    status.toString(),
+                    is_error,
+                ], (err) => {
+                    if (err)
+                        console.error("[MCP] Log access error:", err.message);
+                });
+                // Log to stats (Upsert)
+                db.run(`INSERT INTO cybermem_stats (client_name, operation, count, errors, last_updated)
+          VALUES (?, ?, 1, ?, ?)
+          ON CONFLICT(client_name, operation) DO UPDATE SET
+            count = count + 1,
+            errors = errors + ?,
+            last_updated = ?`, [client, operation, is_error, ts, is_error, ts], (err) => {
+                    if (err)
+                        console.error("[MCP] Log stats error:", err.message);
+                });
+            });
+            db.close();
+        }
+        catch (e) {
+            console.error("Failed to log activity to SQLite:", e);
+        }
+    };
     const addSourceTag = (tags = []) => {
-        if (!tags.some((t) => t.startsWith("source:")))
-            tags.push(`source:${cliClientName}`);
+        if (!tags.some((t) => t.startsWith("source:"))) {
+            const clientName = requestContext.getStore()?.clientName || stdioClientName || "unknown";
+            tags.push(`source:${clientName}`);
+        }
         return tags;
     };
+    // Helper to get current User ID from context or args
+    const getContextUserId = (argsUserId) => {
+        const store = requestContext.getStore();
+        return argsUserId || store?.userId;
+    };
     // --- TOOLS ---
     server.registerTool("add_memory", {
         description: "Store a new memory. " + CYBERMEM_INSTRUCTIONS,
@@ -118,38 +260,76 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         }),
     }, async (args) => {
         const tags = addSourceTag(args.tags);
+        const userId = getContextUserId(args.user_id);
         if (cliUrl) {
-            const res = await apiClient.post("/add", { ...args, tags });
+            const res = await apiClient.post("/add", {
+                ...args,
+                user_id: userId,
+                tags,
+            });
             return { content: [{ type: "text", text: JSON.stringify(res.data) }] };
         }
         else {
-            const res = await memory.add(args.content, {
-                user_id: args.user_id,
-                tags,
-            });
-            return { content: [{ type: "text", text: JSON.stringify(res) }] };
+            try {
+                const res = await memory.add(args.content, {
+                    user_id: userId,
+                    tags,
+                });
+                await logActivity("create", {
+                    method: "POST",
+                    endpoint: "/memory/add",
+                    status: 200,
+                });
+                return { content: [{ type: "text", text: JSON.stringify(res) }] };
+            }
+            catch (e) {
+                await logActivity("create", {
+                    method: "POST",
+                    endpoint: "/memory/add",
+                    status: 500,
+                });
+                throw e;
+            }
         }
     });
     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 userId = getContextUserId(); // Search is scoped to user if provided
         if (cliUrl) {
             const res = await apiClient.post("/query", args);
             return { content: [{ type: "text", text: JSON.stringify(res.data) }] };
         }
         else {
-            const res = await memory.search(args.query, { limit: args.k });
-            return { content: [{ type: "text", text: JSON.stringify(res) }] };
+            try {
+                const res = await memory.search(args.query, {
+                    limit: args.k,
+                    user_id: userId,
+                });
+                await logActivity("read", {
+                    method: "POST",
+                    endpoint: "/memory/query",
+                    status: 200,
+                });
+                return { content: [{ type: "text", text: JSON.stringify(res) }] };
+            }
+            catch (e) {
+                await logActivity("read", {
+                    method: "POST",
+                    endpoint: "/memory/query",
+                    status: 500,
+                });
+                throw e;
+            }
         }
     });
     server.registerTool("list_memories", {
         description: "List recent memories",
         inputSchema: zod_1.z.object({ limit: zod_1.z.number().default(10) }),
     }, async (args) => {
+        const userId = getContextUserId();
         if (cliUrl) {
-            // Fallback to /query with empty string if /list not available, or use /all
-            // Old API had /all
             try {
                 const res = await apiClient.get(`/all?limit=${args.limit}`);
                 return {
@@ -167,7 +347,15 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
             }
         }
         else {
-            const res = await memory.search("", { limit: args.limit });
+            const res = await memory.search("", {
+                limit: args.limit,
+                user_id: userId,
+            });
+            await logActivity("read", {
+                method: "GET",
+                endpoint: "/memory/all",
+                status: 200,
+            });
             return { content: [{ type: "text", text: JSON.stringify(res) }] };
         }
     });
@@ -180,17 +368,55 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
             return { content: [{ type: "text", text: JSON.stringify(res.data) }] };
         }
         else {
-            return {
-                content: [
-                    { type: "text", text: "Delete not implemented in SDK yet" },
-                ],
-            };
+            const dbPath = process.env.OM_DB_PATH;
+            const sqlite3 = await import("sqlite3");
+            const db = new sqlite3.default.Database(dbPath);
+            db.configure("busyTimeout", 5000);
+            return new Promise((resolve, reject) => {
+                db.serialize(() => {
+                    db.run("BEGIN TRANSACTION");
+                    db.run("DELETE FROM memories WHERE id = ?", [args.id]);
+                    db.run("DELETE FROM vectors WHERE id = ?", [args.id]);
+                    db.run("DELETE FROM waypoints WHERE src_id = ? OR dst_id = ?", [
+                        args.id,
+                        args.id,
+                    ]);
+                    db.run("COMMIT", async (err) => {
+                        db.close();
+                        if (err) {
+                            await logActivity("delete", {
+                                method: "DELETE",
+                                endpoint: `/memory/${args.id}`,
+                                status: 500,
+                            });
+                            reject(new Error(`Failed to delete memory ${args.id}: ${err.message}`));
+                        }
+                        else {
+                            await logActivity("delete", {
+                                method: "DELETE",
+                                endpoint: `/memory/${args.id}`,
+                                status: 200,
+                            });
+                            resolve({
+                                content: [
+                                    { type: "text", text: `Memory ${args.id} deleted` },
+                                ],
+                            });
+                        }
+                    });
+                });
+            });
         }
     });
     server.registerTool("update_memory", {
         description: "Update memory",
         inputSchema: zod_1.z.object({ id: zod_1.z.string(), content: zod_1.z.string().optional() }),
     }, async (args) => {
+        await logActivity("update", {
+            method: "PATCH",
+            endpoint: `/memory/${args.id}`,
+            status: 501,
+        });
         return { content: [{ type: "text", text: "Update not implemented" }] };
     });
     // --- TRANSPORT ---
@@ -200,41 +426,130 @@ 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.8.2", mode: cliUrl ? "proxy" : "sdk" }));
-        // REST API Compatibility (for Remote Clients)
-        // Only enable if in SDK mode (Server)
+        app.get("/health", (req, res) => res.json({
+            ok: server._memoryReady,
+            version: "0.7.5",
+            mode: cliUrl ? "proxy" : "sdk",
+            ready: server._memoryReady,
+        }));
+        app.get("/metrics", async (req, res) => {
+            try {
+                const dbPath = process.env.OM_DB_PATH;
+                const sqlite3 = await import("sqlite3");
+                const db = new sqlite3.default.Database(dbPath);
+                db.configure("busyTimeout", 5000);
+                const getCount = (query) => new Promise((resolve) => db.get(query, (err, row) => resolve(row?.count || 0)));
+                const memoriesCount = await getCount("SELECT COUNT(*) as count FROM memories");
+                const totalRequests = await getCount("SELECT COUNT(*) as count FROM cybermem_access_log");
+                const errorRequests = await getCount("SELECT COUNT(*) as count FROM cybermem_access_log WHERE is_error = 1");
+                const uniqueClients = await getCount("SELECT COUNT(DISTINCT client_name) as count FROM cybermem_access_log");
+                db.close();
+                const metrics = [
+                    "# HELP openmemory_memories_total Total number of memories",
+                    "# TYPE openmemory_memories_total gauge",
+                    `openmemory_memories_total ${memoriesCount}`,
+                    "# HELP openmemory_requests_aggregate_total Total requests logged in SQLite",
+                    "# TYPE openmemory_requests_aggregate_total counter",
+                    `openmemory_requests_aggregate_total ${totalRequests}`,
+                    "# HELP openmemory_errors_total Total errors logged in SQLite",
+                    "# TYPE openmemory_errors_total counter",
+                    `openmemory_errors_total ${errorRequests}`,
+                    "# HELP openmemory_clients_total Total unique clients logged in SQLite",
+                    "# TYPE openmemory_clients_total gauge",
+                    `openmemory_clients_total ${uniqueClients}`,
+                    "# HELP openmemory_success_rate_aggregate Success rate from SQLite logs",
+                    "# TYPE openmemory_success_rate_aggregate gauge",
+                    `openmemory_success_rate_aggregate ${totalRequests > 0 ? ((totalRequests - errorRequests) / totalRequests) * 100 : 100}`,
+                ].join("\n");
+                res.set("Content-Type", "text/plain").send(metrics);
+            }
+            catch (e) {
+                res.status(500).send(`# Error: ${e.message}`);
+            }
+        });
+        app.use((req, res, next) => {
+            const userId = req.headers["x-user-id"];
+            const clientName = req.headers["x-client-name"] ||
+                req.headers["user-agent"];
+            requestContext.run({ userId, clientName }, next);
+        });
         if (!cliUrl && memory) {
             app.post("/add", async (req, res) => {
                 try {
+                    const contextUserId = requestContext.getStore()?.userId;
                     const { content, user_id, tags } = req.body;
                     const finalTags = addSourceTag(tags);
                     const result = await memory.add(content, {
-                        user_id,
+                        user_id: user_id || contextUserId,
                         tags: finalTags,
                     });
+                    await logActivity("create", {
+                        client: "rest-api",
+                        method: "POST",
+                        endpoint: "/add",
+                        status: 200,
+                    });
                     res.json(result);
                 }
                 catch (e) {
+                    await logActivity("create", {
+                        client: "rest-api",
+                        method: "POST",
+                        endpoint: "/add",
+                        status: 500,
+                    });
                     res.status(500).json({ error: e.message });
                 }
             });
             app.post("/query", async (req, res) => {
                 try {
+                    const contextUserId = requestContext.getStore()?.userId;
                     const { query, k } = req.body;
-                    const result = await memory.search(query || "", { limit: k || 5 });
+                    const result = await memory.search(query || "", {
+                        limit: k || 5,
+                        user_id: contextUserId,
+                    });
+                    await logActivity("read", {
+                        client: "rest-api",
+                        method: "POST",
+                        endpoint: "/query",
+                        status: 200,
+                    });
                     res.json(result);
                 }
                 catch (e) {
+                    await logActivity("read", {
+                        client: "rest-api",
+                        method: "POST",
+                        endpoint: "/query",
+                        status: 500,
+                    });
                     res.status(500).json({ error: e.message });
                 }
             });
             app.get("/all", async (req, res) => {
                 try {
+                    const contextUserId = requestContext.getStore()?.userId;
                     const limit = parseInt(req.query.limit) || 10;
-                    const result = await memory.search("", { limit });
+                    const result = await memory.search("", {
+                        limit,
+                        user_id: contextUserId,
+                    });
+                    await logActivity("read", {
+                        client: "rest-api",
+                        method: "GET",
+                        endpoint: "/all",
+                        status: 200,
+                    });
                     res.json(result);
                 }
                 catch (e) {
+                    await logActivity("read", {
+                        client: "rest-api",
+                        method: "GET",
+                        endpoint: "/all",
+                        status: 500,
+                    });
                     res.status(500).json({ error: e.message });
                 }
             });
@@ -246,7 +561,7 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         app.all("/sse", async (req, res) => await transport.handleRequest(req, res, req.body));
         server.connect(transport).then(() => {
             app.listen(port, () => {
-                console.log(`CyberMem MCP running on http://localhost:${port}`);
+                console.error(`CyberMem MCP (ready: ${server._memoryReady}) running on http://localhost:${port}`);
             });
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cybermem/mcp",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "CyberMem MCP Server - AI Memory with openmemory-js SDK",
   "main": "dist/index.js",
   "bin": {
@@ -25,7 +25,6 @@
     "ai-memory",
     "claude",
     "cursor",
-    "antigravity",
     "openmemory",
     "llm"
   ],
@@ -40,7 +39,11 @@
     "cors": "^2.8.5",
     "dotenv": "^16.0.0",
     "express": "^5.2.1",
+    "keytar": "^7.9.0",
+    "open": "^11.0.0",
     "openmemory-js": "^1.3.2",
+    "sqlite": "^5.1.1",
+    "sqlite3": "^5.1.7",
     "zod": "^3.25.76"
   },
   "devDependencies": {

package/src/env.ts

@@ -0,0 +1,10 @@
+/**
+ * Environment Initialization for CyberMem MCP
+ * Must be imported first to set side-effect vars.
+ */
+import dotenv from "dotenv";
+dotenv.config();
+
+process.env.OM_TIER = process.env.OM_TIER || "hybrid";
+process.env.OM_PORT = process.env.OM_PORT || "0";
+process.env.PORT = process.env.PORT || "0";

package/src/index.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./env.js";
 /**
  * CyberMem MCP Server
  *
@@ -10,15 +11,34 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.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 axios from "axios";
 import cors from "cors";
-import dotenv from "dotenv";
 import express from "express";
-import { Memory } from "openmemory-js";
 import { z } from "zod";
-import { login, logout, showStatus } from "./auth.js";
+import { getToken, login, logout, showStatus } from "./auth";
 
-dotenv.config();
+// Redirect all stdout to stderr IMMEDIATELY to protect Stdio protocol
+const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+(process.stdout as any).write = (chunk: any, encoding: any, callback: any) => {
+  const str = typeof chunk === "string" ? chunk : chunk.toString();
+  // Allow ONLY protocol messages (must be JSON-RPC)
+  if (str.includes('"jsonrpc":')) {
+    return originalStdoutWrite(chunk, encoding, callback);
+  }
+  return process.stderr.write(chunk, encoding, callback);
+};
+
+// Also redirect console outputs
+console.log = console.error;
+console.info = console.error;
+
+// Async Storage for Request Context (User ID and Client Name)
+const requestContext = new AsyncLocalStorage<{
+  userId?: string;
+  clientName?: string;
+}>();
 
 // Handle CLI auth commands first
 const args = process.argv.slice(2);
@@ -46,9 +66,9 @@ async function startServer() {
     return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
   };
 
-  const cliClientName = getArg("--client-name") || "cybermem-mcp";
   const cliUrl = getArg("--url");
-  const cliApiKey = getArg("--api-key");
+  const cliToken = getArg("--token") || getArg("--api-key") || (cliUrl ? getToken() : undefined);
+  let stdioClientName: string | undefined = undefined;
 
   // Protocol Instructions
   const CYBERMEM_INSTRUCTIONS = `CyberMem is a persistent context daemon for AI agents.
@@ -59,7 +79,7 @@ PROTOCOL:
 For full protocol: https://docs.cybermem.dev/agent-protocol`;
 
   const server = new McpServer(
-    { name: "cybermem", version: "0.8.2" },
+    { name: "cybermem", version: "0.7.5" },
     {
       instructions: CYBERMEM_INSTRUCTIONS,
     },
@@ -80,9 +100,27 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
     }),
   );
 
+  // 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.7.5",
+      },
+    };
+  });
+
   // --- IMPLEMENTATION LOGIC ---
 
-  let memory: Memory | null = null;
+  let memory: any = null;
   let apiClient: any = null;
 
   if (cliUrl) {
@@ -91,36 +129,182 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
     apiClient = axios.create({
       baseURL: cliUrl,
       headers: {
-        Authorization: `Bearer ${cliApiKey}`,
-        "X-Client-Name": cliClientName,
+        "X-API-Key": cliToken,
+        Accept: "application/json, text/event-stream",
+        "Content-Type": "application/json",
       },
     });
+    // Dynamically inject client name from context or discovery
+    apiClient.interceptors.request.use((config: any) => {
+      const ctx = requestContext.getStore();
+      config.headers["X-Client-Name"] =
+        ctx?.clientName || stdioClientName || "unknown-mcp-client";
+      return config;
+    });
   } else {
     // LOCAL SDK MODE
     const homedir = process.env.HOME || process.env.USERPROFILE || "";
-    // Default to ~/.cybermem/data if OM_DB_PATH not set
-    if (!process.env.OM_DB_PATH) {
-      process.env.OM_DB_PATH = `${homedir}/.cybermem/data/openmemory.sqlite`;
-    }
+    // FORCE absolute standardized path for consistency across components
+    const path = await import("path");
+    const dbPath = path.resolve(homedir, ".cybermem/data/openmemory.sqlite");
+    process.env.OM_DB_PATH = dbPath;
 
     // Ensure directory exists
-    const fs = require("fs");
+    const fs = await import("fs");
     try {
-      const dbPath = process.env.OM_DB_PATH;
-      const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+      const dir = path.dirname(dbPath);
       if (dir) fs.mkdirSync(dir, { recursive: true });
-    } catch {}
+    } catch { }
 
-    memory = new Memory();
+    try {
+      // Dynamic import to ensure env vars are set before loading SDK
+      // We import from dist/core/memory directly to avoid triggering the server side-effects in openmemory-js/dist/index.js
+      // @ts-ignore
+      const { Memory } = await import("openmemory-js/dist/core/memory.js");
+      memory = new Memory();
+      (server as any)._memoryReady = true;
+
+      // --- INITIALIZE LOGGING TABLES ---
+      const sqlite3 = await import("sqlite3");
+      const db = new sqlite3.default.Database(dbPath);
+      db.configure("busyTimeout", 5000);
+      db.serialize(() => {
+        db.run("PRAGMA journal_mode=WAL;", (err: any) => {
+          if (err) console.error("[MCP] Init WAL error:", err.message);
+        });
+        db.run(
+          `CREATE TABLE IF NOT EXISTS cybermem_stats (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            client_name TEXT NOT NULL,
+            operation TEXT NOT NULL,
+            count INTEGER DEFAULT 0,
+            errors INTEGER DEFAULT 0,
+            last_updated INTEGER NOT NULL,
+            UNIQUE(client_name, operation)
+        );`,
+          (err: any) => {
+            if (err)
+              console.error("[MCP] Init stats table error:", err.message);
+          },
+        );
+        db.run(
+          `CREATE TABLE IF NOT EXISTS cybermem_access_log (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp INTEGER NOT NULL,
+            client_name TEXT NOT NULL,
+            client_version TEXT,
+            method TEXT NOT NULL,
+            endpoint TEXT NOT NULL,
+            operation TEXT NOT NULL,
+            status TEXT NOT NULL,
+            is_error INTEGER DEFAULT 0
+        );`,
+          (err: any) => {
+            if (err)
+              console.error("[MCP] Init access_log table error:", err.message);
+          },
+        );
+      });
+      db.close();
+    } catch (e) {
+      console.error("Failed to initialize OpenMemory SDK:", e);
+      (server as any)._memoryReady = false;
+    }
   }
 
-  // Helper to add source tag
+  // Helper to log activity to SQLite (Local SDK Mode only)
+  const logActivity = async (
+    operation: string,
+    opts: {
+      client?: string;
+      method?: string;
+      endpoint?: string;
+      status?: number;
+    } = {},
+  ) => {
+    if (cliUrl || !memory) return;
+
+    const {
+      client: providedClient,
+      method = "POST",
+      endpoint = "/mcp",
+      status = 200,
+    } = opts;
+
+    const ctx = requestContext.getStore();
+    const client =
+      providedClient || ctx?.clientName || stdioClientName || "unknown-client";
+
+    try {
+      const dbPath = process.env.OM_DB_PATH!;
+      const sqlite3 = await import("sqlite3");
+      const db = new sqlite3.default.Database(dbPath);
+      db.configure("busyTimeout", 5000);
+
+      const ts = Date.now();
+      const is_error = status >= 400 ? 1 : 0;
+
+      console.error(
+        `[MCP] Logging ${operation} for ${client} (status: ${status})`,
+      );
+
+      db.serialize(() => {
+        // Log to access_log
+        db.run(
+          `INSERT INTO cybermem_access_log
+          (timestamp, client_name, client_version, method, endpoint, operation, status, is_error)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            ts,
+            client,
+            "0.7.0",
+            method,
+            endpoint,
+            operation,
+            status.toString(),
+            is_error,
+          ],
+          (err: any) => {
+            if (err) console.error("[MCP] Log access error:", err.message);
+          },
+        );
+
+        // Log to stats (Upsert)
+        db.run(
+          `INSERT INTO cybermem_stats (client_name, operation, count, errors, last_updated)
+          VALUES (?, ?, 1, ?, ?)
+          ON CONFLICT(client_name, operation) DO UPDATE SET
+            count = count + 1,
+            errors = errors + ?,
+            last_updated = ?`,
+          [client, operation, is_error, ts, is_error, ts],
+          (err: any) => {
+            if (err) console.error("[MCP] Log stats error:", err.message);
+          },
+        );
+      });
+
+      db.close();
+    } catch (e) {
+      console.error("Failed to log activity to SQLite:", e);
+    }
+  };
+
   const addSourceTag = (tags: string[] = []) => {
-    if (!tags.some((t) => t.startsWith("source:")))
-      tags.push(`source:${cliClientName}`);
+    if (!tags.some((t) => t.startsWith("source:"))) {
+      const clientName =
+        requestContext.getStore()?.clientName || stdioClientName || "unknown";
+      tags.push(`source:${clientName}`);
+    }
     return tags;
   };
 
+  // Helper to get current User ID from context or args
+  const getContextUserId = (argsUserId?: string) => {
+    const store = requestContext.getStore();
+    return argsUserId || store?.userId;
+  };
+
   // --- TOOLS ---
 
   server.registerTool(
@@ -133,17 +317,37 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
         tags: z.array(z.string()).optional(),
       }),
     },
-    async (args) => {
+    async (args: any) => {
       const tags = addSourceTag(args.tags);
+      const userId = getContextUserId(args.user_id);
+
       if (cliUrl) {
-        const res = await apiClient.post("/add", { ...args, tags });
-        return { content: [{ type: "text", text: JSON.stringify(res.data) }] };
-      } else {
-        const res = await memory!.add(args.content, {
-          user_id: args.user_id,
+        const res = await apiClient.post("/add", {
+          ...args,
+          user_id: userId,
           tags,
         });
-        return { content: [{ type: "text", text: JSON.stringify(res) }] };
+        return { content: [{ type: "text", text: JSON.stringify(res.data) }] };
+      } else {
+        try {
+          const res = await memory!.add(args.content, {
+            user_id: userId,
+            tags,
+          });
+          await logActivity("create", {
+            method: "POST",
+            endpoint: "/memory/add",
+            status: 200,
+          });
+          return { content: [{ type: "text", text: JSON.stringify(res) }] };
+        } catch (e: any) {
+          await logActivity("create", {
+            method: "POST",
+            endpoint: "/memory/add",
+            status: 500,
+          });
+          throw e;
+        }
       }
     },
   );
@@ -154,13 +358,32 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
       description: "Search memories.",
       inputSchema: z.object({ query: z.string(), k: z.number().default(5) }),
     },
-    async (args) => {
+    async (args: any) => {
+      const userId = getContextUserId(); // Search is scoped to user if provided
+
       if (cliUrl) {
         const res = await apiClient.post("/query", args);
         return { content: [{ type: "text", text: JSON.stringify(res.data) }] };
       } else {
-        const res = await memory!.search(args.query, { limit: args.k });
-        return { content: [{ type: "text", text: JSON.stringify(res) }] };
+        try {
+          const res = await memory!.search(args.query, {
+            limit: args.k,
+            user_id: userId,
+          });
+          await logActivity("read", {
+            method: "POST",
+            endpoint: "/memory/query",
+            status: 200,
+          });
+          return { content: [{ type: "text", text: JSON.stringify(res) }] };
+        } catch (e: any) {
+          await logActivity("read", {
+            method: "POST",
+            endpoint: "/memory/query",
+            status: 500,
+          });
+          throw e;
+        }
       }
     },
   );
@@ -172,9 +395,9 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
       inputSchema: z.object({ limit: z.number().default(10) }),
     },
     async (args) => {
+      const userId = getContextUserId();
+
       if (cliUrl) {
-        // Fallback to /query with empty string if /list not available, or use /all
-        // Old API had /all
         try {
           const res = await apiClient.get(`/all?limit=${args.limit}`);
           return {
@@ -190,7 +413,15 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
           };
         }
       } else {
-        const res = await memory!.search("", { limit: args.limit });
+        const res = await memory!.search("", {
+          limit: args.limit,
+          user_id: userId,
+        });
+        await logActivity("read", {
+          method: "GET",
+          endpoint: "/memory/all",
+          status: 200,
+        });
         return { content: [{ type: "text", text: JSON.stringify(res) }] };
       }
     },
@@ -202,16 +433,53 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
       description: "Delete memory by ID",
       inputSchema: z.object({ id: z.string() }),
     },
-    async (args) => {
+    async (args: any) => {
       if (cliUrl) {
         const res = await apiClient.delete(`/${args.id}`);
         return { content: [{ type: "text", text: JSON.stringify(res.data) }] };
       } else {
-        return {
-          content: [
-            { type: "text", text: "Delete not implemented in SDK yet" },
-          ],
-        };
+        const dbPath = process.env.OM_DB_PATH!;
+        const sqlite3 = await import("sqlite3");
+        const db = new sqlite3.default.Database(dbPath);
+        db.configure("busyTimeout", 5000);
+
+        return new Promise((resolve, reject) => {
+          db.serialize(() => {
+            db.run("BEGIN TRANSACTION");
+            db.run("DELETE FROM memories WHERE id = ?", [args.id]);
+            db.run("DELETE FROM vectors WHERE id = ?", [args.id]);
+            db.run("DELETE FROM waypoints WHERE src_id = ? OR dst_id = ?", [
+              args.id,
+              args.id,
+            ]);
+            db.run("COMMIT", async (err: any) => {
+              db.close();
+              if (err) {
+                await logActivity("delete", {
+                  method: "DELETE",
+                  endpoint: `/memory/${args.id}`,
+                  status: 500,
+                });
+                reject(
+                  new Error(
+                    `Failed to delete memory ${args.id}: ${err.message}`,
+                  ),
+                );
+              } else {
+                await logActivity("delete", {
+                  method: "DELETE",
+                  endpoint: `/memory/${args.id}`,
+                  status: 200,
+                });
+                resolve({
+                  content: [
+                    { type: "text", text: `Memory ${args.id} deleted` },
+                  ],
+                });
+              }
+            });
+          });
+        });
       }
     },
   );
@@ -222,7 +490,12 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
       description: "Update memory",
       inputSchema: z.object({ id: z.string(), content: z.string().optional() }),
     },
-    async (args) => {
+    async (args: any) => {
+      await logActivity("update", {
+        method: "PATCH",
+        endpoint: `/memory/${args.id}`,
+        status: 501,
+      });
       return { content: [{ type: "text", text: "Update not implemented" }] };
     },
   );
@@ -237,43 +510,159 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
     app.use(cors());
     app.use(express.json());
 
-    app.get("/health", (req, res) =>
-      res.json({ ok: true, version: "0.8.2", mode: cliUrl ? "proxy" : "sdk" }),
+    app.get("/health", (req: express.Request, res: express.Response) =>
+      res.json({
+        ok: (server as any)._memoryReady,
+        version: "0.7.5",
+        mode: cliUrl ? "proxy" : "sdk",
+        ready: (server as any)._memoryReady,
+      }),
+    );
+
+    app.get("/metrics", async (req: express.Request, res: express.Response) => {
+      try {
+        const dbPath = process.env.OM_DB_PATH!;
+        const sqlite3 = await import("sqlite3");
+        const db = new sqlite3.default.Database(dbPath);
+        db.configure("busyTimeout", 5000);
+
+        const getCount = (query: string): Promise<number> =>
+          new Promise((resolve) =>
+            db.get(query, (err, row: any) => resolve(row?.count || 0)),
+          );
+
+        const memoriesCount = await getCount(
+          "SELECT COUNT(*) as count FROM memories",
+        );
+        const totalRequests = await getCount(
+          "SELECT COUNT(*) as count FROM cybermem_access_log",
+        );
+        const errorRequests = await getCount(
+          "SELECT COUNT(*) as count FROM cybermem_access_log WHERE is_error = 1",
+        );
+        const uniqueClients = await getCount(
+          "SELECT COUNT(DISTINCT client_name) as count FROM cybermem_access_log",
+        );
+
+        db.close();
+
+        const metrics = [
+          "# HELP openmemory_memories_total Total number of memories",
+          "# TYPE openmemory_memories_total gauge",
+          `openmemory_memories_total ${memoriesCount}`,
+          "# HELP openmemory_requests_aggregate_total Total requests logged in SQLite",
+          "# TYPE openmemory_requests_aggregate_total counter",
+          `openmemory_requests_aggregate_total ${totalRequests}`,
+          "# HELP openmemory_errors_total Total errors logged in SQLite",
+          "# TYPE openmemory_errors_total counter",
+          `openmemory_errors_total ${errorRequests}`,
+          "# HELP openmemory_clients_total Total unique clients logged in SQLite",
+          "# TYPE openmemory_clients_total gauge",
+          `openmemory_clients_total ${uniqueClients}`,
+          "# HELP openmemory_success_rate_aggregate Success rate from SQLite logs",
+          "# TYPE openmemory_success_rate_aggregate gauge",
+          `openmemory_success_rate_aggregate ${totalRequests > 0 ? ((totalRequests - errorRequests) / totalRequests) * 100 : 100}`,
+        ].join("\n");
+
+        res.set("Content-Type", "text/plain").send(metrics);
+      } catch (e: any) {
+        res.status(500).send(`# Error: ${e.message}`);
+      }
+    });
+
+    app.use(
+      (
+        req: express.Request,
+        res: express.Response,
+        next: express.NextFunction,
+      ) => {
+        const userId = req.headers["x-user-id"] as string | undefined;
+        const clientName =
+          (req.headers["x-client-name"] as string) ||
+          (req.headers["user-agent"] as string);
+        requestContext.run({ userId, clientName }, next);
+      },
     );
 
-    // REST API Compatibility (for Remote Clients)
-    // Only enable if in SDK mode (Server)
     if (!cliUrl && memory) {
-      app.post("/add", async (req, res) => {
+      app.post("/add", async (req: express.Request, res: express.Response) => {
         try {
+          const contextUserId = requestContext.getStore()?.userId;
           const { content, user_id, tags } = req.body;
           const finalTags = addSourceTag(tags);
           const result = await memory!.add(content, {
-            user_id,
+            user_id: user_id || contextUserId,
             tags: finalTags,
           });
+          await logActivity("create", {
+            client: "rest-api",
+            method: "POST",
+            endpoint: "/add",
+            status: 200,
+          });
           res.json(result);
         } catch (e: any) {
+          await logActivity("create", {
+            client: "rest-api",
+            method: "POST",
+            endpoint: "/add",
+            status: 500,
+          });
           res.status(500).json({ error: e.message });
         }
       });
 
-      app.post("/query", async (req, res) => {
-        try {
-          const { query, k } = req.body;
-          const result = await memory!.search(query || "", { limit: k || 5 });
-          res.json(result);
-        } catch (e: any) {
-          res.status(500).json({ error: e.message });
-        }
-      });
+      app.post(
+        "/query",
+        async (req: express.Request, res: express.Response) => {
+          try {
+            const contextUserId = requestContext.getStore()?.userId;
+            const { query, k } = req.body;
+            const result = await memory!.search(query || "", {
+              limit: k || 5,
+              user_id: contextUserId,
+            });
+            await logActivity("read", {
+              client: "rest-api",
+              method: "POST",
+              endpoint: "/query",
+              status: 200,
+            });
+            res.json(result);
+          } catch (e: any) {
+            await logActivity("read", {
+              client: "rest-api",
+              method: "POST",
+              endpoint: "/query",
+              status: 500,
+            });
+            res.status(500).json({ error: e.message });
+          }
+        },
+      );
 
-      app.get("/all", async (req, res) => {
+      app.get("/all", async (req: express.Request, res: express.Response) => {
         try {
+          const contextUserId = requestContext.getStore()?.userId;
           const limit = parseInt(req.query.limit as string) || 10;
-          const result = await memory!.search("", { limit });
+          const result = await memory!.search("", {
+            limit,
+            user_id: contextUserId,
+          });
+          await logActivity("read", {
+            client: "rest-api",
+            method: "GET",
+            endpoint: "/all",
+            status: 200,
+          });
           res.json(result);
         } catch (e: any) {
+          await logActivity("read", {
+            client: "rest-api",
+            method: "GET",
+            endpoint: "/all",
+            status: 500,
+          });
           res.status(500).json({ error: e.message });
         }
       });
@@ -282,18 +671,24 @@ For full protocol: https://docs.cybermem.dev/agent-protocol`;
     const transport = new StreamableHTTPServerTransport({
       sessionIdGenerator: () => crypto.randomUUID(),
     });
+
     app.all(
       "/mcp",
-      async (req, res) => await transport.handleRequest(req, res, req.body),
+      async (req: express.Request, res: express.Response) =>
+        await transport.handleRequest(req, res, req.body),
     );
+
     app.all(
       "/sse",
-      async (req, res) => await transport.handleRequest(req, res, req.body),
+      async (req: express.Request, res: express.Response) =>
+        await transport.handleRequest(req, res, req.body),
     );
 
     server.connect(transport).then(() => {
       app.listen(port, () => {
-        console.log(`CyberMem MCP running on http://localhost:${port}`);
+        console.error(
+          `CyberMem MCP (ready: ${(server as any)._memoryReady}) running on http://localhost:${port}`,
+        );
       });
     });
   } else {