mortgram-hook 1.0.0 → 1.0.2

package/mortgram-observer/HOOK.md

@@ -0,0 +1,43 @@
+---
+name: mortgram-observer
+description: "Stream agent events to MORTGRAM dashboard in real-time"
+homepage: https://mortgram.com
+metadata:
+  {
+    "openclaw":
+      {
+        "emoji": "👻",
+        "events": ["agent:thought", "agent:reasoning", "agent:response", "agent:message", "agent:error", "agent:start", "agent:end", "tool:call", "tool:result", "tool:error", "session:usage", "session:cost", "session:start", "session:end"],
+      },
+  }
+---
+
+# MORTGRAM Ghost Bridge
+
+Invisible observability hook for OpenClaw agents. Streams thoughts, tool calls, errors, and cost data to your MORTGRAM dashboard in real-time.
+
+## What It Does
+
+Every time your agent thinks, calls a tool, or completes a session:
+
+1. **Captures event** — Intercepts agent thoughts, tool calls, errors, and usage data
+2. **Streams to MORTGRAM** — POSTs event data to the MORTGRAM ingest API
+3. **Silent operation** — Zero performance impact, silent failure on network issues
+
+## Requirements
+
+Environment variable `MORTGRAM_API_KEY` must be set to your MORTGRAM API key from the dashboard.
+
+## Configuration
+
+Set the following environment variables:
+
+- `MORTGRAM_API_KEY` — Your MORTGRAM API key (required)
+- `MORTGRAM_API_URL` — API endpoint (default: `https://mortgram.com/api/ingest`)
+- `MG_AGENT_ID` — Agent identifier (default: `ghost-agent`)
+
+## Disabling
+
+```bash
+openclaw hooks disable mortgram-observer
+```

package/mortgram-observer/handler.js

@@ -0,0 +1,181 @@
+// ═══════════════════════════════════════════════════════
+// MORTGRAM Ghost Bridge — Native OpenClaw Hook
+// ═══════════════════════════════════════════════════════
+
+export const name = "mortgram-observer";
+
+// State
+let ably = null;
+let pulseChannel = null;
+let commandChannel = null;
+let initialized = false;
+let userId = null;
+let agentId = process.env.MG_AGENT_ID || "ghost-agent";
+
+// Tracking
+let totalTurns = 0;
+let successfulTools = 0;
+let latestThought = "Ghost Bridge Active";
+let dailyCost = 0;
+
+const API_KEY = process.env.MORTGRAM_API_KEY || process.env.MG_LIVE_KEY || "";
+const API_URL = process.env.MORTGRAM_API_URL || "https://mortgram.com/api/ingest";
+
+// Initialize Ably connection using keys from MORTGRAM API
+async function init(initialType, initialContent, initialMetadata) {
+    if (initialized || !API_KEY) return;
+    initialized = true;
+
+    try {
+        // 1. Initial Handshake + Data Ingest
+        const res = await fetch(API_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-mortgram-token": API_KEY
+            },
+            body: JSON.stringify({
+                agent_id: agentId,
+                type: initialType,
+                content: initialContent,
+                metadata: initialMetadata
+            })
+        });
+
+        const data = await res.json();
+        const ablyKey = data.ably_key;
+        userId = data.userId;
+
+        if (ablyKey && userId) {
+            // Lazy load Ably to keep startup fast
+            const { default: Ably } = await import("ably");
+            ably = new Ably.Realtime(ablyKey);
+
+            pulseChannel = ably.channels.get(`agent:pulse:${agentId}`);
+            commandChannel = ably.channels.get(`agent:commands:${agentId}`);
+
+            // Heartbeat Pulse (every 10s)
+            setInterval(() => {
+                if (pulseChannel) {
+                    pulseChannel.publish("pulse", {
+                        status: "online",
+                        latest_thought: latestThought,
+                        efficiency: totalTurns > 0 ? (successfulTools / totalTurns) : 0,
+                        daily_cost: dailyCost,
+                        timestamp: new Date().toISOString()
+                    });
+                }
+            }, 10000);
+
+            // Remote Kill Switch
+            commandChannel.subscribe("kill", async (message) => {
+                latestThought = "Remote shutdown initiated by Commander.";
+                await send("system", "Remote shutdown initiated by Commander.", {
+                    status: "offline",
+                    reason: message.data.reason || "Manual Termination"
+                });
+
+                // Signal Ably one last time
+                if (pulseChannel) {
+                    await pulseChannel.publish("pulse", { status: "offline", timestamp: new Date().toISOString() });
+                }
+
+                console.error("\x1b[31m[MORTGRAM] Remote shutdown initiated by Commander.\x1b[0m");
+                process.exit(0); // This kills the OpenClaw process/agent
+            });
+        }
+    } catch (e) {
+        // Silent fail
+    }
+}
+
+// Silently POST to the MORTGRAM ingest endpoint
+async function send(type, content, metadata = {}) {
+    if (!API_KEY) return;
+
+    try {
+        await fetch(API_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-mortgram-token": API_KEY
+            },
+            body: JSON.stringify({
+                agent_id: agentId,
+                type,
+                content,
+                metadata: {
+                    ...metadata,
+                    daily_cost: dailyCost,
+                    efficiency: totalTurns > 0 ? (successfulTools / totalTurns) : 0,
+                    latest_thought: latestThought,
+                    status: "online",
+                    timestamp: new Date().toISOString()
+                }
+            })
+        });
+    } catch (_) {
+        // Silent fail
+    }
+}
+
+export async function onEvent({ event, data }) {
+    // Determine type/content for potential init
+    let type = "log";
+    let content = "Event observed";
+
+    switch (event) {
+        case "agent:thought":
+        case "agent:reasoning":
+            totalTurns++;
+            latestThought = data?.text || data?.content || "Thinking...";
+            type = "thought";
+            content = latestThought;
+            break;
+
+        case "tool:call":
+        case "tool:result":
+            successfulTools++;
+            type = "action";
+            content = data?.name || data?.tool || "Tool Call";
+            break;
+
+        case "agent:error":
+        case "tool:error":
+            if (successfulTools > 0) successfulTools--;
+            type = "error";
+            content = data?.message || data?.text || "Error occurred";
+            break;
+
+        case "session:usage":
+        case "session:cost":
+            dailyCost = data?.total_cost || data?.cost || dailyCost;
+            type = "cost_update";
+            content = `Daily spend: $${dailyCost.toFixed(4)}`;
+            break;
+
+        case "session:start":
+        case "agent:start":
+            totalTurns = 0;
+            successfulTools = 0;
+            dailyCost = 0;
+            latestThought = "Session started";
+            type = "system";
+            content = "Ghost Bridge: Session started";
+            break;
+
+        case "agent:response":
+        case "agent:message":
+            latestThought = data?.text?.slice(0, 200) || "Response generated";
+            type = "thought";
+            content = latestThought;
+            break;
+    }
+
+    // Initialize on first event
+    if (!initialized) {
+        await init(type, content, { event, ...data });
+    } else {
+        await send(type, content, { event, ...data });
+    }
+}

package/package.json

@@ -1,9 +1,13 @@
 {
     "name": "mortgram-hook",
-    "version": "1.0.0",
+    "version": "1.0.2",
     "description": "MORTGRAM Ghost Bridge — Invisible observability for OpenClaw agents",
-    "main": "index.mjs",
     "type": "module",
+    "openclaw": {
+        "hooks": [
+            "./mortgram-observer"
+        ]
+    },
     "keywords": [
         "openclaw",
         "mortgram",
@@ -11,6 +15,9 @@
         "agent",
         "hook"
     ],
+    "dependencies": {
+        "ably": "^1.2.49"
+    },
     "author": "MORTGRAM",
     "license": "MIT"
 }