@steadwing/openalerts 0.2.4 → 0.2.5

package/dist/index.js

@@ -1,15 +1,24 @@
-import { OpenAlertsEngine } from "./core/index.js";
+import { ALL_RULES, OpenAlertsEngine } from "./core/index.js";
 import { onDiagnosticEvent, registerLogTransport } from "openclaw/plugin-sdk";
 import { createLogBridge } from "./plugin/log-bridge.js";
+import { GatewayClient } from "./plugin/gateway-client.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
 import { OpenClawAlertChannel, createOpenClawEnricher, parseConfig, resolveAlertTarget, translateOpenClawEvent, translateToolCallHook, translateAgentStartHook, translateAgentEndHook, translateSessionStartHook, translateSessionEndHook, translateMessageSentHook, translateMessageReceivedHook, translateBeforeToolCallHook, translateBeforeCompactionHook, translateAfterCompactionHook, translateMessageSendingHook, translateToolResultPersistHook, translateGatewayStartHook, translateGatewayStopHook, } from "./plugin/adapter.js";
 import { bindEngine, createMonitorCommands } from "./plugin/commands.js";
-import { createDashboardHandler, closeDashboardConnections, } from "./plugin/dashboard-routes.js";
+import { createDashboardHandler, closeDashboardConnections, emitAgentMonitorEvent, recordGatewayEvent, } from "./plugin/dashboard-routes.js";
+import { CollectionManager, CollectionPersistence, parseGatewayEvent, diagnosticUsageToSessionUpdate, } from "./collections/index.js";
 const PLUGIN_ID = "openalerts";
 const LOG_PREFIX = "openalerts";
 let engine = null;
 let unsubDiagnostic = null;
 let unsubLogTransport = null;
 let logBridgeCleanup = null;
+let gatewayClient = null;
+let collections = null;
+let collectionsPersistence = null;
+let sessionSyncInterval = null;
 function createMonitorService(api) {
     return {
         id: PLUGIN_ID,
@@ -36,7 +45,7 @@ function createMonitorService(api) {
             engine.start();
             // Wire commands to engine
             bindEngine(engine, api);
-            // ── Bridge 1: Diagnostic events → engine ──────────────────────────────
+            // ── Bridge 1: Diagnostic events → engine + collections ───────────────────
             // Covers: webhook.*, message.*, session.stuck, session.state,
             //         model.usage, queue.lane.*, diagnostic.heartbeat, run.attempt
             unsubDiagnostic = onDiagnosticEvent((event) => {
@@ -44,6 +53,17 @@ function createMonitorService(api) {
                 if (translated) {
                     engine.ingest(translated);
                 }
+                // Feed model.usage to collections for cost tracking
+                if (event.type === "model.usage" && collections) {
+                    const parsed = diagnosticUsageToSessionUpdate(event);
+                    if (parsed.session) {
+                        collections.upsertSession(parsed.session);
+                    }
+                    if (parsed.action && collectionsPersistence) {
+                        collections.addAction(parsed.action);
+                        collectionsPersistence.queueAction(parsed.action);
+                    }
+                }
             });
             // ── Bridge 2: Log transport → engine (fills gaps from non-firing hooks) ─
             // Parses structured log records to synthesize tool.call, session.start/end,
@@ -51,6 +71,27 @@ function createMonitorService(api) {
             const logBridge = createLogBridge(engine);
             unsubLogTransport = registerLogTransport(logBridge.transport);
             logBridgeCleanup = logBridge.cleanup;
+            // Helper to track actions in collections (for sessions, tools, messages)
+            const trackAction = (type, eventType, data, context) => {
+                if (!collections || !collectionsPersistence)
+                    return;
+                const action = {
+                    id: `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+                    runId: data.runId || `run-${Date.now()}`,
+                    sessionKey: context.sessionKey ||
+                        context.sessionId ||
+                        "unknown",
+                    seq: Date.now() % 1000000,
+                    type,
+                    eventType,
+                    timestamp: Date.now(),
+                    content: typeof data.content === "string"
+                        ? data.content
+                        : JSON.stringify(data).slice(0, 500),
+                };
+                collections.addAction(action);
+                collectionsPersistence.queueAction(action);
+            };
             // ── Bridge 3: Plugin hooks → engine ───────────────────────────────────
             // Covers: tool calls, agent lifecycle, session lifecycle, gateway, messages
             // These events are NOT emitted as diagnostic events — they come through
@@ -61,38 +102,131 @@ function createMonitorService(api) {
                 apiOn("after_tool_call", (data, hookCtx) => {
                     if (!engine)
                         return;
-                    engine.ingest(translateToolCallHook(data, {
-                        sessionId: hookCtx.sessionId,
-                        agentId: hookCtx.agentId,
-                    }));
+                    const d = data;
+                    const ctx = hookCtx;
+                    const sessionId = ctx.sessionKey ||
+                        ctx.sessionId ||
+                        undefined;
+                    const agentId = ctx.agentId;
+                    const runId = ctx.runId;
+                    engine.ingest(translateToolCallHook(d, { sessionId, agentId }));
+                    const _toolKey = sessionId && isRealSessionKey(sessionId)
+                        ? sessionId
+                        : runSessionMap.get(runId || "");
+                    const _toolParamSummary = d.params
+                        ? JSON.stringify(d.params).slice(0, 200)
+                        : undefined;
+                    const _toolResultSummary = d.result
+                        ? JSON.stringify(d.result).slice(0, 300)
+                        : undefined;
+                    if (_toolKey)
+                        emitAgentMonitorEvent({
+                            type: "agent",
+                            data: {
+                                ts: Date.now(),
+                                type: "agent",
+                                sessionKey: _toolKey,
+                                runId: runId || `tool-${Date.now()}`,
+                                data: {
+                                    phase: "tool",
+                                    toolName: d.toolName,
+                                    durationMs: d.durationMs,
+                                    error: d.error,
+                                    params: _toolParamSummary,
+                                    result: _toolResultSummary,
+                                },
+                            },
+                        });
                 });
                 // Agent lifecycle
                 apiOn("before_agent_start", (data, hookCtx) => {
                     if (!engine)
                         return;
-                    engine.ingest(translateAgentStartHook(data, {
-                        sessionId: hookCtx.sessionId,
-                        agentId: hookCtx.agentId,
-                    }));
+                    const ctx = hookCtx;
+                    const sessionId = ctx.sessionKey ||
+                        ctx.sessionId ||
+                        undefined;
+                    const agentId = ctx.agentId;
+                    const runId = ctx.runId;
+                    engine.ingest(translateAgentStartHook(data, { sessionId, agentId }));
+                    const _startKey = sessionId && isRealSessionKey(sessionId)
+                        ? sessionId
+                        : runSessionMap.get(runId || "");
+                    const _msgs = data.messages;
+                    const _lastUMsg = Array.isArray(_msgs)
+                        ? _msgs
+                            .filter((m) => m.role === "user")
+                            .pop()
+                        : null;
+                    const _startCtx = _lastUMsg
+                        ? (typeof _lastUMsg.content === "string"
+                            ? _lastUMsg.content
+                            : JSON.stringify(_lastUMsg.content)).slice(0, 300)
+                        : undefined;
+                    if (_startKey) {
+                        runSessionMap.set(runId || "", _startKey);
+                        emitAgentMonitorEvent({
+                            type: "agent",
+                            data: {
+                                ts: Date.now(),
+                                type: "agent",
+                                sessionKey: _startKey,
+                                runId: runId || `run-${Date.now()}`,
+                                data: { phase: "start", agentId, content: _startCtx },
+                            },
+                        });
+                    }
                 });
                 apiOn("agent_end", (data, hookCtx) => {
                     if (!engine)
                         return;
-                    engine.ingest(translateAgentEndHook(data, {
-                        sessionId: hookCtx.sessionId,
-                        agentId: hookCtx.agentId,
-                    }));
+                    const d = data;
+                    const ctx = hookCtx;
+                    const sessionId = ctx.sessionKey ||
+                        ctx.sessionId ||
+                        undefined;
+                    const agentId = ctx.agentId;
+                    const runId = ctx.runId;
+                    engine.ingest(translateAgentEndHook(d, { sessionId, agentId }));
+                    const _endKey = sessionId && isRealSessionKey(sessionId)
+                        ? sessionId
+                        : runSessionMap.get(runId || "");
+                    if (_endKey)
+                        emitAgentMonitorEvent({
+                            type: "agent",
+                            data: {
+                                ts: Date.now(),
+                                type: "agent",
+                                sessionKey: _endKey,
+                                runId: runId || `run-${Date.now()}`,
+                                data: {
+                                    phase: "end",
+                                    durationMs: d.durationMs,
+                                    success: d.success,
+                                    error: d.error,
+                                },
+                            },
+                        });
                 });
                 // Session lifecycle
-                apiOn("session_start", (data) => {
+                apiOn("session_start", (data, hookCtx) => {
                     if (!engine)
                         return;
                     engine.ingest(translateSessionStartHook(data));
+                    // Track in collections
+                    const ctx = hookCtx;
+                    trackAction("start", "system", { sessionId: data.sessionId }, ctx);
                 });
-                apiOn("session_end", (data) => {
+                apiOn("session_end", (data, hookCtx) => {
                     if (!engine)
                         return;
                     engine.ingest(translateSessionEndHook(data));
+                    // Track in collections
+                    const ctx = hookCtx;
+                    trackAction("complete", "system", {
+                        sessionId: data.sessionId,
+                        messageCount: data.messageCount,
+                    }, ctx);
                 });
                 // Message delivery tracking (all messages — success and failure)
                 apiOn("message_sent", (data, hookCtx) => {
@@ -105,13 +239,36 @@ function createMonitorService(api) {
                     }));
                 });
                 // Inbound message tracking (fires reliably in all modes)
+                // Inbound message tracking (fires reliably in all modes)
                 apiOn("message_received", (data, hookCtx) => {
                     if (!engine)
                         return;
-                    engine.ingest(translateMessageReceivedHook(data, {
-                        channelId: hookCtx.channelId,
-                        accountId: hookCtx.accountId,
-                    }));
+                    const d = data;
+                    const ctx = hookCtx;
+                    const channelId = ctx.channelId;
+                    const accountId = ctx.accountId;
+                    engine.ingest(translateMessageReceivedHook(d, { channelId, accountId }));
+                    // Emit inbound message to agent monitor live view
+                    const _inboundKey = channelId || "unknown";
+                    // Register channelId as a known session so subsequent agent events can link to it
+                    if (_inboundKey !== "unknown" && isRealSessionKey(_inboundKey)) {
+                        // Will be linked by runId once agent starts
+                    }
+                    emitAgentMonitorEvent({
+                        type: "chat",
+                        data: {
+                            ts: d.timestamp || Date.now(),
+                            type: "chat",
+                            sessionKey: _inboundKey,
+                            runId: "inbound",
+                            data: {
+                                state: "inbound",
+                                content: d.content,
+                                from: d.from,
+                                isInbound: true,
+                            },
+                        },
+                    });
                 });
                 // Tool start tracking (fires reliably — complements log-bridge tool end)
                 apiOn("before_tool_call", (data, hookCtx) => {
@@ -153,6 +310,25 @@ function createMonitorService(api) {
                 apiOn("message_sending", (data, hookCtx) => {
                     if (!engine)
                         return;
+                    const _sendCtx = hookCtx;
+                    const _sendChannelId = _sendCtx.channelId;
+                    const _sendData = data;
+                    if (_sendChannelId) {
+                        emitAgentMonitorEvent({
+                            type: "chat",
+                            data: {
+                                ts: Date.now(),
+                                type: "chat",
+                                sessionKey: _sendChannelId,
+                                runId: "outbound",
+                                data: {
+                                    state: "outbound",
+                                    content: _sendData.content,
+                                    to: _sendData.to,
+                                },
+                            },
+                        });
+                    }
                     engine.ingest(translateMessageSendingHook(data, {
                         channelId: hookCtx.channelId,
                         accountId: hookCtx.accountId,
@@ -171,13 +347,224 @@ function createMonitorService(api) {
                 });
                 logger.info(`${LOG_PREFIX}: subscribed to 13 plugin hooks (100% coverage: tool, agent, session, gateway, message, compaction)`);
             }
+            // ── Collections: Session/Action/Exec tracking ───────────────────────────
+            // NOTE: Direct filesystem reading for sessions (no gateway pairing needed)
+            // Sessions are read from ~/.openclaw/agents/<agent>/sessions/sessions.json
+            collections = new CollectionManager();
+            collectionsPersistence = new CollectionPersistence(ctx.stateDir);
+            collectionsPersistence.start();
+            // Read sessions from filesystem
+            const agentsDir = path.join(process.env.OPENCLAW_HOME ?? path.join(os.homedir(), ".openclaw"), "agents");
+            const loadSessionsFromFilesystem = () => {
+                try {
+                    if (!fs.existsSync(agentsDir))
+                        return;
+                    const agentDirs = fs
+                        .readdirSync(agentsDir, { withFileTypes: true })
+                        .filter((d) => d.isDirectory());
+                    let loadedCount = 0;
+                    for (const agentDir of agentDirs) {
+                        const sessionsFile = path.join(agentsDir, agentDir.name, "sessions", "sessions.json");
+                        if (fs.existsSync(sessionsFile)) {
+                            const content = fs.readFileSync(sessionsFile, "utf-8");
+                            const sessionsObj = JSON.parse(content);
+                            // sessions.json is an object with keys like "agent:main:main"
+                            for (const [key, session] of Object.entries(sessionsObj)) {
+                                const s = session;
+                                if (s.sessionId) {
+                                    collections?.upsertSession({
+                                        key: key,
+                                        agentId: s.agentId || agentDir.name,
+                                        platform: s.platform || "unknown",
+                                        recipient: s.recipient || "",
+                                        isGroup: s.isGroup || false,
+                                        lastActivityAt: s.updatedAt || Date.now(),
+                                        status: "idle",
+                                        messageCount: s.messageCount,
+                                    });
+                                    loadedCount++;
+                                }
+                            }
+                        }
+                    }
+                    logger.info(`${LOG_PREFIX}: loaded ${loadedCount} sessions from filesystem`);
+                }
+                catch (err) {
+                    logger.warn(`${LOG_PREFIX}: failed to load sessions from filesystem: ${err}`);
+                }
+            };
+            loadSessionsFromFilesystem();
+            // Persist sessions immediately after loading
+            if (collections && collectionsPersistence) {
+                collectionsPersistence.saveSessions(collections.getSessions());
+            }
+            // Persist sessions periodically
+            sessionSyncInterval = setInterval(() => {
+                if (collections && collectionsPersistence) {
+                    collectionsPersistence.saveSessions(collections.getSessions());
+                }
+            }, 30000);
+            // Hydrate from persisted data
+            const hydrated = collectionsPersistence.hydrate();
+            if (hydrated.sessions.length > 0 || hydrated.actions.length > 0) {
+                collections.hydrate(hydrated.sessions, hydrated.actions, hydrated.execEvents);
+                logger.info(`${LOG_PREFIX}: hydrated ${hydrated.sessions.length} sessions, ${hydrated.actions.length} actions, ${hydrated.execEvents.length} exec events`);
+            }
+            // Wire collection changes to persistence
+            collections.setCallbacks({
+                onSessionChange: (session) => {
+                    if (collections && collectionsPersistence) {
+                        collectionsPersistence.saveSessions(collections.getSessions());
+                    }
+                },
+                onActionChange: (action) => {
+                    collectionsPersistence?.queueAction(action);
+                },
+                onExecChange: (exec) => {
+                    // Exec changes tracked via hooks
+                },
+            });
+            // ── runId → real session key map ─────────────────────────────────
+            // Chat events always carry the real sessionKey (agent:agentId:platform:recipient).
+            // Agent events often omit it, falling back to stream name ("assistant", "lifecycle").
+            // We build this map from chat events and use it to normalize agent events.
+            const runSessionMap = new Map();
+            const isRealSessionKey = (k) => k.split(":")[0] === "agent" && k.split(":").length >= 3;
+            // ── Bridge 4: Gateway WebSocket → engine + collections ─────────────────
+            // Connects to gateway WS for real-time session/action/exec tracking.
+            // Falls back gracefully if not paired (NOT_PAIRED error is handled).
+            // Use token from config or fall back to empty (will show pairing warning)
+            // Bug 4 fix: read token from config instead of hardcoding
+            const _gatewayCfg = api.config.gateway;
+            const _gatewayAuth = _gatewayCfg?.auth;
+            const gatewayToken = _gatewayAuth?.token || "";
+            if (gatewayToken) {
+                gatewayClient = new GatewayClient({
+                    token: gatewayToken,
+                });
+                gatewayClient.on("ready", () => {
+                    logger.info(`${LOG_PREFIX}: gateway client connected`);
+                });
+                gatewayClient.on("error", (err) => {
+                    // Ignore pairing errors - plugin works without full gateway client
+                    if (err.message.includes("NOT_PAIRED") ||
+                        err.message.includes("device identity")) {
+                        logger.warn(`${LOG_PREFIX}: gateway pairing not configured (optional)`);
+                    }
+                    else {
+                        logger.warn(`${LOG_PREFIX}: gateway client error: ${err.message}`);
+                    }
+                });
+                gatewayClient.on("disconnected", () => {
+                    logger.info(`${LOG_PREFIX}: gateway client disconnected`);
+                });
+                // Wire gateway events to collections
+                const gatewayEventNames = ["chat", "agent", "health", "tick"];
+                for (const eventName of gatewayEventNames) {
+                    gatewayClient.on(eventName, (payload) => {
+                        // Record for test endpoint
+                        recordGatewayEvent(eventName, payload);
+                        if (collections) {
+                            const parsed = parseGatewayEvent(eventName, payload);
+                            if (parsed) {
+                                if (parsed.session)
+                                    collections.upsertSession(parsed.session);
+                                if (parsed.action) {
+                                    // Register real keys in runSessionMap
+                                    if (parsed.action.sessionKey &&
+                                        !parsed.action.sessionKey.includes("lifecycle") &&
+                                        isRealSessionKey(parsed.action.sessionKey)) {
+                                        runSessionMap.set(parsed.action.runId, parsed.action.sessionKey);
+                                    }
+                                    // Route to real key via runId; fall back to original key — never filter (frontend handles grouping)
+                                    const realKey = isRealSessionKey(parsed.action.sessionKey)
+                                        ? parsed.action.sessionKey
+                                        : runSessionMap.get(parsed.action.runId) ||
+                                            parsed.action.sessionKey;
+                                    collections.addAction(parsed.action);
+                                    // Forward parsed WS actions to the live agent monitor SSE stream
+                                    const action = parsed.action;
+                                    const sseType = action.eventType === "chat" ? "chat" : "agent";
+                                    const sseData = {
+                                        ts: action.timestamp,
+                                        sessionKey: realKey,
+                                        runId: action.runId,
+                                    };
+                                    if (action.eventType === "chat") {
+                                        const state = action.type === "complete"
+                                            ? "final"
+                                            : action.type === "streaming"
+                                                ? "delta"
+                                                : action.type === "error"
+                                                    ? "error"
+                                                    : "final";
+                                        sseData.data = {
+                                            state,
+                                            content: action.content,
+                                            inputTokens: action.inputTokens,
+                                            outputTokens: action.outputTokens,
+                                            stopReason: action.stopReason,
+                                        };
+                                    }
+                                    else {
+                                        const phase = action.type === "start"
+                                            ? "start"
+                                            : action.type === "complete"
+                                                ? "end"
+                                                : action.type === "error"
+                                                    ? "error"
+                                                    : action.type === "tool_call"
+                                                        ? "tool"
+                                                        : action.type === "streaming"
+                                                            ? "streaming"
+                                                            : action.type;
+                                        sseData.data = {
+                                            phase,
+                                            content: action.content,
+                                            toolName: action.toolName,
+                                            toolArgs: action.toolArgs,
+                                            durationMs: action.endedAt && action.startedAt
+                                                ? action.endedAt - action.startedAt
+                                                : undefined,
+                                        };
+                                    }
+                                    emitAgentMonitorEvent({ type: sseType, data: sseData });
+                                }
+                                if (parsed.execEvent) {
+                                    collections.addExecEvent(parsed.execEvent);
+                                    collectionsPersistence?.queueExecEvent(parsed.execEvent);
+                                }
+                            }
+                        }
+                    });
+                }
+                gatewayClient.start();
+                // Bug 1 fix: cost sync via usage.cost RPC removed
+                // Gateway denies operator.read scope; cost flows via model.usage diagnostic events
+            }
             const targetDesc = target
                 ? `alerting to ${target.channel}:${target.to}`
                 : "log-only (no alert channel detected)";
-            logger.info(`${LOG_PREFIX}: started, ${targetDesc}, log-bridge active, 8 rules active`);
+            logger.info(`${LOG_PREFIX}: started, ${targetDesc}, log-bridge active, ${ALL_RULES.length} rules active`);
         },
         stop() {
             closeDashboardConnections();
+            if (sessionSyncInterval) {
+                clearInterval(sessionSyncInterval);
+                sessionSyncInterval = null;
+            }
+            if (gatewayClient) {
+                gatewayClient.stop();
+                gatewayClient = null;
+            }
+            if (collectionsPersistence) {
+                collectionsPersistence.stop();
+                collectionsPersistence = null;
+            }
+            if (collections) {
+                collections.clear();
+                collections = null;
+            }
             if (unsubLogTransport) {
                 unsubLogTransport();
                 unsubLogTransport = null;
@@ -207,7 +594,7 @@ const plugin = {
             api.registerCommand(cmd);
         }
         // Register dashboard HTTP routes under /openalerts*
-        api.registerHttpHandler(createDashboardHandler(() => engine));
+        api.registerHttpHandler(createDashboardHandler(() => engine, () => collections));
     },
 };
 export default plugin;

package/dist/plugin/dashboard-html.js

@@ -194,6 +194,28 @@ export function getDashboardHtml() {
   .log-detail .ld-grid .lk{color:#8b949e;text-align:right}
   .log-detail .ld-grid .lv{color:#c9d1d9;word-break:break-all}
   .log-detail .ld-file{color:#484f58;font-size:10px;margin-top:3px}
+
+  /* ── Graph View ──────────────────── */
+  .view-toggle{display:flex;gap:2px;background:#0d1117;border:1px solid #30363d;border-radius:4px;padding:2px;font-size:11px}
+  .view-toggle button{background:transparent;border:none;color:#8b949e;padding:3px 10px;border-radius:3px;cursor:pointer;font-family:inherit;font-size:11px}
+  .view-toggle button:hover{color:#c9d1d9;background:#21262d}
+  .view-toggle button.active{background:#21262d;color:#58a6ff}
+  #graphView{display:none;flex:1;overflow:auto;position:relative;background:#0d1117}
+  #graphView.active{display:block}
+  .graph-svg{position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none}
+  .graph-node{position:absolute;display:flex;flex-direction:column;align-items:center;justify-content:center;background:#161b22;border:2px solid #30363d;border-radius:8px;padding:8px 12px;min-width:60px;cursor:pointer;transition:all 0.15s}
+  .graph-node:hover{border-color:#58a6ff;background:#1c2129}
+  .graph-node.session{border-color:#58a6ff;background:#0d1a2d}
+  .graph-node.action{border-radius:6px;padding:6px 10px}
+  .graph-node.tool{border-color:#bc8cff;background:#1a0d2d;border-radius:4px;padding:4px 8px;font-size:11px}
+  .graph-node.exec{border-color:#d29922;background:#2d1a0d;border-radius:4px;padding:4px 8px;font-size:11px}
+  .node-icon{font-size:20px;margin-bottom:2px}
+  .node-label{font-size:11px;color:#c9d1d9;max-width:100px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;text-align:center}
+  .node-status{font-size:9px;color:#8b949e;margin-top:2px}
+  .node-status.running{color:#58a6ff}
+  .node-status.completed{color:#3fb950}
+  .node-status.error{color:#f85149}
+ 
 </style>
 </head>
 <body>
@@ -218,7 +240,10 @@ export function getDashboardHtml() {
     <div class="tab-content active" id="tab-activity">
       <div class="activity-panels">
         <div class="panel">
-          <div class="panel-header"><span>Live Timeline</span><span style="color:#484f58;font-weight:400" id="evCnt">0</span></div>
+          <div class="panel-header">
+            <span>Live Timeline</span>
+            <span style="color:#484f58;font-weight:400" id="evCnt">0</span>
+          </div>
           <div class="scroll" id="evList"><div class="empty-msg" id="emptyMsg">Waiting for events... send a message to your bot.</div></div>
         </div>
         <div class="panel">
@@ -626,8 +651,13 @@ export function getDashboardHtml() {
       evSrc.addEventListener('history',function(e){try{var evs=JSON.parse(e.data);for(var i=0;i<evs.length;i++)addEvent(evs[i])}catch(_){}});
       evSrc.addEventListener('oclog',function(e){try{addLogEntry(JSON.parse(e.data))}catch(_){}});
       evSrc.onopen=function(){$('sDot').className='dot live';$('sConn').textContent='live'};
-      evSrc.onerror=function(e){$('sDot').className='dot dead';$('sConn').textContent='err:'+evSrc.readyState};
-    }catch(e){$('sConn').textContent='SSE fail:'+e.message}
+      evSrc.onerror=function(e){
+        $('sDot').className='dot dead';
+        $('sConn').textContent='reconnecting...';
+        evSrc.close();
+        setTimeout(connectSSE,3000);
+      };
+    }catch(e){$('sConn').textContent='SSE fail:'+e.message;setTimeout(connectSSE,3000);}
   }
 
   // ─── State polling ──────────────────────

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

@@ -1,7 +1,12 @@
 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. */
+type AgentMonitorEvent = {
+    type: string;
+    data: unknown;
+};
+export declare function emitAgentMonitorEvent(event: AgentMonitorEvent): void;
+export declare function recordGatewayEvent(eventName: string, payload: unknown): void;
 export declare function closeDashboardConnections(): void;
-export declare function createDashboardHandler(getEngine: () => OpenAlertsEngine | null): HttpHandler;
+export declare function createDashboardHandler(getEngine: () => OpenAlertsEngine | null, getCollections: () => unknown): HttpHandler;
 export {};