@steadwing/openalerts 0.2.4 → 0.2.6

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

@@ -1,7 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { OpenAlertsEngine } from "../core/index.js";
-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/plugin/dashboard-routes.js

@@ -1,336 +0,0 @@
-import { readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { DEFAULTS } from "../core/index.js";
-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",
-    "tool-errors",
-    "gateway-down",
-];
-function getRuleStatuses(engine) {
-    const state = engine.state;
-    const now = Date.now();
-    const cooldownWindow = 15 * 60 * 1000;
-    return RULE_IDS.map((id) => {
-        // For gateway-down, reflect current condition: if heartbeats have resumed,
-        // show OK even if the rule fired recently.
-        if (id === "gateway-down") {
-            const silenceMs = state.lastHeartbeatTs > 0
-                ? now - state.lastHeartbeatTs
-                : 0;
-            const isCurrentlyDown = state.lastHeartbeatTs > 0 &&
-                silenceMs >= DEFAULTS.gatewayDownThresholdMs;
-            return { id, status: isCurrentlyDown ? "fired" : "ok" };
-        }
-        // Cooldown keys are fingerprints like "llm-errors:unknown", not bare rule IDs.
-        // Check if ANY cooldown key starting with this rule ID has fired recently.
-        let fired = false;
-        for (const [key, ts] of state.cooldowns) {
-            if (key === id || key.startsWith(id + ":")) {
-                if (ts > now - cooldownWindow) {
-                    fired = true;
-                    break;
-                }
-            }
-        }
-        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 = maxEntries > 0 && entries.length > maxEntries;
-        const sliced = maxEntries > 0 ? entries.slice(-maxEntries) : entries;
-        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();
-            // Send initial connection event so the browser knows the stream is live
-            res.write(`:ok\n\n`);
-            // Send current state snapshot as initial event
-            const state = engine.state;
-            res.write(`event: state\ndata: ${JSON.stringify({
-                uptimeMs: Date.now() - state.startedAt,
-                stats: state.stats,
-                rules: getRuleStatuses(engine),
-            })}\n\n`);
-            // Send event history so dashboard survives refreshes
-            const history = engine.getRecentLiveEvents(200);
-            if (history.length > 0) {
-                res.write(`event: history\ndata: ${JSON.stringify(history)}\n\n`);
-            }
-            // 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 rawLimit = urlObj.searchParams.get("limit") || "200";
-            // limit=0 means "no limit" — return all log entries
-            const limit = rawLimit === "0" ? 0 : Math.min(parseInt(rawLimit, 10), 50000);
-            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/plugin/gateway-client.d.ts

@@ -1,39 +0,0 @@
-import EventEmitter from "eventemitter3";
-interface GatewayClientConfig {
-    url: string;
-    token: string;
-    reconnectInterval: number;
-    maxRetries: number;
-}
-/**
- * WebSocket client for OpenClaw Gateway
- * - Connects to ws://127.0.0.1:18789
- * - Handles JSON-RPC requests/responses
- * - Emits events: agent, health, cron, chat
- * - Auto-reconnects on disconnect
- */
-export declare class GatewayClient extends EventEmitter {
-    private ws;
-    private config;
-    private pending;
-    private backoffMs;
-    private closed;
-    private connectTimer;
-    private ready;
-    constructor(config?: Partial<GatewayClientConfig>);
-    start(): void;
-    stop(): void;
-    isReady(): boolean;
-    private doConnect;
-    private sendConnectHandshake;
-    private handleMessage;
-    /**
-     * Send RPC request to gateway
-     * @example
-     * const cost = await client.request("usage.cost", { period: "day" });
-     * const sessions = await client.request("sessions.list");
-     */
-    request<T = unknown>(method: string, params?: unknown): Promise<T>;
-    private scheduleReconnect;
-}
-export {};

package/dist/plugin/gateway-client.js

@@ -1,193 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { WebSocket } from "ws";
-import EventEmitter from "eventemitter3";
-/**
- * WebSocket client for OpenClaw Gateway
- * - Connects to ws://127.0.0.1:18789
- * - Handles JSON-RPC requests/responses
- * - Emits events: agent, health, cron, chat
- * - Auto-reconnects on disconnect
- */
-export class GatewayClient extends EventEmitter {
-    ws = null;
-    config;
-    pending = new Map();
-    backoffMs = 1000;
-    closed = false;
-    connectTimer = null;
-    ready = false;
-    constructor(config) {
-        super();
-        this.config = {
-            url: config?.url ?? "ws://127.0.0.1:18789",
-            token: config?.token ?? "",
-            reconnectInterval: config?.reconnectInterval ?? 1000,
-            maxRetries: config?.maxRetries ?? 60,
-        };
-    }
-    start() {
-        if (this.closed) {
-            return;
-        }
-        this.doConnect();
-    }
-    stop() {
-        this.closed = true;
-        if (this.connectTimer) {
-            clearTimeout(this.connectTimer);
-            this.connectTimer = null;
-        }
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
-        }
-    }
-    isReady() {
-        return this.ready;
-    }
-    doConnect() {
-        if (this.closed || this.ws) {
-            return;
-        }
-        this.ws = new WebSocket(this.config.url, {
-            maxPayload: 25 * 1024 * 1024,
-        });
-        this.ws.on("open", () => {
-            this.backoffMs = 1000;
-            // Delay connect handshake slightly to allow gateway to send challenge
-            setTimeout(() => this.sendConnectHandshake(), 800);
-        });
-        this.ws.on("message", (data) => {
-            this.handleMessage(data.toString());
-        });
-        this.ws.on("error", (err) => {
-            this.emit("error", err);
-        });
-        this.ws.on("close", () => {
-            this.ws = null;
-            this.ready = false;
-            this.emit("disconnected");
-            if (!this.closed) {
-                this.scheduleReconnect();
-            }
-        });
-    }
-    sendConnectHandshake() {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            return;
-        }
-        const id = randomUUID();
-        const frame = {
-            type: "req",
-            id,
-            method: "connect",
-            params: {
-                minProtocol: 3,
-                maxProtocol: 3,
-                client: {
-                    id: "gateway-client",
-                    displayName: "OpenAlerts Monitor",
-                    version: "0.1.0",
-                    platform: process.platform,
-                    mode: "backend",
-                },
-                role: "operator",
-                scopes: ["operator.admin"],
-                auth: {
-                    token: this.config.token,
-                },
-            },
-        };
-        this.pending.set(id, {
-            resolve: (result) => {
-                this.ready = true;
-                this.emit("ready", result);
-            },
-            reject: (err) => {
-                this.emit("error", new Error(`Connect handshake failed: ${err.message}`));
-            },
-        });
-        this.ws.send(JSON.stringify(frame));
-    }
-    handleMessage(raw) {
-        try {
-            const frame = JSON.parse(raw);
-            if (frame.type === "res") {
-                const pending = this.pending.get(frame.id);
-                if (pending) {
-                    if (frame.error || frame.ok === false) {
-                        const errMsg = typeof frame.error === "string"
-                            ? frame.error
-                            : typeof frame.payload === "object" &&
-                                frame.payload &&
-                                "message" in frame.payload
-                                ? String(frame.payload.message)
-                                : JSON.stringify(frame.error ?? frame.payload);
-                        pending.reject(new Error(errMsg));
-                    }
-                    else {
-                        pending.resolve(frame.payload ?? frame.result);
-                    }
-                    this.pending.delete(frame.id);
-                }
-            }
-            else if (frame.type === "event") {
-                // Emit the event for subscribers: agent, health, cron, chat
-                this.emit(frame.event, frame.payload);
-            }
-        }
-        catch (err) {
-            this.emit("error", new Error(`Failed to parse frame: ${err}`));
-        }
-    }
-    /**
-     * Send RPC request to gateway
-     * @example
-     * const cost = await client.request("usage.cost", { period: "day" });
-     * const sessions = await client.request("sessions.list");
-     */
-    request(method, params) {
-        if (!this.ready || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            return Promise.reject(new Error("Gateway not ready"));
-        }
-        const id = randomUUID();
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`Request timeout: ${method}`));
-            }, 10000);
-            this.pending.set(id, {
-                resolve: (value) => {
-                    clearTimeout(timeout);
-                    resolve(value);
-                },
-                reject: (err) => {
-                    clearTimeout(timeout);
-                    reject(err);
-                },
-            });
-            const frame = {
-                type: "req",
-                id,
-                method,
-                params,
-            };
-            if (!this.ws) {
-                this.pending.delete(id);
-                clearTimeout(timeout);
-                reject(new Error("WebSocket not connected"));
-                return;
-            }
-            this.ws.send(JSON.stringify(frame));
-        });
-    }
-    scheduleReconnect() {
-        if (this.connectTimer) {
-            clearTimeout(this.connectTimer);
-        }
-        this.connectTimer = setTimeout(() => {
-            this.backoffMs = Math.min(this.backoffMs * 2, 60000);
-            this.doConnect();
-        }, this.backoffMs);
-    }
-}

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

@@ -1,22 +0,0 @@
-import type { OpenAlertsEngine } from "../core/index.js";
-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;
-};