@cybermem/mcp 0.14.15 → 0.15.0

package/dist/index.js

@@ -1,458 +1,264 @@
+#!/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("./console-fix.js");
 require("./env.js");
-const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
-const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const async_hooks_1 = require("async_hooks");
-const cors_1 = __importDefault(require("cors"));
-const express_1 = __importDefault(require("express"));
+const fastmcp_1 = require("fastmcp");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const zod_1 = require("zod");
-// Async Storage for Request Context (User ID and Client Name)
+// --- CORE SDK IMPORTS ---
+const db_js_1 = require("openmemory-js/dist/core/db.js");
+const memory_js_1 = require("openmemory-js/dist/core/memory.js");
+const hsg_js_1 = require("openmemory-js/dist/memory/hsg.js");
+// --- GLOBALS & CONTEXT ---
 const requestContext = new async_hooks_1.AsyncLocalStorage();
-// CLI args processing
-const args = process.argv.slice(2);
-// Read version from package.json
 let PACKAGE_VERSION = "0.0.0";
 try {
     const packageJsonPath = (0, path_1.join)(__dirname, "../package.json");
     const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"));
     PACKAGE_VERSION = packageJson.version;
 }
-catch (error) {
-    console.error("[MCP] Failed to read package.json version", error);
-}
-// Start the server
-startServer();
-async function startServer() {
-    const getArg = (name) => {
-        const idx = args.indexOf(name);
-        return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
-    };
-    const cliEnv = getArg("--env");
-    if (cliEnv === "staging") {
-        console.error("[MCP] Running in Staging environment");
-        process.env.CYBERMEM_ENV = "staging";
-    }
-    // --- IMPLEMENTATION LOGIC ---
-    let memory = null;
-    let sdk_update_memory = null;
-    let sdk_reinforce_memory = null;
-    // LOCAL SDK MODE
-    const dbPath = process.env.OM_DB_PATH;
-    const fs = await import("fs");
-    const path = await import("path");
+catch { }
+const VALID_VERSION = (PACKAGE_VERSION.match(/^\d+\.\d+\.\d+$/) ? PACKAGE_VERSION : "0.0.0");
+const CYBERMEM_INSTRUCTIONS = `CyberMem is a persistent context daemon for AI agents.
+PROTOCOL:
+1. On session start: call query_memory("user context profile")
+2. Store insights immediately with add_memory
+3. Corrections: update_memory
+4. Decay prevention: reinforce_memory
+Full protocol: https://docs.cybermem.dev/agent-protocol`;
+// --- ERROR TRAPPING ---
+process.on("uncaughtException", (err) => {
+    console.error("[CRITICAL] Uncaught Exception:", err);
+});
+process.on("unhandledRejection", (reason) => {
+    console.error("[CRITICAL] Unhandled Rejection:", reason);
+});
+// --- LOGGING ---
+const logActivity = async (tool, status = 200) => {
     try {
-        const dir = path.dirname(dbPath);
-        if (dir)
-            fs.mkdirSync(dir, { recursive: true });
+        const ctx = requestContext.getStore();
+        const client = ctx?.clientName || "unknown";
+        console.log(`[MCP-LOG] client=${client} tool=${tool} status=${status}`);
+        const ts = Date.now();
+        const isError = status >= 400 ? 1 : 0;
+        await (0, db_js_1.run_async)("INSERT INTO cybermem_access_log (timestamp, client_name, client_version, method, endpoint, tool, status, is_error) VALUES (?, ?, ?, 'POST', '/mcp', ?, ?, ?)", [ts, client, PACKAGE_VERSION, tool, status.toString(), isError]);
+        await (0, db_js_1.run_async)("INSERT INTO cybermem_stats (client_name, tool, count, errors, last_updated) VALUES (?, ?, 1, ?, ?) ON CONFLICT(client_name, tool) DO UPDATE SET count=count+1, errors=errors+?, last_updated=?", [client, tool, isError, ts, isError, ts]);
     }
-    catch { }
-    try {
-        const { Memory } = await import("openmemory-js/dist/core/memory.js");
-        const hsg = await import("openmemory-js/dist/memory/hsg.js");
-        sdk_update_memory = hsg.update_memory;
-        sdk_reinforce_memory = hsg.reinforce_memory;
-        memory = new Memory();
-        // Initialize Tables
-        const sqlite3 = await import("sqlite3");
-        const db = new sqlite3.default.Database(dbPath);
-        db.configure("busyTimeout", 5000);
-        db.serialize(() => {
-            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));");
-            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);");
-            db.run("CREATE TABLE IF NOT EXISTS access_keys (id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))), key_hash TEXT NOT NULL, name TEXT DEFAULT 'default', user_id TEXT DEFAULT 'default', created_at TEXT DEFAULT (datetime('now')), last_used_at TEXT, is_active INTEGER DEFAULT 1);");
-        });
-        db.close();
+    catch (err) {
+        console.error("[MCP] Log Error:", err.message);
     }
-    catch (e) {
-        console.error("Failed to initialize OpenMemory SDK:", e);
-        console.error("[FATAL] CyberMem cannot start without a working database. " +
-            "Check OM_DB_PATH and ensure sqlite3 native bindings are installed.");
+};
+// --- INITIALIZATION ---
+async function initialize() {
+    const dbPath = process.env.OM_DB_PATH;
+    if (!dbPath) {
+        console.error("[INIT] Environment variable OM_DB_PATH is not set. Please configure OM_DB_PATH to point to the OpenMemory database file (e.g., /path/to/openmemory.db).");
         process.exit(1);
     }
-    // PERSISTENT LOGGING DB
-    let loggingDb = null;
-    const initLoggingDb = async () => {
-        if (loggingDb)
-            return loggingDb;
-        const dbPath = process.env.OM_DB_PATH;
-        const sqlite3 = await import("sqlite3");
-        loggingDb = new sqlite3.default.Database(dbPath);
-        loggingDb.configure("busyTimeout", 10000);
-        return new Promise((resolve) => {
-            loggingDb.serialize(() => {
-                loggingDb.run("PRAGMA journal_mode=WAL;");
-                loggingDb.run("PRAGMA synchronous=NORMAL;", () => resolve(loggingDb));
-            });
-        });
-    };
-    let stdioClientName = undefined;
-    // Protocol Instructions
-    const CYBERMEM_INSTRUCTIONS = `CyberMem is a persistent context daemon for AI agents.
-PROTOCOL:
-1. On session start: call query_memory("user context profile")
-2. Store new insights immediately with add_memory (STABLE data)
-3. For corrections: use update_memory (STRUCTURAL mutation, high cost)
-4. To prevent decay: use reinforce_memory (METABOLIC boost, low cost)
-5. Always include tags: [topic, year, source:your-client-name]
-For full protocol: https://docs.cybermem.dev/agent-protocol`;
-    const logActivity = async (operation, opts = {}) => {
-        // Determine client name (priority: specific > store > default)
-        let client;
-        const ctx = requestContext.getStore();
-        if (opts.sessionId) {
-            // For SSE sessions, prefer the real client name from the request context when available
-            client = ctx?.clientName || "sse-client";
+    const dir = (0, path_1.dirname)(dbPath);
+    if (dir && !(0, fs_1.existsSync)(dir))
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    // Migrations
+    try {
+        await (0, db_js_1.run_async)("CREATE TABLE IF NOT EXISTS cybermem_stats (id INTEGER PRIMARY KEY AUTOINCREMENT, client_name TEXT NOT NULL, tool TEXT NOT NULL, count INTEGER DEFAULT 0, errors INTEGER DEFAULT 0, last_updated INTEGER NOT NULL, UNIQUE(client_name, tool));");
+        await (0, db_js_1.run_async)("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, tool TEXT NOT NULL, status TEXT NOT NULL, is_error INTEGER DEFAULT 0);");
+        // Robustly check for and rename 'operation' to 'tool'
+        const statsInfo = (await (0, db_js_1.all_async)("PRAGMA table_info(cybermem_stats);"));
+        if (statsInfo.some((col) => col.name === "operation")) {
+            await (0, db_js_1.run_async)("ALTER TABLE cybermem_stats RENAME COLUMN operation TO tool;");
         }
-        else if (ctx) {
-            client = ctx.clientName || stdioClientName || "unknown";
+        else if (!statsInfo.some((col) => col.name === "tool")) {
+            await (0, db_js_1.run_async)("ALTER TABLE cybermem_stats ADD COLUMN tool TEXT DEFAULT 'unknown';");
         }
-        else {
-            client = stdioClientName || "unknown";
+        const logInfo = (await (0, db_js_1.all_async)("PRAGMA table_info(cybermem_access_log);"));
+        if (logInfo.some((col) => col.name === "operation")) {
+            await (0, db_js_1.run_async)("ALTER TABLE cybermem_access_log RENAME COLUMN operation TO tool;");
         }
-        const { method = "POST", endpoint = "/mcp", status = 200 } = opts;
-        try {
-            const db = await initLoggingDb();
-            const ts = Date.now();
-            const is_error = status >= 400 ? 1 : 0;
-            db.serialize(() => {
-                db.run("INSERT INTO cybermem_access_log (timestamp, client_name, client_version, method, endpoint, operation, status, is_error) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [
-                    ts,
-                    client,
-                    PACKAGE_VERSION,
-                    method,
-                    endpoint,
-                    operation,
-                    status.toString(),
-                    is_error,
-                ]);
-                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]);
-            });
+        else if (!logInfo.some((col) => col.name === "tool")) {
+            await (0, db_js_1.run_async)("ALTER TABLE cybermem_access_log ADD COLUMN tool TEXT DEFAULT 'unknown';");
         }
-        catch { }
-    };
-    // Factory to create configured McpServer instance
-    const createConfiguredServer = (onClientConnected) => {
-        const server = new mcp_js_1.McpServer({ name: "cybermem", version: PACKAGE_VERSION }, {
-            instructions: CYBERMEM_INSTRUCTIONS,
-        });
-        // access underlying server to set internal state for direct memory access
-        // Casting to unknown first to allow adding private property
-        server._memoryReady = true;
-        server.registerResource("CyberMem Agent Protocol", "cybermem://protocol", { description: "Instructions for AI agents", mimeType: "text/plain" }, async () => ({
-            contents: [
-                {
-                    uri: "cybermem://protocol",
-                    mimeType: "text/plain",
-                    text: CYBERMEM_INSTRUCTIONS,
-                },
-            ],
-        }));
-        // access underlying server
-        server.server.setRequestHandler(types_js_1.InitializeRequestSchema, async (request) => {
-            // For SSE multiple clients, stdioClientName global is less useful,
-            // but we can set it for context if running in single-user mode.
-            // For multi-user, rely on requestContext.
-            // For SSE multiple clients, rely on per-request context instead of a global.
-            const clientName = request.params.clientInfo.name;
-            if (onClientConnected) {
-                onClientConnected(clientName);
+        // Backfill NULL tool values for SQLite safety
+        await (0, db_js_1.run_async)("UPDATE cybermem_access_log SET tool = 'unknown' WHERE tool IS NULL;");
+        await (0, db_js_1.run_async)("UPDATE cybermem_stats SET tool = 'unknown' WHERE tool IS NULL;");
+    }
+    catch (e) {
+        console.error("[INIT] Migration Error: Failed to apply database migrations:", e?.message ?? e);
+        process.exit(1);
+    }
+}
+const server = new fastmcp_1.FastMCP({
+    name: "cybermem",
+    version: VALID_VERSION,
+    instructions: CYBERMEM_INSTRUCTIONS,
+    health: { enabled: true, path: "/health" },
+    authenticate: async (req) => {
+        const clientName = (req.headers["x-client-name"] ||
+            req.headers["X-Client-Name"] ||
+            "unknown");
+        // Extract versioned naming if present (e.g. "antigravity/v1.0.0" -> "antigravity")
+        return { clientName: clientName.split("/")[0] };
+    },
+});
+const memory = new memory_js_1.Memory();
+const app = server.getApp();
+// Keep Hono middleware for custom routes if any, though FastMCP transport bypasses it
+app.use("*", async (c, next) => {
+    const clientName = (c.req.header("X-Client-Name") ||
+        c.req.header("x-client-name") ||
+        "unknown").split("/")[0];
+    return requestContext.run({ clientName }, next);
+});
+// TOOLS
+server.addTool({
+    name: "add_memory",
+    description: "Store a new memory with optional tags for semantic retrieval.",
+    parameters: zod_1.z.object({
+        content: zod_1.z.string().describe("The text content of the memory"),
+        tags: zod_1.z.array(zod_1.z.string()).optional().describe("Category tags"),
+    }),
+    execute: async (args, context) => {
+        return requestContext.run({ clientName: context.session?.clientName }, async () => {
+            try {
+                const res = await memory.add(args.content, { tags: args.tags });
+                await logActivity("add_memory");
+                return JSON.stringify(res);
             }
-            else {
-                stdioClientName = clientName;
+            catch (err) {
+                await logActivity("add_memory", 500);
+                throw err;
             }
-            console.error(`[MCP] Client identified via handshake: ${clientName}`);
-            return {
-                protocolVersion: "2024-11-05",
-                capabilities: {
-                    tools: { listChanged: true },
-                    resources: { subscribe: true },
-                },
-                serverInfo: {
-                    name: "cybermem",
-                    version: PACKAGE_VERSION,
-                },
-            };
-        });
-        // TOOLS
-        server.registerTool("add_memory", {
-            description: "Store a new memory. Use for high-quality, stable data. " +
-                CYBERMEM_INSTRUCTIONS,
-            inputSchema: zod_1.z.object({
-                content: zod_1.z.string(),
-                tags: zod_1.z.array(zod_1.z.string()).optional(),
-            }),
-        }, async (args) => {
-            const res = await memory.add(args.content, { tags: args.tags });
-            await logActivity("create", {
-                method: "POST",
-                endpoint: "/memory/add",
-                status: 200,
-            });
-            return { content: [{ type: "text", text: JSON.stringify(res) }] };
-        });
-        server.registerTool("query_memory", {
-            description: "Search memories.",
-            inputSchema: zod_1.z.object({ query: zod_1.z.string(), k: zod_1.z.number().default(5) }),
-        }, async (args) => {
-            const res = await memory.search(args.query, { limit: args.k });
-            await logActivity("read", {
-                method: "POST",
-                endpoint: "/memory/query",
-                status: 200,
-            });
-            return { content: [{ type: "text", text: JSON.stringify(res) }] };
         });
-        server.registerTool("update_memory", {
-            description: "Mutate existing memory (content/tags). HIGH COST: re-embeds and re-links. Use for corrections.",
-            inputSchema: zod_1.z.object({
-                id: zod_1.z.string(),
-                content: zod_1.z.string().optional(),
-                tags: zod_1.z.array(zod_1.z.string()).optional(),
-            }),
-        }, async (args) => {
-            if (!sdk_update_memory)
-                throw new Error("Update not available in SDK");
-            if (args.content === undefined && args.tags === undefined) {
-                throw new Error("At least one of 'content' or 'tags' must be provided to update_memory");
+    },
+});
+server.addTool({
+    name: "query_memory",
+    description: "Retrieve relevant memories using semantic search.",
+    parameters: zod_1.z.object({
+        query: zod_1.z.string().describe("Search query string"),
+        k: zod_1.z.number().default(5).describe("Number of results"),
+    }),
+    execute: async (args, context) => {
+        return requestContext.run({ clientName: context.session?.clientName }, async () => {
+            try {
+                const res = await memory.search(args.query, { limit: args.k });
+                await logActivity("query_memory");
+                return JSON.stringify(res);
             }
-            const res = await sdk_update_memory(args.id, args.content, args.tags);
-            await logActivity("update", {
-                method: "PATCH",
-                endpoint: `/memory/${args.id}`,
-                status: 200,
-            });
-            return { content: [{ type: "text", text: JSON.stringify(res) }] };
-        });
-        server.registerTool("reinforce_memory", {
-            description: "Metabolic boost (salience). LOW COST: prevents decay without mutation. Use for active topics.",
-            inputSchema: zod_1.z.object({
-                id: zod_1.z.string(),
-                boost: zod_1.z.number().default(0.1),
-            }),
-        }, async (args) => {
-            if (!sdk_reinforce_memory)
-                throw new Error("Reinforce not available in SDK");
-            const res = await sdk_reinforce_memory(args.id, args.boost);
-            await logActivity("update", {
-                method: "POST",
-                endpoint: `/memory/${args.id}/reinforce`,
-                status: 200,
-            });
-            return { content: [{ type: "text", text: JSON.stringify(res) }] };
-        });
-        server.registerTool("delete_memory", {
-            description: "Delete memory",
-            inputSchema: zod_1.z.object({ id: zod_1.z.string() }),
-        }, async (args) => {
-            const dbPath = process.env.OM_DB_PATH;
-            const sqlite3 = await import("sqlite3");
-            const db = new sqlite3.default.Database(dbPath);
-            return new Promise((resolve, reject) => {
-                db.serialize(() => {
-                    db.run("DELETE FROM memories WHERE id = ?", [args.id]);
-                    db.run("DELETE FROM vectors WHERE id = ?", [args.id], async (err) => {
-                        db.close();
-                        await logActivity("delete", {
-                            method: "DELETE",
-                            endpoint: `/memory/${args.id}`,
-                            status: err ? 500 : 200,
-                        });
-                        if (err)
-                            reject(err);
-                        else
-                            resolve({ content: [{ type: "text", text: "Deleted" }] });
-                    });
-                });
-            });
-        });
-        return server;
-    };
-    // EXPRESS SERVER
-    // HTTP server mode for Docker/Traefik deployment
-    const useHttp = args.includes("--http") || args.includes("--port");
-    if (useHttp) {
-        const port = parseInt(getArg("--port") || "3100", 10);
-        const app = (0, express_1.default)();
-        app.use((0, cors_1.default)());
-        app.use((req, res, next) => {
-            // Skip JSON parsing for SSE message endpoint - it needs raw body stream
-            // Use req.url to handle query params like /message?sessionId=...
-            if (req.url.startsWith("/message")) {
-                return next();
+            catch (err) {
+                await logActivity("query_memory", 500);
+                throw err;
             }
-            express_1.default.json()(req, res, next);
-        });
-        app.get("/health", (req, res) => res.json({ ok: true, version: PACKAGE_VERSION }));
-        app.use((req, res, next) => {
-            const clientName = req.headers["x-client-name"] || "antigravity-client";
-            requestContext.run({ clientName }, next);
-        });
-        if (memory) {
-            app.post("/add", async (req, res) => {
-                try {
-                    const result = await memory.add(req.body.content, {
-                        id: req.body.id,
-                        tags: req.body.tags,
-                    });
-                    await logActivity("create", {
-                        method: "POST",
-                        endpoint: "/add",
-                        status: 200,
-                    });
-                    res.json(result);
-                }
-                catch (e) {
-                    res.status(500).json({ error: e.message });
-                }
-            });
-            app.post("/query", async (req, res) => {
-                try {
-                    const result = await memory.search(req.body.query || "", {
-                        limit: req.body.k || 5,
-                    });
-                    await logActivity("read", {
-                        method: "POST",
-                        endpoint: "/query",
-                        status: 200,
-                    });
-                    res.json(result);
-                }
-                catch (e) {
-                    res.status(500).json({ error: e.message });
-                }
-            });
-            app.get("/all", async (req, res) => {
-                try {
-                    const result = await memory.search("", { limit: 10 });
-                    await logActivity("read", {
-                        method: "GET",
-                        endpoint: "/all",
-                        status: 200,
-                    });
-                    res.json(result);
-                }
-                catch (e) {
-                    res.status(500).json({ error: e.message });
-                }
-            });
-            app.patch("/memory/:id", async (req, res) => {
-                try {
-                    const result = await sdk_update_memory(req.params.id, req.body.content, req.body.tags, req.body.metadata);
-                    await logActivity("update", {
-                        method: "PATCH",
-                        endpoint: `/memory/${req.params.id}`,
-                        status: 200,
-                    });
-                    res.json(result);
-                }
-                catch (e) {
-                    res.status(500).json({ error: e.message });
-                }
-            });
-            app.post("/memory/:id/reinforce", async (req, res) => {
-                try {
-                    await sdk_reinforce_memory(req.params.id, req.body.boost);
-                    await logActivity("update", {
-                        method: "POST",
-                        endpoint: `/memory/${req.params.id}/reinforce`,
-                        status: 200,
-                    });
-                    res.json({ ok: true });
-                }
-                catch (e) {
-                    res.status(500).json({ error: e.message });
-                }
-            });
-            app.delete("/memory/:id", async (req, res) => {
-                const dbPath = process.env.OM_DB_PATH;
-                const sqlite3 = await import("sqlite3");
-                const db = new sqlite3.default.Database(dbPath);
-                db.run("DELETE FROM memories WHERE id = ?", [req.params.id], async () => {
-                    db.close();
-                    await logActivity("delete", {
-                        method: "DELETE",
-                        endpoint: `/memory/${req.params.id}`,
-                        status: 200,
-                    });
-                    res.json({ ok: true });
-                });
-            });
-        }
-        // MULTI-SESSION SSE SUPPORT
-        const sessions = new Map();
-        // Legacy MCP endpoint - 410 Gone
-        app.all("/mcp", (req, res) => {
-            res
-                .status(410)
-                .send("Endpoint /mcp is deprecated. Please update your client configuration to use /sse for Server-Sent Events.");
         });
-        app.get("/sse", async (req, res) => {
-            console.error("[MCP] Attempting SSE Connection...");
-            const transport = new sse_js_1.SSEServerTransport("/message", res);
-            const newServer = createConfiguredServer((name) => {
-                const session = sessions.get(transport.sessionId);
-                if (session)
-                    session.clientName = name;
-            });
+    },
+});
+server.addTool({
+    name: "update_memory",
+    description: "Update an existing memory's content or tags. At least one must be provided.",
+    parameters: zod_1.z
+        .object({
+        id: zod_1.z.string().describe("Memory ID"),
+        content: zod_1.z.string().optional().describe("New content"),
+        tags: zod_1.z.array(zod_1.z.string()).optional().describe("New tags"),
+    })
+        .refine((data) => data.content !== undefined || data.tags !== undefined, {
+        message: "Either content or tags must be provided for update",
+        path: ["content"],
+    }),
+    execute: async (args, context) => {
+        return requestContext.run({ clientName: context.session?.clientName }, async () => {
             try {
-                await newServer.connect(transport);
-                sessions.set(transport.sessionId, { server: newServer, transport });
-                transport.onclose = () => {
-                    console.error(`[MCP] SSE Connection Closed: ${transport.sessionId}`);
-                    sessions.delete(transport.sessionId);
-                };
-                transport.onerror = (err) => {
-                    console.error(`[MCP] SSE Connection Error: ${transport.sessionId}`, err);
-                    sessions.delete(transport.sessionId);
-                };
-                // await transport.start(); // FIXED: connect() starts it automatically
+                const res = await (0, hsg_js_1.update_memory)(args.id, args.content, args.tags);
+                await logActivity("update_memory");
+                return JSON.stringify(res);
             }
             catch (err) {
-                console.error("[MCP] Failed to start SSE transport:", err);
-                sessions.delete(transport.sessionId);
-                // If headers haven't been sent, send 500
-                if (!res.headersSent) {
-                    res.status(500).send("Internal Server Error during SSE handshake");
-                }
+                await logActivity("update_memory", 500);
+                throw err;
             }
         });
-        app.post("/message", async (req, res) => {
-            const sessionId = req.query.sessionId;
-            const session = sessions.get(sessionId);
-            if (!session) {
-                res.status(404).send("Session not found");
-                return;
+    },
+});
+server.addTool({
+    name: "reinforce_memory",
+    description: "Boost a memory's relevance score to prevent decay.",
+    parameters: zod_1.z.object({
+        id: zod_1.z.string().describe("Memory ID"),
+        boost: zod_1.z
+            .number()
+            .default(0.1)
+            .describe("Relevance boost amount (0.0 to 1.0)"),
+    }),
+    execute: async (args, context) => {
+        return requestContext.run({ clientName: context.session?.clientName }, async () => {
+            try {
+                await (0, hsg_js_1.reinforce_memory)(args.id, args.boost);
+                await logActivity("reinforce_memory");
+                return `Memory reinforced: ${args.id}`;
+            }
+            catch (err) {
+                await logActivity("reinforce_memory", 500);
+                throw err;
             }
+        });
+    },
+});
+server.addTool({
+    name: "delete_memory",
+    description: "Permanently delete a memory and its associated vectors.",
+    parameters: zod_1.z.object({
+        id: zod_1.z.string().describe("Memory ID"),
+    }),
+    execute: async (args, context) => {
+        return requestContext.run({ clientName: context.session?.clientName }, async () => {
             try {
-                const clientName = session.clientName || "sse-client";
-                await requestContext.run({ clientName }, async () => {
-                    await session.transport.handlePostMessage(req, res);
-                });
+                await (0, db_js_1.run_async)("DELETE FROM memories WHERE id=?", [args.id]);
+                await (0, db_js_1.run_async)("DELETE FROM vectors WHERE id=?", [args.id]);
+                await logActivity("delete_memory");
+                return "Deleted";
             }
             catch (err) {
-                console.error(`[MCP] Error handling message for session ${sessionId}:`, err);
-                if (!res.headersSent) {
-                    res.status(500).send("Internal Server Error processing message");
-                }
+                await logActivity("delete_memory", 500);
+                throw err;
             }
         });
-        app.listen(port, () => console.error(`CyberMem MCP running on http://localhost:${port}`));
+    },
+});
+// START
+async function main() {
+    console.error("[INIT] Starting CyberMem MCP...");
+    await initialize();
+    console.error("[INIT] Database initialized.");
+    const argsArr = process.argv.slice(2);
+    const getArg = (name) => {
+        const idx = argsArr.indexOf(name);
+        return idx !== -1 ? argsArr[idx + 1] : undefined;
+    };
+    const port = parseInt(getArg("--port") || "3100", 10);
+    const useHttp = argsArr.includes("--http") || argsArr.includes("--port");
+    console.error(`[INIT] Starting ${useHttp ? "HTTP" : "STDIO"} server...`);
+    await server.start({
+        transportType: useHttp ? "httpStream" : "stdio",
+        httpStream: useHttp
+            ? {
+                port,
+                host: "0.0.0.0",
+                endpoint: "/mcp",
+                stateless: false,
+                enableJsonResponse: true,
+            }
+            : undefined,
+    });
+    if (useHttp) {
+        console.error(`CyberMem MCP running on http://localhost:${port}/mcp`);
     }
     else {
-        // STDIO
-        const transport = new stdio_js_1.StdioServerTransport();
-        const server = createConfiguredServer();
-        server
-            .connect(transport)
-            .then(() => console.error("CyberMem MCP connected via STDIO"));
+        console.error(`CyberMem MCP ${VALID_VERSION} [STDIO]`);
     }
 }
+main().catch((err) => {
+    console.error("[CRITICAL] Main Failure:", err);
+    process.exit(1);
+});