@steadwing/openalerts 0.1.0 → 0.2.0

package/dist/core/rules.js

@@ -0,0 +1,274 @@
+import { DEFAULTS, } from "./types.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function makeAlertId(ruleId, fingerprint, ts) {
+    return `${ruleId}:${fingerprint}:${ts}`;
+}
+function pushWindow(ctx, name, entry) {
+    let window = ctx.state.windows.get(name);
+    if (!window) {
+        window = [];
+        ctx.state.windows.set(name, window);
+    }
+    window.push(entry);
+    // Evict old entries beyond max
+    if (window.length > DEFAULTS.maxWindowEntries) {
+        window.splice(0, window.length - DEFAULTS.maxWindowEntries);
+    }
+}
+function countInWindow(ctx, name, windowMs) {
+    const window = ctx.state.windows.get(name);
+    if (!window)
+        return 0;
+    const cutoff = ctx.now - windowMs;
+    return window.filter((e) => e.ts >= cutoff).length;
+}
+function getRuleThreshold(ctx, ruleId, defaultVal) {
+    return ctx.config.rules?.[ruleId]?.threshold ?? defaultVal;
+}
+function isRuleEnabled(ctx, ruleId) {
+    return ctx.config.rules?.[ruleId]?.enabled !== false;
+}
+// ─── Rule: infra-errors (was: webhook-errors) ───────────────────────────────
+const infraErrors = {
+    id: "infra-errors",
+    defaultCooldownMs: 15 * 60 * 1000,
+    defaultThreshold: 3,
+    evaluate(event, ctx) {
+        if (event.type !== "infra.error")
+            return null;
+        if (!isRuleEnabled(ctx, "infra-errors"))
+            return null;
+        const channel = event.channel ?? "unknown";
+        pushWindow(ctx, "infra-errors", { ts: ctx.now });
+        const threshold = getRuleThreshold(ctx, "infra-errors", 3);
+        const windowMs = 5 * 60 * 1000; // 5 minutes
+        const count = countInWindow(ctx, "infra-errors", windowMs);
+        if (count < threshold)
+            return null;
+        const fingerprint = `infra-errors:${channel}`;
+        return {
+            type: "alert",
+            id: makeAlertId("infra-errors", fingerprint, ctx.now),
+            ruleId: "infra-errors",
+            severity: "error",
+            title: "Infrastructure errors spike",
+            detail: `${count} infra errors on ${channel} in the last 5 minutes.`,
+            ts: ctx.now,
+            fingerprint,
+        };
+    },
+};
+// ─── Rule: llm-errors (was: message-errors) ─────────────────────────────────
+const llmErrors = {
+    id: "llm-errors",
+    defaultCooldownMs: 15 * 60 * 1000,
+    defaultThreshold: 3,
+    evaluate(event, ctx) {
+        if (event.type !== "llm.call")
+            return null;
+        if (!isRuleEnabled(ctx, "llm-errors"))
+            return null;
+        // Track all LLM calls for stats
+        ctx.state.stats.messagesProcessed++;
+        if (event.outcome !== "error")
+            return null;
+        ctx.state.stats.messageErrors++;
+        const channel = event.channel ?? "unknown";
+        pushWindow(ctx, "llm-errors", { ts: ctx.now });
+        const threshold = getRuleThreshold(ctx, "llm-errors", 3);
+        const windowMs = 5 * 60 * 1000;
+        const count = countInWindow(ctx, "llm-errors", windowMs);
+        if (count < threshold)
+            return null;
+        const fingerprint = `llm-errors:${channel}`;
+        return {
+            type: "alert",
+            id: makeAlertId("llm-errors", fingerprint, ctx.now),
+            ruleId: "llm-errors",
+            severity: "error",
+            title: "LLM call errors",
+            detail: `${count} LLM errors on ${channel} in the last 5 minutes.`,
+            ts: ctx.now,
+            fingerprint,
+        };
+    },
+};
+// ─── Rule: session-stuck ─────────────────────────────────────────────────────
+const sessionStuck = {
+    id: "session-stuck",
+    defaultCooldownMs: 30 * 60 * 1000,
+    defaultThreshold: 120_000, // 120 seconds
+    evaluate(event, ctx) {
+        if (event.type !== "session.stuck")
+            return null;
+        if (!isRuleEnabled(ctx, "session-stuck"))
+            return null;
+        ctx.state.stats.stuckSessions++;
+        const ageMs = event.ageMs ?? 0;
+        const threshold = getRuleThreshold(ctx, "session-stuck", 120_000);
+        if (ageMs < threshold)
+            return null;
+        const sessionKey = event.sessionKey ?? "unknown";
+        const fingerprint = `session-stuck:${sessionKey}`;
+        const ageSec = Math.round(ageMs / 1000);
+        return {
+            type: "alert",
+            id: makeAlertId("session-stuck", fingerprint, ctx.now),
+            ruleId: "session-stuck",
+            severity: "warn",
+            title: "Session stuck",
+            detail: `Session ${sessionKey} stuck in processing for ${ageSec}s.`,
+            ts: ctx.now,
+            fingerprint,
+        };
+    },
+};
+// ─── Rule: heartbeat-fail ────────────────────────────────────────────────────
+const heartbeatFail = {
+    id: "heartbeat-fail",
+    defaultCooldownMs: 30 * 60 * 1000,
+    defaultThreshold: 3, // consecutive failures
+    evaluate(event, ctx) {
+        if (event.type !== "infra.heartbeat")
+            return null;
+        if (!isRuleEnabled(ctx, "heartbeat-fail"))
+            return null;
+        const counterKey = "heartbeat-consecutive-fail";
+        if (event.outcome === "error") {
+            const count = (ctx.state.consecutives.get(counterKey) ?? 0) + 1;
+            ctx.state.consecutives.set(counterKey, count);
+            const threshold = getRuleThreshold(ctx, "heartbeat-fail", 3);
+            if (count < threshold)
+                return null;
+            const channel = event.channel ?? "";
+            const fingerprint = `heartbeat-fail:${channel}`;
+            return {
+                type: "alert",
+                id: makeAlertId("heartbeat-fail", fingerprint, ctx.now),
+                ruleId: "heartbeat-fail",
+                severity: "error",
+                title: "Heartbeat delivery failing",
+                detail: `${count} consecutive heartbeat failures.${channel ? ` Channel: ${channel}.` : ""}`,
+                ts: ctx.now,
+                fingerprint,
+            };
+        }
+        // Reset on success
+        if (event.outcome === "success") {
+            ctx.state.consecutives.set(counterKey, 0);
+        }
+        return null;
+    },
+};
+// ─── Rule: queue-depth ───────────────────────────────────────────────────────
+const queueDepth = {
+    id: "queue-depth",
+    defaultCooldownMs: 15 * 60 * 1000,
+    defaultThreshold: 10,
+    evaluate(event, ctx) {
+        // Fire on heartbeat (which carries queue depth) and dedicated queue_depth events
+        if (event.type !== "infra.heartbeat" && event.type !== "infra.queue_depth")
+            return null;
+        if (!isRuleEnabled(ctx, "queue-depth"))
+            return null;
+        // Update last heartbeat timestamp (used by gateway-down rule)
+        if (event.type === "infra.heartbeat") {
+            ctx.state.lastHeartbeatTs = ctx.now;
+        }
+        const queued = event.queueDepth ?? 0;
+        const threshold = getRuleThreshold(ctx, "queue-depth", 10);
+        if (queued < threshold)
+            return null;
+        const fingerprint = "queue-depth";
+        return {
+            type: "alert",
+            id: makeAlertId("queue-depth", fingerprint, ctx.now),
+            ruleId: "queue-depth",
+            severity: "warn",
+            title: "Queue depth high",
+            detail: `${queued} items queued for processing.`,
+            ts: ctx.now,
+            fingerprint,
+        };
+    },
+};
+// ─── Rule: high-error-rate ───────────────────────────────────────────────────
+const highErrorRate = {
+    id: "high-error-rate",
+    defaultCooldownMs: 30 * 60 * 1000,
+    defaultThreshold: 50, // percent
+    evaluate(event, ctx) {
+        if (event.type !== "llm.call")
+            return null;
+        if (!isRuleEnabled(ctx, "high-error-rate"))
+            return null;
+        const isError = event.outcome === "error";
+        pushWindow(ctx, "msg-outcomes", { ts: ctx.now, value: isError ? 1 : 0 });
+        const window = ctx.state.windows.get("msg-outcomes");
+        if (!window || window.length < 20)
+            return null; // Need 20 messages minimum
+        // Check last 20 messages
+        const recent = window.slice(-20);
+        const errors = recent.filter((e) => e.value === 1).length;
+        const rate = (errors / recent.length) * 100;
+        const threshold = getRuleThreshold(ctx, "high-error-rate", 50);
+        if (rate < threshold)
+            return null;
+        const fingerprint = "high-error-rate";
+        return {
+            type: "alert",
+            id: makeAlertId("high-error-rate", fingerprint, ctx.now),
+            ruleId: "high-error-rate",
+            severity: "error",
+            title: "High error rate",
+            detail: `${Math.round(rate)}% of the last ${recent.length} messages failed.`,
+            ts: ctx.now,
+            fingerprint,
+        };
+    },
+};
+// ─── Rule: gateway-down ──────────────────────────────────────────────────────
+const gatewayDown = {
+    id: "gateway-down",
+    defaultCooldownMs: 60 * 60 * 1000,
+    defaultThreshold: 90_000, // 90 seconds
+    evaluate(event, ctx) {
+        // This rule is called by the watchdog timer, not by events directly.
+        if (event.type !== "watchdog.tick")
+            return null;
+        if (!isRuleEnabled(ctx, "gateway-down"))
+            return null;
+        if (ctx.state.lastHeartbeatTs === 0)
+            return null; // No heartbeat received yet
+        const silenceMs = ctx.now - ctx.state.lastHeartbeatTs;
+        const threshold = getRuleThreshold(ctx, "gateway-down", DEFAULTS.gatewayDownThresholdMs);
+        if (silenceMs < threshold)
+            return null;
+        const fingerprint = "gateway-down";
+        const silenceSec = Math.round(silenceMs / 1000);
+        const lastTime = new Date(ctx.state.lastHeartbeatTs).toLocaleTimeString([], {
+            hour: "2-digit",
+            minute: "2-digit",
+        });
+        return {
+            type: "alert",
+            id: makeAlertId("gateway-down", fingerprint, ctx.now),
+            ruleId: "gateway-down",
+            severity: "critical",
+            title: "Gateway unresponsive",
+            detail: `No heartbeat received for ${silenceSec}s. Last successful: ${lastTime}.`,
+            ts: ctx.now,
+            fingerprint,
+        };
+    },
+};
+// ─── Export all rules ────────────────────────────────────────────────────────
+export const ALL_RULES = [
+    infraErrors,
+    llmErrors,
+    sessionStuck,
+    heartbeatFail,
+    queueDepth,
+    highErrorRate,
+    gatewayDown,
+];

package/dist/core/store.d.ts

@@ -0,0 +1,12 @@
+import { type StoredEvent } from "./types.js";
+/** Append a single event to the JSONL log. */
+export declare function appendEvent(stateDir: string, event: StoredEvent): void;
+/** Read the most recent N events from the log. Skips malformed lines. */
+export declare function readRecentEvents(stateDir: string, limit: number): StoredEvent[];
+/** Read all events (for warm-start). Caps at 1000 most recent. */
+export declare function readAllEvents(stateDir: string): StoredEvent[];
+/** Prune the log by age and size. Atomic rewrite via .tmp + rename. */
+export declare function pruneLog(stateDir: string, opts?: {
+    maxAgeMs?: number;
+    maxSizeKb?: number;
+}): void;

package/dist/core/store.js

@@ -0,0 +1,125 @@
+import fs from "node:fs";
+import path from "node:path";
+import { DEFAULTS, LOG_FILENAME, STORE_DIR_NAME } from "./types.js";
+function resolveDir(stateDir) {
+    return path.join(stateDir, STORE_DIR_NAME);
+}
+function resolveLogPath(stateDir) {
+    return path.join(resolveDir(stateDir), LOG_FILENAME);
+}
+function ensureDir(stateDir) {
+    const dir = resolveDir(stateDir);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+/** Append a single event to the JSONL log. */
+export function appendEvent(stateDir, event) {
+    ensureDir(stateDir);
+    const line = JSON.stringify(event) + "\n";
+    fs.appendFileSync(resolveLogPath(stateDir), line, "utf-8");
+}
+/** Read the most recent N events from the log. Skips malformed lines. */
+export function readRecentEvents(stateDir, limit) {
+    const logPath = resolveLogPath(stateDir);
+    if (!fs.existsSync(logPath))
+        return [];
+    let content;
+    try {
+        content = fs.readFileSync(logPath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const lines = content.trim().split("\n").filter(Boolean);
+    const recent = lines.slice(-limit);
+    const events = [];
+    for (const line of recent) {
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed && typeof parsed.type === "string" && typeof parsed.ts === "number") {
+                events.push(parsed);
+            }
+        }
+        catch {
+            // Skip malformed lines silently
+        }
+    }
+    return events;
+}
+/** Read all events (for warm-start). Caps at 1000 most recent. */
+export function readAllEvents(stateDir) {
+    return readRecentEvents(stateDir, 1000);
+}
+/** Prune the log by age and size. Atomic rewrite via .tmp + rename. */
+export function pruneLog(stateDir, opts) {
+    const logPath = resolveLogPath(stateDir);
+    if (!fs.existsSync(logPath))
+        return;
+    const maxAgeMs = opts?.maxAgeMs ?? DEFAULTS.maxLogAgeDays * 24 * 60 * 60 * 1000;
+    const maxSizeBytes = (opts?.maxSizeKb ?? DEFAULTS.maxLogSizeKb) * 1024;
+    let content;
+    try {
+        content = fs.readFileSync(logPath, "utf-8");
+    }
+    catch {
+        return;
+    }
+    // Check size first — skip if well within limits
+    if (Buffer.byteLength(content, "utf-8") < maxSizeBytes * 0.8) {
+        // Only prune by age if size is okay
+        const cutoff = Date.now() - maxAgeMs;
+        const lines = content.trim().split("\n").filter(Boolean);
+        const filtered = lines.filter((line) => {
+            try {
+                const parsed = JSON.parse(line);
+                return typeof parsed.ts === "number" && parsed.ts >= cutoff;
+            }
+            catch {
+                return false; // Drop malformed lines during prune
+            }
+        });
+        if (filtered.length < lines.length) {
+            writeAtomic(logPath, filtered.join("\n") + "\n");
+        }
+        return;
+    }
+    // Over size limit — filter by age first, then trim oldest if still too large
+    const cutoff = Date.now() - maxAgeMs;
+    let lines = content.trim().split("\n").filter(Boolean);
+    // Remove expired
+    lines = lines.filter((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            return typeof parsed.ts === "number" && parsed.ts >= cutoff;
+        }
+        catch {
+            return false;
+        }
+    });
+    // Still too large? Keep only the newest lines that fit
+    let result = lines.join("\n") + "\n";
+    while (Buffer.byteLength(result, "utf-8") > maxSizeBytes && lines.length > 10) {
+        lines = lines.slice(Math.floor(lines.length * 0.25)); // Drop oldest quarter
+        result = lines.join("\n") + "\n";
+    }
+    writeAtomic(logPath, result);
+}
+/** Atomic write: write to .tmp, then rename. Falls back to direct write on Windows. */
+function writeAtomic(filePath, content) {
+    const tmpPath = filePath + ".tmp";
+    try {
+        fs.writeFileSync(tmpPath, content, "utf-8");
+        fs.renameSync(tmpPath, filePath);
+    }
+    catch {
+        // Windows fallback: direct write (rename can be flaky)
+        fs.writeFileSync(filePath, content, "utf-8");
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch {
+            // Ignore cleanup failure
+        }
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,152 @@
+export type AlertSeverity = "info" | "warn" | "error" | "critical";
+export type OpenAlertsEventType = "llm.call" | "llm.error" | "llm.token_usage" | "tool.call" | "tool.error" | "agent.start" | "agent.end" | "agent.error" | "agent.stuck" | "session.start" | "session.end" | "session.stuck" | "infra.error" | "infra.heartbeat" | "infra.queue_depth" | "custom" | "watchdog.tick";
+export type OpenAlertsEvent = {
+    type: OpenAlertsEventType;
+    ts: number;
+    severity?: AlertSeverity;
+    channel?: string;
+    sessionKey?: string;
+    agentId?: string;
+    durationMs?: number;
+    tokenCount?: number;
+    queueDepth?: number;
+    ageMs?: number;
+    costUsd?: number;
+    outcome?: "success" | "error" | "skipped" | "timeout";
+    error?: string;
+    meta?: Record<string, unknown>;
+};
+export interface AlertChannel {
+    readonly name: string;
+    send(alert: AlertEvent, formatted: string): Promise<void> | void;
+}
+export type AlertEvent = {
+    type: "alert";
+    id: string;
+    ruleId: string;
+    severity: AlertSeverity;
+    title: string;
+    detail: string;
+    ts: number;
+    fingerprint: string;
+};
+export type DiagnosticSnapshot = {
+    type: "diagnostic";
+    eventType: string;
+    ts: number;
+    summary: string;
+    channel?: string;
+    sessionKey?: string;
+};
+export type HeartbeatSnapshot = {
+    type: "heartbeat";
+    status: string;
+    ts: number;
+    reason?: string;
+    channel?: string;
+};
+export type StoredEvent = AlertEvent | DiagnosticSnapshot | HeartbeatSnapshot;
+export type AlertTarget = {
+    channel: string;
+    to: string;
+    accountId?: string;
+};
+export type RuleOverride = {
+    enabled?: boolean;
+    threshold?: number;
+    cooldownMinutes?: number;
+};
+export type MonitorConfig = {
+    apiKey?: string;
+    alertChannel?: string;
+    alertTo?: string;
+    alertAccountId?: string;
+    cooldownMinutes?: number;
+    maxLogSizeKb?: number;
+    maxLogAgeDays?: number;
+    quiet?: boolean;
+    rules?: Record<string, RuleOverride>;
+};
+export type OpenAlertsInitOptions = {
+    /** Where to store JSONL event logs */
+    stateDir: string;
+    /** Monitor config (rules, cooldowns, etc.) */
+    config: MonitorConfig;
+    /** Alert channels to send to */
+    channels?: AlertChannel[];
+    /** Logger (defaults to console) */
+    logger?: OpenAlertsLogger;
+    /** Log prefix for messages */
+    logPrefix?: string;
+    /** Diagnosis hint shown in critical alerts (e.g., 'Run "openclaw doctor"') */
+    diagnosisHint?: string;
+};
+export type OpenAlertsLogger = {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+};
+export type WindowEntry = {
+    ts: number;
+    value?: number;
+};
+export type EvaluatorState = {
+    /** Sliding window counters keyed by window name */
+    windows: Map<string, WindowEntry[]>;
+    /** Cooldown: fingerprint → last alerted timestamp */
+    cooldowns: Map<string, number>;
+    /** Consecutive failure counters keyed by counter name */
+    consecutives: Map<string, number>;
+    /** Hourly alert count for hard cap */
+    hourlyAlerts: {
+        count: number;
+        resetAt: number;
+    };
+    /** Last diagnostic heartbeat timestamp (for gateway-down detection) */
+    lastHeartbeatTs: number;
+    /** Startup timestamp */
+    startedAt: number;
+    /** Aggregate 24h counters for /health display */
+    stats: {
+        messagesProcessed: number;
+        messageErrors: number;
+        messagesReceived: number;
+        webhookErrors: number;
+        stuckSessions: number;
+        toolCalls: number;
+        toolErrors: number;
+        agentStarts: number;
+        agentErrors: number;
+        sessionsStarted: number;
+        compactions: number;
+        totalTokens: number;
+        totalCostUsd: number;
+        lastResetTs: number;
+    };
+};
+export type RuleContext = {
+    state: EvaluatorState;
+    config: MonitorConfig;
+    now: number;
+};
+export type AlertRuleDefinition = {
+    id: string;
+    defaultCooldownMs: number;
+    defaultThreshold: number;
+    evaluate: (event: OpenAlertsEvent, ctx: RuleContext) => AlertEvent | null;
+};
+export declare const STORE_DIR_NAME = "openalerts";
+export declare const LOG_FILENAME = "events.jsonl";
+export declare const DEFAULTS: {
+    readonly cooldownMs: number;
+    readonly maxLogSizeKb: 512;
+    readonly maxLogAgeDays: 7;
+    readonly maxWindowEntries: 100;
+    readonly maxCooldownEntries: 50;
+    readonly maxAlertsPerHour: 5;
+    readonly watchdogIntervalMs: 30000;
+    readonly pruneIntervalMs: number;
+    readonly platformFlushIntervalMs: number;
+    readonly platformBatchSize: 100;
+    readonly gatewayDownThresholdMs: 90000;
+};

package/dist/core/types.js

@@ -0,0 +1,17 @@
+// ─── Alert Severity ──────────────────────────────────────────────────────────
+// ─── Constants ───────────────────────────────────────────────────────────────
+export const STORE_DIR_NAME = "openalerts";
+export const LOG_FILENAME = "events.jsonl";
+export const DEFAULTS = {
+    cooldownMs: 15 * 60 * 1000, // 15 minutes
+    maxLogSizeKb: 512,
+    maxLogAgeDays: 7,
+    maxWindowEntries: 100,
+    maxCooldownEntries: 50,
+    maxAlertsPerHour: 5,
+    watchdogIntervalMs: 30_000, // 30 seconds
+    pruneIntervalMs: 6 * 60 * 60 * 1000, // 6 hours
+    platformFlushIntervalMs: 5 * 60 * 1000, // 5 minutes
+    platformBatchSize: 100,
+    gatewayDownThresholdMs: 90_000, // 90 seconds
+};

package/dist/index.js

@@ -1,9 +1,9 @@
-import { OpenAlertsEngine } from "@steadwing/openalerts-core";
+import { OpenAlertsEngine } from "./core/index.js";
 import { onDiagnosticEvent, registerLogTransport } from "openclaw/plugin-sdk";
-import { createLogBridge } from "./src/log-bridge.js";
-import { OpenClawAlertChannel, parseConfig, resolveAlertTarget, translateOpenClawEvent, translateToolCallHook, translateAgentStartHook, translateAgentEndHook, translateSessionStartHook, translateSessionEndHook, translateMessageSentHook, translateMessageReceivedHook, translateBeforeToolCallHook, translateBeforeCompactionHook, translateAfterCompactionHook, translateMessageSendingHook, translateToolResultPersistHook, translateGatewayStartHook, translateGatewayStopHook, } from "./src/adapter.js";
-import { bindEngine, createMonitorCommands } from "./src/commands.js";
-import { createDashboardHandler, closeDashboardConnections, } from "./src/dashboard-routes.js";
+import { createLogBridge } from "./plugin/log-bridge.js";
+import { OpenClawAlertChannel, 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";
 const PLUGIN_ID = "openalerts";
 const LOG_PREFIX = "openalerts";
 let engine = null;

package/dist/{src → plugin}/adapter.d.ts

@@ -1,4 +1,4 @@
-import type { AlertChannel, AlertEvent, AlertTarget, MonitorConfig, OpenAlertsEvent } from "@steadwing/openalerts-core";
+import type { AlertChannel, AlertEvent, AlertTarget, MonitorConfig, OpenAlertsEvent } from "../core/index.js";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 /**
  * Translate an OpenClaw diagnostic event into a universal OpenAlertsEvent.

package/dist/{src → plugin}/commands.d.ts

@@ -1,4 +1,4 @@
-import type { OpenAlertsEngine } from "@steadwing/openalerts-core";
+import type { OpenAlertsEngine } from "../core/index.js";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 type PluginCommandDef = {
     name: string;

package/dist/{src → plugin}/commands.js

@@ -1,4 +1,4 @@
-import { formatAlertsOutput, formatHealthOutput } from "@steadwing/openalerts-core";
+import { formatAlertsOutput, formatHealthOutput } from "../core/index.js";
 // Engine reference, set when service starts
 let _engine = null;
 let _api = null;

package/dist/{src → plugin}/dashboard-routes.d.ts

@@ -1,5 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { OpenAlertsEngine } from "@steadwing/openalerts-core";
+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;

package/dist/{src → plugin}/log-bridge.d.ts

@@ -1,4 +1,4 @@
-import type { OpenAlertsEngine } from "@steadwing/openalerts-core";
+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

package/dist/{src → plugin}/log-bridge.js

@@ -1,4 +1,4 @@
-import { BoundedMap } from "@steadwing/openalerts-core";
+import { BoundedMap } from "../core/index.js";
 // ─── Parsing Helpers ─────────────────────────────────────────────────────────
 const KV_RE = /(\w+)=([\S]+)/g;
 /** Parse key=value pairs from a log message string. */