mortgram-bridge 2.3.0

package/index.mjs

@@ -0,0 +1,397 @@
+#!/usr/bin/env node
+// ═══════════════════════════════════════════════════════════════════
+// MORTGRAM Gateway Bridge — Zero-config OpenClaw Event Forwarder
+// ═══════════════════════════════════════════════════════════════════
+// Connects to the OpenClaw Gateway WebSocket and forwards all agent
+// events to the MORTGRAM dashboard API.
+//
+// Usage:
+//   npx mortgram-bridge --token YOUR_MORTGRAM_TOKEN
+//   node bridge/index.mjs --token YOUR_MORTGRAM_TOKEN
+// ═══════════════════════════════════════════════════════════════════
+
+import { WebSocket } from "ws";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+
+// ─── CLI Args ─────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+function getArg(name) {
+    const idx = args.indexOf(`--${name}`);
+    return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
+}
+
+const MORTGRAM_TOKEN = getArg("token") || process.env.MORTGRAM_API_KEY || process.env.MG_LIVE_KEY || "";
+const MORTGRAM_API = getArg("api") || process.env.MORTGRAM_API_URL || "https://mortgram.online/api/ingest";
+const GATEWAY_URL_OVERRIDE = getArg("gateway-url");
+const AGENT_ID = getArg("agent-id") || "gateway-bridge";
+
+if (!MORTGRAM_TOKEN) {
+    console.error("\x1b[31m[MORTGRAM] ERROR: No --token provided.\x1b[0m");
+    console.error("\x1b[33m  Usage: npx mortgram-bridge --token YOUR_MORTGRAM_TOKEN\x1b[0m");
+    console.error("\x1b[33m  Get your token from the MORTGRAM dashboard.\x1b[0m");
+    process.exit(1);
+}
+
+// ─── Auto-Detect OpenClaw Config ──────────────────────────────────
+function loadOpenClawConfig() {
+    const configPaths = [
+        path.join(os.homedir(), ".openclaw", "openclaw.json"),
+        path.join(os.homedir(), ".clawdbot", "clawdbot.json"),
+    ];
+
+    for (const p of configPaths) {
+        try {
+            if (fs.existsSync(p)) {
+                const raw = JSON.parse(fs.readFileSync(p, "utf8"));
+                const port = raw?.gateway?.port || 18789;
+                const token = raw?.gateway?.auth?.token || "";
+                const mode = raw?.gateway?.auth?.mode || "token";
+                console.log(`\x1b[90m[MORTGRAM] Found OpenClaw config: ${p}\x1b[0m`);
+                console.log(`\x1b[90m[MORTGRAM] Gateway port: ${port}, auth: ${mode}\x1b[0m`);
+                return { port, token, mode };
+            }
+        } catch (e) {
+            // Skip invalid config
+        }
+    }
+
+    console.warn("\x1b[33m[MORTGRAM] No OpenClaw config found, using defaults.\x1b[0m");
+    return { port: 18789, token: "", mode: "token" };
+}
+
+const ocConfig = loadOpenClawConfig();
+const GATEWAY_URL = GATEWAY_URL_OVERRIDE || `ws://127.0.0.1:${ocConfig.port}`;
+const GATEWAY_TOKEN = ocConfig.token;
+
+// ─── State ────────────────────────────────────────────────────────
+let ws = null;
+let connected = false;
+let connectNonce = null;
+let reconnectDelay = 500;
+let eventCount = 0;
+let lastAgentId = AGENT_ID;
+let lastAgentName = "";
+let heartbeatTimer = null;
+
+// Tracking
+let latestThought = "Bridge starting...";
+let dailyCost = 0;
+let totalTurns = 0;
+let successfulTools = 0;
+
+// ─── Retry Queue ──────────────────────────────────────────────────
+const retryQueue = [];
+const MAX_QUEUE = 50;
+let retryTimer = null;
+
+function drainRetryQueue() {
+    if (retryQueue.length === 0) {
+        retryTimer = null;
+        return;
+    }
+    const item = retryQueue.shift();
+    _sendPayload(item.payload, item.attempt + 1)
+        .then(() => {
+            // Success — continue draining
+            if (retryQueue.length > 0) {
+                retryTimer = setTimeout(drainRetryQueue, 200);
+            } else {
+                retryTimer = null;
+            }
+        })
+        .catch(() => {
+            // Still failing — put back and slow down
+            retryQueue.unshift({ ...item, attempt: item.attempt + 1 });
+            const delay = Math.min(3000 * Math.pow(1.5, item.attempt), 15000);
+            retryTimer = setTimeout(drainRetryQueue, delay);
+        });
+}
+
+// ─── MORTGRAM API ─────────────────────────────────────────────────
+async function _sendPayload(payload, attempt = 0) {
+    const res = await fetch(MORTGRAM_API, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "x-mortgram-token": MORTGRAM_TOKEN
+        },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`API ${res.status}: ${body}`);
+    }
+}
+
+async function sendToMortgram(type, content, metadata = {}) {
+    const payload = {
+        agent_id: lastAgentId,
+        type,
+        content,
+        metadata: {
+            ...metadata,
+            agent_name: lastAgentName || lastAgentId,
+            daily_cost: dailyCost,
+            efficiency: totalTurns > 0 ? (successfulTools / totalTurns) : 0,
+            latest_thought: latestThought,
+            status: "online",
+            timestamp: new Date().toISOString()
+        }
+    };
+
+    try {
+        await _sendPayload(payload);
+    } catch (e) {
+        console.error(`\x1b[31m[MORTGRAM] API Error: ${e.message} — queuing for retry\x1b[0m`);
+        if (retryQueue.length < MAX_QUEUE) {
+            retryQueue.push({ payload, attempt: 0 });
+            if (!retryTimer) {
+                retryTimer = setTimeout(drainRetryQueue, 3000);
+            }
+        } else {
+            console.warn(`\x1b[33m[MORTGRAM] Retry queue full (${MAX_QUEUE}), dropping event\x1b[0m`);
+        }
+    }
+}
+
+// ─── Event Processing ─────────────────────────────────────────────
+function processEvent(evt) {
+    const { event, payload, seq } = evt;
+
+    // Skip internal/tick events
+    if (event === "tick" || event === "connect.challenge") return;
+
+    eventCount++;
+
+    // Extract agent info from various event shapes
+    const data = payload || {};
+    const agentId = data.agentId || data.agent_id || data.runId?.split("-")[0] || lastAgentId;
+    if (agentId !== lastAgentId && agentId !== "gateway-bridge") {
+        lastAgentId = agentId;
+    }
+    // Extract agent name if available
+    const agentName = data.agentName || data.agent_name || data.displayName || data.name || "";
+    if (agentName && agentName !== lastAgentName) {
+        lastAgentName = agentName;
+    }
+
+    let type = "log";
+    let content = `${event}`;
+
+    // Map OpenClaw events to MORTGRAM types
+    if (event.startsWith("agent.")) {
+        // Agent-level events
+        if (event === "agent.run.start" || event === "agent.start") {
+            type = "system";
+            content = `Agent session started: ${agentId}`;
+            totalTurns = 0;
+            successfulTools = 0;
+        } else if (event === "agent.run.end" || event === "agent.end") {
+            type = "system";
+            content = `Agent session ended: ${agentId}`;
+        } else if (event.includes("thought") || event.includes("reasoning") || event.includes("think")) {
+            totalTurns++;
+            latestThought = data.text || data.content || data.message || "Thinking...";
+            type = "thought";
+            content = latestThought;
+        } else if (event.includes("response") || event.includes("message") || event.includes("reply")) {
+            latestThought = (data.text || data.content || data.message || "").slice(0, 200) || "Response generated";
+            type = "thought";
+            content = latestThought;
+        } else if (event.includes("error")) {
+            type = "error";
+            content = data.message || data.text || data.error || "Agent error";
+        }
+    } else if (event.startsWith("tool.") || event.startsWith("exec.")) {
+        // Tool execution events
+        if (event.includes("result") || event.includes("end") || event.includes("done")) {
+            successfulTools++;
+        }
+        type = "action";
+        content = data.name || data.tool || data.command || event;
+    } else if (event.startsWith("session.")) {
+        if (event.includes("usage") || event.includes("cost")) {
+            dailyCost = data.total_cost || data.cost || data.totalCost || dailyCost;
+            type = "cost_update";
+            content = `Daily spend: $${dailyCost.toFixed(4)}`;
+        } else {
+            type = "system";
+            content = event;
+        }
+    } else if (event === "system.notify" || event === "system.presence") {
+        type = "system";
+        content = data.text || data.message || event;
+    } else if (event === "shutdown") {
+        type = "system";
+        content = `Gateway shutdown: ${data.reason || "unknown"}`;
+    }
+
+    // Forward to MORTGRAM
+    console.log(`\x1b[34m[MORTGRAM] 📡 #${eventCount} ${event}\x1b[0m`);
+    sendToMortgram(type, content, { event, seq, ...data });
+}
+
+// ─── Gateway WebSocket Connection ─────────────────────────────────
+function sendConnectFrame() {
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+
+    const id = crypto.randomUUID();
+    const connectParams = {
+        minProtocol: 3,
+        maxProtocol: 3,
+        client: {
+            id: "gateway-client",
+            displayName: "MORTGRAM Bridge",
+            version: "2.3.0",
+            platform: process.platform,
+            mode: "backend",
+        },
+        caps: ["tool-events"],
+        auth: GATEWAY_TOKEN ? { token: GATEWAY_TOKEN } : undefined,
+        role: "operator",
+        scopes: ["operator.admin"],
+    };
+
+    const frame = {
+        type: "req",
+        id,
+        method: "connect",
+        params: connectParams
+    };
+
+    ws.send(JSON.stringify(frame));
+}
+
+function connect() {
+    if (ws) {
+        try { ws.close(); } catch (_) { }
+        ws = null;
+    }
+
+    console.log(`\x1b[90m[MORTGRAM] Connecting to gateway: ${GATEWAY_URL}\x1b[0m`);
+
+    ws = new WebSocket(GATEWAY_URL, { maxPayload: 25 * 1024 * 1024 });
+
+    ws.on("open", () => {
+        console.log("\x1b[32m[MORTGRAM] WebSocket connected, sending handshake...\x1b[0m");
+        connectNonce = null;
+        // Send connect frame immediately — if gateway needs a challenge,
+        // it will respond and we resend in the message handler
+        sendConnectFrame();
+        // Fallback: resend after 100ms if challenge was needed
+        setTimeout(() => {
+            if (!connected) sendConnectFrame();
+        }, 100);
+    });
+
+    ws.on("message", (rawData) => {
+        try {
+            const msg = JSON.parse(rawData.toString());
+
+            // Event frame: has "event" field
+            if (msg.event) {
+                // Handle connect challenge
+                if (msg.event === "connect.challenge") {
+                    connectNonce = msg.payload?.nonce || null;
+                    sendConnectFrame();
+                    return;
+                }
+
+                processEvent(msg);
+                return;
+            }
+
+            // Response frame: has "id" and "ok" fields
+            if (msg.id && typeof msg.ok !== "undefined") {
+                if (msg.ok) {
+                    if (!connected) {
+                        connected = true;
+                        reconnectDelay = 500;
+                        console.log("\x1b[32m[MORTGRAM] ✅ Ghost Bridge: LINK ACTIVE\x1b[0m");
+                        console.log("\x1b[32m[MORTGRAM] Streaming all agent events to dashboard...\x1b[0m");
+
+                        // Send initial heartbeat and READY signal to MORTGRAM
+                        sendToMortgram("system", "Ghost Bridge connected", {
+                            event: "bridge.connect",
+                            gateway_url: GATEWAY_URL,
+                            action: "AGENT_READY" // Triggers UI flip
+                        });
+
+                        // Start heartbeat pings to keep connection alive
+                        if (heartbeatTimer) clearInterval(heartbeatTimer);
+                        heartbeatTimer = setInterval(() => {
+                            if (ws && ws.readyState === WebSocket.OPEN) {
+                                try { ws.ping(); } catch (_) { /* noop */ }
+                            }
+                        }, 25000);
+                    }
+                } else {
+                    console.error(`\x1b[31m[MORTGRAM] Gateway rejected: ${msg.error?.message || "Unknown"}\x1b[0m`);
+                }
+            }
+        } catch (e) {
+            // Non-JSON message, ignore
+        }
+    });
+
+    ws.on("close", (code, reason) => {
+        const wasConnected = connected;
+        connected = false;
+        connectNonce = null;
+
+        // Stop heartbeat
+        if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+
+        const reasonText = reason?.toString() || "";
+        if (wasConnected) {
+            console.log(`\x1b[33m[MORTGRAM] Gateway disconnected (${code}): ${reasonText}\x1b[0m`);
+            sendToMortgram("system", "Ghost Bridge disconnected", { event: "bridge.disconnect" });
+        }
+
+        // Auto-reconnect with backoff
+        console.log(`\x1b[90m[MORTGRAM] Reconnecting in ${reconnectDelay / 1000}s...\x1b[0m`);
+        setTimeout(connect, reconnectDelay);
+        reconnectDelay = Math.min(reconnectDelay * 2, 30000);
+    });
+
+    ws.on("error", (err) => {
+        if (!connected) {
+            // Silently handle — reconnect will kick in via close event
+        }
+    });
+}
+
+// ─── Banner ───────────────────────────────────────────────────────
+console.log("");
+console.log("\x1b[35m  ╔══════════════════════════════════════╗\x1b[0m");
+console.log("\x1b[35m  ║   MORTGRAM Ghost Bridge v2.3.0       ║\x1b[0m");
+console.log("\x1b[35m  ║   Zero-config Event Forwarder        ║\x1b[0m");
+console.log("\x1b[35m  ╚══════════════════════════════════════╝\x1b[0m");
+console.log("");
+console.log(`\x1b[90m  Gateway:   ${GATEWAY_URL}\x1b[0m`);
+console.log(`\x1b[90m  Dashboard: ${MORTGRAM_API}\x1b[0m`);
+console.log(`\x1b[90m  Auth:      ${GATEWAY_TOKEN ? "Token ✓" : "None"}\x1b[0m`);
+console.log("");
+
+// ─── Start ────────────────────────────────────────────────────────
+connect();
+
+// ─── Graceful Shutdown ────────────────────────────────────────────
+function shutdown() {
+    console.log("\n\x1b[33m[MORTGRAM] Shutting down...\x1b[0m");
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    sendToMortgram("system", "Ghost Bridge shutdown", { event: "bridge.shutdown" });
+    if (ws) ws.close();
+    setTimeout(() => process.exit(0), 500);
+}
+
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+// Windows: Ctrl+Break and console close
+if (process.platform === "win32") {
+    process.on("SIGBREAK", shutdown);
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+    "name": "mortgram-bridge",
+    "version": "2.3.0",
+    "description": "MORTGRAM Ghost Bridge — Zero-config OpenClaw event forwarder",
+    "type": "module",
+    "main": "index.mjs",
+    "bin": {
+        "mortgram-bridge": "./index.mjs"
+    },
+    "dependencies": {
+        "ws": "^8.18.0"
+    },
+    "keywords": [
+        "mortgram",
+        "openclaw",
+        "ai-agent",
+        "monitoring",
+        "observability"
+    ],
+    "license": "MIT"
+}