@cybermem/mcp 0.8.3 → 0.8.7

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,50 +12,42 @@
  * 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();
-// Handle CLI auth commands first
+// 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();
+// CLI args processing
 const args = process.argv.slice(2);
-if (args.includes("--login")) {
-    (0, auth_js_1.login)()
-        .then(() => process.exit(0))
-        .catch((err) => {
-        console.error("Login failed:", err.message);
-        process.exit(1);
-    });
-}
-else if (args.includes("--logout")) {
-    (0, auth_js_1.logout)();
-    process.exit(0);
-}
-else if (args.includes("--status")) {
-    (0, auth_js_1.showStatus)();
-    process.exit(0);
-}
-else {
-    startServer();
-}
+// 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 cliClientName = getArg("--client-name") || "cybermem-mcp";
     const cliUrl = getArg("--url");
-    const cliApiKey = getArg("--api-key");
+    const cliToken = getArg("--token") || getArg("--api-key");
+    let stdioClientName = undefined;
     // Protocol Instructions
     const CYBERMEM_INSTRUCTIONS = `CyberMem is a persistent context daemon for AI agents.
 PROTOCOL:
@@ -58,7 +55,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 +67,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 +93,158 @@ 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);
+                });
+                // Access keys table for token-based auth
+                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
+        );`, (err) => {
+                    if (err)
+                        console.error("[MCP] Init access_keys 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 +255,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 +342,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 +363,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 +421,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 +556,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.7",
   "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";