@steadwing/openalerts 0.1.0

package/dist/src/dashboard-routes.d.ts

@@ -0,0 +1,7 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { OpenAlertsEngine } from "@steadwing/openalerts-core";
+type HttpHandler = (req: IncomingMessage, res: ServerResponse) => Promise<boolean> | boolean;
+/** Close all active SSE connections. Call on engine stop. */
+export declare function closeDashboardConnections(): void;
+export declare function createDashboardHandler(getEngine: () => OpenAlertsEngine | null): HttpHandler;
+export {};

package/dist/src/dashboard-routes.js

@@ -0,0 +1,298 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { getDashboardHtml } from "./dashboard-html.js";
+// ─── SSE connection tracking ─────────────────────────────────────────────────
+const sseConnections = new Set();
+/** Close all active SSE connections. Call on engine stop. */
+export function closeDashboardConnections() {
+    for (const conn of sseConnections) {
+        clearInterval(conn.heartbeat);
+        clearInterval(conn.logTailer);
+        conn.unsub();
+        try {
+            conn.res.end();
+        }
+        catch {
+            /* already closed */
+        }
+    }
+    sseConnections.clear();
+}
+// ─── Rule status helper ──────────────────────────────────────────────────────
+const RULE_IDS = [
+    "infra-errors",
+    "llm-errors",
+    "session-stuck",
+    "heartbeat-fail",
+    "queue-depth",
+    "high-error-rate",
+    "gateway-down",
+];
+function getRuleStatuses(engine) {
+    const state = engine.state;
+    const now = Date.now();
+    return RULE_IDS.map((id) => {
+        const cooldownTs = state.cooldowns.get(id);
+        const fired = cooldownTs != null && cooldownTs > now - 15 * 60 * 1000;
+        return { id, status: fired ? "fired" : "ok" };
+    });
+}
+// ─── OpenClaw log file ──────────────────────────────────────────────────────
+function getOpenClawLogDir() {
+    // Use platform-appropriate default: C:\tmp\openclaw on Windows, /tmp/openclaw elsewhere
+    if (process.platform === "win32") {
+        return join("C:", "tmp", "openclaw");
+    }
+    return join("/tmp", "openclaw");
+}
+function getOpenClawLogPath() {
+    const d = new Date();
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return join(getOpenClawLogDir(), `openclaw-${y}-${m}-${day}.log`);
+}
+/** Parse key=value pairs from a log message string. */
+function parseLogKVs(msg) {
+    const kvs = {};
+    // Match key=value or key="quoted value"
+    const re = /(\w+)=(?:"([^"]*)"|(\S+))/g;
+    let m;
+    while ((m = re.exec(msg)) !== null) {
+        kvs[m[1]] = m[2] ?? m[3];
+    }
+    return kvs;
+}
+function parseLogLine(line) {
+    try {
+        const obj = JSON.parse(line);
+        const ts = obj.time || obj._meta?.date || "";
+        const tsMs = ts ? new Date(ts).getTime() : 0;
+        let subsystem = "";
+        try {
+            const nameObj = JSON.parse(obj["0"] || "{}");
+            subsystem = nameObj.subsystem || "";
+        }
+        catch {
+            subsystem = obj["0"] || "";
+        }
+        const message = obj["1"] || "";
+        const extra = parseLogKVs(message);
+        return {
+            ts,
+            tsMs,
+            level: obj._meta?.logLevelName || "DEBUG",
+            subsystem,
+            message,
+            sessionId: extra.sessionId,
+            runId: extra.runId,
+            durationMs: extra.durationMs ? parseInt(extra.durationMs, 10) : undefined,
+            filePath: obj._meta?.path?.fileNameWithLine,
+            method: obj._meta?.path?.method,
+            hostname: obj._meta?.hostname,
+            extra,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readOpenClawLogs(maxEntries, afterTs) {
+    const logPath = getOpenClawLogPath();
+    if (!existsSync(logPath))
+        return { entries: [], truncated: false, subsystems: [] };
+    try {
+        const content = readFileSync(logPath, "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        const entries = [];
+        const subsystemSet = new Set();
+        for (const line of lines) {
+            const parsed = parseLogLine(line);
+            if (!parsed)
+                continue;
+            if (afterTs && parsed.ts <= afterTs)
+                continue;
+            entries.push(parsed);
+            subsystemSet.add(parsed.subsystem);
+        }
+        const truncated = entries.length > maxEntries;
+        const sliced = entries.slice(-maxEntries);
+        const subsystems = Array.from(subsystemSet).sort();
+        return { entries: sliced, truncated, subsystems };
+    }
+    catch {
+        return { entries: [], truncated: false, subsystems: [] };
+    }
+}
+/**
+ * Create a log tailer for an SSE connection.
+ * Polls the log file every 2 seconds, sends new lines as `event: oclog`.
+ */
+function createLogTailer(res) {
+    let lastLineCount = 0;
+    let lastPath = "";
+    // Initialize: count existing lines so we only send new ones
+    try {
+        const path = getOpenClawLogPath();
+        if (existsSync(path)) {
+            const content = readFileSync(path, "utf-8");
+            lastLineCount = content.trim().split("\n").length;
+            lastPath = path;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return setInterval(() => {
+        try {
+            const path = getOpenClawLogPath();
+            if (!existsSync(path))
+                return;
+            // If date changed (new log file), reset counter
+            if (path !== lastPath) {
+                lastLineCount = 0;
+                lastPath = path;
+            }
+            const content = readFileSync(path, "utf-8");
+            const lines = content.trim().split("\n");
+            if (lines.length <= lastLineCount)
+                return;
+            // Send only new lines
+            const newLines = lines.slice(lastLineCount);
+            lastLineCount = lines.length;
+            for (const line of newLines) {
+                const parsed = parseLogLine(line);
+                if (!parsed)
+                    continue;
+                res.write(`event: oclog\ndata: ${JSON.stringify(parsed)}\n\n`);
+            }
+        }
+        catch {
+            /* ignore read errors */
+        }
+    }, 2000);
+}
+// ─── HTTP Handler ────────────────────────────────────────────────────────────
+export function createDashboardHandler(getEngine) {
+    return async (req, res) => {
+        const url = req.url ?? "";
+        if (!url.startsWith("/openalerts"))
+            return false;
+        const engine = getEngine();
+        // ── GET /openalerts → Dashboard HTML ──────────────────────
+        if ((url === "/openalerts" || url === "/openalerts/") &&
+            req.method === "GET") {
+            if (!engine) {
+                res.writeHead(503, { "Content-Type": "text/plain" });
+                res.end("OpenAlerts engine not running.");
+                return true;
+            }
+            res.writeHead(200, {
+                "Content-Type": "text/html; charset=utf-8",
+                "Cache-Control": "no-cache",
+            });
+            res.end(getDashboardHtml());
+            return true;
+        }
+        // ── GET /openalerts/events → SSE stream (engine events + log tailing) ──
+        if (url === "/openalerts/events" && req.method === "GET") {
+            if (!engine) {
+                res.writeHead(503, { "Content-Type": "text/plain" });
+                res.end("Engine not running.");
+                return true;
+            }
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+                "Access-Control-Allow-Origin": "*",
+            });
+            res.flushHeaders();
+            // Subscribe to engine events
+            const unsub = engine.bus.on((event) => {
+                try {
+                    res.write(`event: openalerts\ndata: ${JSON.stringify(event)}\n\n`);
+                }
+                catch {
+                    /* closed */
+                }
+            });
+            // Start log file tailer — streams OpenClaw internal logs as `event: oclog`
+            const logTailer = createLogTailer(res);
+            // Heartbeat every 15s
+            const heartbeat = setInterval(() => {
+                try {
+                    res.write(":heartbeat\n\n");
+                }
+                catch {
+                    /* closed */
+                }
+            }, 15_000);
+            const conn = { res, unsub, heartbeat, logTailer };
+            sseConnections.add(conn);
+            req.on("close", () => {
+                clearInterval(heartbeat);
+                clearInterval(logTailer);
+                unsub();
+                sseConnections.delete(conn);
+            });
+            return true;
+        }
+        // ── GET /openalerts/state → JSON snapshot ─────────────────
+        if (url === "/openalerts/state" && req.method === "GET") {
+            if (!engine) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Engine not running" }));
+                return true;
+            }
+            const state = engine.state;
+            const recentAlerts = engine
+                .getRecentEvents(50)
+                .filter((e) => e.type === "alert");
+            const body = JSON.stringify({
+                uptimeMs: Date.now() - state.startedAt,
+                startedAt: state.startedAt,
+                lastHeartbeatTs: state.lastHeartbeatTs,
+                hourlyAlerts: state.hourlyAlerts,
+                stuckSessions: state.stats.stuckSessions,
+                lastResetTs: state.stats.lastResetTs,
+                stats: state.stats,
+                busListeners: engine.bus.size,
+                platformConnected: engine.platformConnected,
+                recentAlerts: recentAlerts.slice(0, 20),
+                rules: getRuleStatuses(engine),
+                cooldowns: Object.fromEntries(state.cooldowns),
+            });
+            res.writeHead(200, {
+                "Content-Type": "application/json",
+                "Cache-Control": "no-cache",
+                "Access-Control-Allow-Origin": "*",
+            });
+            res.end(body);
+            return true;
+        }
+        // ── GET /openalerts/logs → OpenClaw log entries (for Logs tab) ────
+        if (url.startsWith("/openalerts/logs") && req.method === "GET") {
+            const urlObj = new URL(url, "http://localhost");
+            const limit = Math.min(parseInt(urlObj.searchParams.get("limit") || "200", 10), 1000);
+            const afterTs = urlObj.searchParams.get("after") || undefined;
+            const result = readOpenClawLogs(limit, afterTs);
+            res.writeHead(200, {
+                "Content-Type": "application/json",
+                "Cache-Control": "no-cache",
+                "Access-Control-Allow-Origin": "*",
+            });
+            res.end(JSON.stringify({
+                entries: result.entries,
+                truncated: result.truncated,
+                subsystems: result.subsystems,
+                logFile: getOpenClawLogPath(),
+            }));
+            return true;
+        }
+        // Unknown /openalerts sub-route
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+        return true;
+    };
+}

package/dist/src/log-bridge.d.ts

@@ -0,0 +1,22 @@
+import type { OpenAlertsEngine } from "@steadwing/openalerts-core";
+import type { LogTransportRecord } from "openclaw/plugin-sdk";
+/**
+ * Create a log-transport bridge that parses structured log records and
+ * synthesizes OpenAlertsEvents to fill gaps left by non-firing plugin hooks.
+ *
+ * Covers:
+ * - Tool calls (tool start → tool end, with duration) — fills `after_tool_call` gap
+ * - Session lifecycle (idle ↔ processing transitions) — fills `session_start/end` gap
+ * - Run prompt duration — enriches session.end with durationMs
+ * - Agent run lifecycle — agent start/end at run level
+ * - Compaction events — detects costly context compaction
+ * - Message delivery — "Committed messaging text" fills `message_sent` gap
+ * - Exec commands — attaches elevated commands to tool events
+ *
+ * Returns the transport function to pass to registerLogTransport().
+ * Call the returned cleanup function to release internal state.
+ */
+export declare function createLogBridge(engine: OpenAlertsEngine): {
+    transport: (logObj: LogTransportRecord) => void;
+    cleanup: () => void;
+};

package/dist/src/log-bridge.js

@@ -0,0 +1,336 @@
+import { BoundedMap } from "@steadwing/openalerts-core";
+// ─── Parsing Helpers ─────────────────────────────────────────────────────────
+const KV_RE = /(\w+)=([\S]+)/g;
+/** Parse key=value pairs from a log message string. */
+function parseKvs(message) {
+    const result = {};
+    let m;
+    KV_RE.lastIndex = 0;
+    while ((m = KV_RE.exec(message)) !== null) {
+        result[m[1]] = m[2];
+    }
+    return result;
+}
+/** Extract subsystem string from field "0" which may be JSON or raw. */
+function extractSubsystem(field0) {
+    if (typeof field0 !== "string")
+        return "";
+    if (field0.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(field0);
+            return typeof parsed.subsystem === "string" ? parsed.subsystem : "";
+        }
+        catch {
+            return "";
+        }
+    }
+    return field0;
+}
+/** Extract timestamp from a log record. */
+function extractTimestamp(logObj) {
+    const meta = logObj._meta;
+    if (meta?.date && typeof meta.date === "string") {
+        const t = new Date(meta.date).getTime();
+        if (!isNaN(t))
+            return t;
+    }
+    if (typeof logObj.time === "string") {
+        const t = new Date(logObj.time).getTime();
+        if (!isNaN(t))
+            return t;
+    }
+    if (typeof logObj.time === "number") {
+        return logObj.time;
+    }
+    return Date.now();
+}
+/** Subsystems the bridge cares about. Everything else is fast-skipped. */
+const WATCHED_SUBSYSTEMS = new Set(["agent/embedded", "diagnostic", "exec"]);
+/**
+ * Parse a raw LogTransportRecord into a structured form.
+ * Returns null if the record can't be parsed or is from an irrelevant subsystem.
+ */
+function parseLogRecord(logObj) {
+    const subsystem = extractSubsystem(logObj["0"]);
+    if (!WATCHED_SUBSYSTEMS.has(subsystem))
+        return null;
+    const message = typeof logObj["1"] === "string" ? logObj["1"] : "";
+    if (!message)
+        return null;
+    return {
+        subsystem,
+        message,
+        ts: extractTimestamp(logObj),
+        kvs: parseKvs(message),
+    };
+}
+// ─── Dedup set with periodic pruning ─────────────────────────────────────────
+const DEDUP_MAX_SIZE = 2000;
+const DEDUP_PRUNE_TARGET = 500;
+/** Prune oldest entries from a dedup set when it grows too large. */
+function pruneDedupeSet(set) {
+    if (set.size <= DEDUP_MAX_SIZE)
+        return;
+    // Set iterates in insertion order; delete oldest entries
+    const toDelete = set.size - DEDUP_PRUNE_TARGET;
+    let deleted = 0;
+    for (const key of set) {
+        if (deleted >= toDelete)
+            break;
+        set.delete(key);
+        deleted++;
+    }
+}
+// ─── Bridge ──────────────────────────────────────────────────────────────────
+/**
+ * Create a log-transport bridge that parses structured log records and
+ * synthesizes OpenAlertsEvents to fill gaps left by non-firing plugin hooks.
+ *
+ * Covers:
+ * - Tool calls (tool start → tool end, with duration) — fills `after_tool_call` gap
+ * - Session lifecycle (idle ↔ processing transitions) — fills `session_start/end` gap
+ * - Run prompt duration — enriches session.end with durationMs
+ * - Agent run lifecycle — agent start/end at run level
+ * - Compaction events — detects costly context compaction
+ * - Message delivery — "Committed messaging text" fills `message_sent` gap
+ * - Exec commands — attaches elevated commands to tool events
+ *
+ * Returns the transport function to pass to registerLogTransport().
+ * Call the returned cleanup function to release internal state.
+ */
+export function createLogBridge(engine) {
+    // ── State ──────────────────────────────────────────────────────────────────
+    // Use bounded maps to prevent memory leaks (max 1000 entries each)
+    const toolFlights = new BoundedMap({ maxSize: 1000 });
+    const sessionStates = new BoundedMap({ maxSize: 500 });
+    const dedupeSet = new Set();
+    let pendingCommand = null;
+    let lastRunDurationMs = null;
+    let pruneCounter = 0;
+    function ingest(event) {
+        engine.ingest(event);
+    }
+    // ── Tool call handling (agent/embedded) ────────────────────────────────────
+    // Fills the `after_tool_call` hook gap (hook is declared but never fires)
+    function handleToolStart(rec) {
+        const { toolCallId, tool, runId } = rec.kvs;
+        if (!toolCallId || !tool)
+            return;
+        toolFlights.set(toolCallId, {
+            tool,
+            runId: runId ?? "",
+            startTs: rec.ts,
+        });
+    }
+    function handleToolEnd(rec) {
+        const { toolCallId, tool, runId } = rec.kvs;
+        if (!toolCallId)
+            return;
+        const dedupeKey = `tool:${toolCallId}`;
+        if (dedupeSet.has(dedupeKey))
+            return;
+        dedupeSet.add(dedupeKey);
+        const flight = toolFlights.get(toolCallId);
+        toolFlights.delete(toolCallId);
+        const durationMs = flight ? rec.ts - flight.startTs : undefined;
+        const toolName = flight?.tool ?? tool ?? "unknown";
+        const event = {
+            type: "tool.call",
+            ts: rec.ts,
+            durationMs,
+            outcome: "success",
+            meta: {
+                toolName,
+                toolCallId,
+                runId: flight?.runId ?? runId,
+                source: "log-bridge",
+            },
+        };
+        if (pendingCommand) {
+            event.meta.command = pendingCommand;
+            pendingCommand = null;
+        }
+        ingest(event);
+    }
+    // ── Session lifecycle handling (diagnostic) ────────────────────────────────
+    // Fills the `session_start/end` hook gap (hooks declared but never fire)
+    function handleSessionState(rec) {
+        const { sessionId, sessionKey, prev, new: newState, reason } = rec.kvs;
+        const sid = sessionId ?? sessionKey;
+        if (!sid || !newState)
+            return;
+        const prevState = prev ?? sessionStates.get(sid);
+        sessionStates.set(sid, newState);
+        // session.start: idle → processing
+        if (newState === "processing" && prevState === "idle") {
+            const startKey = `session:start:${sid}`;
+            if (!dedupeSet.has(startKey)) {
+                dedupeSet.add(startKey);
+                ingest({
+                    type: "session.start",
+                    ts: rec.ts,
+                    sessionKey: sid,
+                    outcome: "success",
+                    meta: { source: "log-bridge" },
+                });
+            }
+        }
+        // session.end: processing → idle with reason=run_completed
+        if (newState === "idle" &&
+            prevState === "processing" &&
+            reason === "run_completed") {
+            const endKey = `session:end:${sid}`;
+            if (!dedupeSet.has(endKey)) {
+                dedupeSet.add(endKey);
+                const event = {
+                    type: "session.end",
+                    ts: rec.ts,
+                    sessionKey: sid,
+                    outcome: "success",
+                    meta: { source: "log-bridge" },
+                };
+                if (lastRunDurationMs !== null) {
+                    event.durationMs = lastRunDurationMs;
+                    lastRunDurationMs = null;
+                }
+                ingest(event);
+            }
+        }
+    }
+    // ── Run prompt duration (agent/embedded) ──────────────────────────────────
+    function handleRunPromptEnd(rec) {
+        const { durationMs } = rec.kvs;
+        if (durationMs) {
+            lastRunDurationMs = parseInt(durationMs, 10) || null;
+        }
+    }
+    // ── Agent run lifecycle (agent/embedded) ──────────────────────────────────
+    // Complements before_agent_start / agent_end hooks with run-level tracking
+    function handleAgentRunStart(rec) {
+        const { runId } = rec.kvs;
+        ingest({
+            type: "custom",
+            ts: rec.ts,
+            outcome: "success",
+            meta: { runId, openclawLog: "agent_run_start", source: "log-bridge" },
+        });
+    }
+    function handleAgentRunEnd(rec) {
+        const { runId } = rec.kvs;
+        ingest({
+            type: "custom",
+            ts: rec.ts,
+            outcome: "success",
+            meta: { runId, openclawLog: "agent_run_end", source: "log-bridge" },
+        });
+    }
+    // ── Compaction (agent/embedded) ───────────────────────────────────────────
+    // OpenClaw compacts when context is full — costly, can lose context.
+    // No hook exists for this. Only available via logs.
+    function handleCompactionStart(rec) {
+        const { runId } = rec.kvs;
+        ingest({
+            type: "custom",
+            ts: rec.ts,
+            outcome: "success",
+            meta: {
+                runId,
+                compaction: true,
+                openclawLog: "compaction_start",
+                source: "log-bridge",
+            },
+        });
+    }
+    function handleCompactionRetry(rec) {
+        const { runId } = rec.kvs;
+        ingest({
+            type: "custom",
+            ts: rec.ts,
+            outcome: "success",
+            meta: {
+                runId,
+                compaction: true,
+                openclawLog: "compaction_retry",
+                source: "log-bridge",
+            },
+        });
+    }
+    // ── Message delivery (agent/embedded) ─────────────────────────────────────
+    // "Committed messaging text" fires when a messaging tool (Telegram, Discord,
+    // etc.) successfully delivers a message. Fills the `message_sent` hook gap.
+    function handleMessageCommitted(rec) {
+        const { tool, len } = rec.kvs;
+        ingest({
+            type: "custom",
+            ts: rec.ts,
+            outcome: "success",
+            meta: {
+                toolName: tool,
+                textLength: len ? parseInt(len, 10) : undefined,
+                openclawLog: "message_committed",
+                source: "log-bridge",
+            },
+        });
+    }
+    // ── Exec command (exec) ────────────────────────────────────────────────────
+    function handleExecCommand(rec) {
+        pendingCommand = rec.message;
+    }
+    // ── Main transport function ────────────────────────────────────────────────
+    function transport(logObj) {
+        const rec = parseLogRecord(logObj);
+        if (!rec)
+            return;
+        const msg = rec.message;
+        if (rec.subsystem === "agent/embedded") {
+            if (msg.startsWith("embedded run tool start:")) {
+                handleToolStart(rec);
+            }
+            else if (msg.startsWith("embedded run tool end:")) {
+                handleToolEnd(rec);
+            }
+            else if (msg.startsWith("embedded run prompt end:")) {
+                handleRunPromptEnd(rec);
+            }
+            else if (msg.startsWith("embedded run agent start:")) {
+                handleAgentRunStart(rec);
+            }
+            else if (msg.startsWith("embedded run agent end:")) {
+                handleAgentRunEnd(rec);
+            }
+            else if (msg.startsWith("embedded run compaction start:")) {
+                handleCompactionStart(rec);
+            }
+            else if (msg.startsWith("embedded run compaction retry:")) {
+                handleCompactionRetry(rec);
+            }
+            else if (msg.startsWith("Committed messaging text:")) {
+                handleMessageCommitted(rec);
+            }
+        }
+        else if (rec.subsystem === "diagnostic") {
+            if (msg.startsWith("session state:")) {
+                handleSessionState(rec);
+            }
+        }
+        else if (rec.subsystem === "exec") {
+            if (msg.startsWith("elevated command")) {
+                handleExecCommand(rec);
+            }
+        }
+        // Periodic dedup set pruning (check every 100 log records)
+        if (++pruneCounter >= 100) {
+            pruneCounter = 0;
+            pruneDedupeSet(dedupeSet);
+        }
+    }
+    function cleanup() {
+        toolFlights.clear();
+        sessionStates.clear();
+        dedupeSet.clear();
+        pendingCommand = null;
+        lastRunDurationMs = null;
+        pruneCounter = 0;
+    }
+    return { transport, cleanup };
+}