@steadwing/openalerts 0.2.4 → 0.2.6

package/README.md

@@ -1,191 +1,252 @@
-<p align="center">
-  <h1 align="center">OpenAlerts</h1>
-  <p align="center">
-    An alerting layer for agentic frameworks.
-  </p>
-</p>
-
-<p align="center">
-  <a href="https://www.npmjs.com/package/@steadwing/openalerts"><img src="https://img.shields.io/npm/v/@steadwing/openalerts?style=flat&color=blue" alt="npm"></a>
-  <a href="https://github.com/steadwing/openalerts/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-green" alt="License"></a>
-  <a href="https://github.com/steadwing/openalerts/stargazers"><img src="https://img.shields.io/github/stars/steadwing/openalerts?style=flat" alt="GitHub stars"></a>
-  <a href="https://discord.gg/4rUP86tSXn"><img src="https://img.shields.io/badge/discord-join-5865F2?style=flat" alt="Discord"></a>
-</p>
-
-<p align="center">
-  <a href="#quickstart">Quickstart</a> &middot;
-  <a href="#alert-rules">Alert Rules</a> &middot;
-  <a href="#llm-enriched-alerts">LLM Enrichment</a> &middot;
-  <a href="#dashboard">Dashboard</a> &middot;
-  <a href="#commands">Commands</a>
-</p>
+# openalerts
+
+Standalone monitoring daemon for [OpenClaw](https://openclaw.dev). Connects to your local OpenClaw gateway in real time, fires alerts via Telegram or webhook when something goes wrong, and serves a live dashboard at `http://localhost:4242`.
+
+No code changes to OpenClaw needed — runs as a separate process alongside it.
 
 ---
 
-AI agents fail silently. LLM errors, stuck sessions, gateway outages — nobody knows until a user complains.
+## Install
 
-OpenAlerts watches your agent in real-time and alerts you the moment something goes wrong. A framework-agnostic core with adapter plugins — starting with [OpenClaw](https://github.com/openclaw/openclaw).
+```bash
+npm install -g @steadwing/openalerts
+```
 
-## Quickstart
+> Requires **Node.js ≥ 22.5.0** (uses the built-in `node:sqlite` module — no native builds).
 
-> Currently supports OpenClaw. More framework adapters coming soon.
-> This project is under revamp for the next few hours
+---
 
-### 1. Install
+## Quick start
 
 ```bash
-openclaw plugins install @steadwing/openalerts
+# 1. Create default config (auto-detects your OpenClaw gateway token)
+openalerts init
+
+# 2. Edit config to add your alert channel
+#    ~/.openalerts/config.json
+
+# 3. Start monitoring
+openalerts start
 ```
 
-### 2. Configure
+Dashboard at **http://127.0.0.1:4242** — the gateway overlay dismisses automatically once connected.
 
-If you already have a channel paired with OpenClaw (e.g. Telegram via `openclaw pair`), **no config is needed** — OpenAlerts auto-detects where to send alerts.
+---
 
-Otherwise, set it explicitly in `openclaw.json`:
+## CLI
 
-```jsonc
-{
-	"plugins": {
-		"entries": {
-			"openalerts": {
-				"enabled": true,
-				"config": {
-					"alertChannel": "telegram", // telegram | discord | slack | whatsapp | signal
-					"alertTo": "YOUR_CHAT_ID",
-				},
-			},
-		},
-	},
-}
-```
+| Command  | Description                                               |
+| -------- | --------------------------------------------------------- |
+| `openalerts init`   | Create default config at `~/.openalerts/config.json` |
+| `openalerts start`  | Start the monitoring daemon |
+| `openalerts status` | Print live engine state (daemon must be running) |
+| `openalerts test`   | Fire a test alert through all configured channels |
 
-**Auto-detection priority:** explicit config > static `allowFrom` in channel config > pairing store.
+**Options for `start`:**
 
-### 3. Restart & verify
+| Flag | Default | Description |
+| ---- | ------- | ----------- |
+| `--port N` | `4242` | HTTP server port |
+| `--config PATH` | `~/.openalerts/config.json` | Config file path |
 
-```bash
-openclaw gateway stop && openclaw gateway run
-```
+---
 
-Send `/health` to your bot. You should get a live status report back — zero LLM tokens consumed.
+## Configuration
 
-That's it. OpenAlerts is now watching your agent.
+`~/.openalerts/config.json` (created by `openalerts init`):
 
-## Demo
+```json
+{
+  "gatewayUrl": "ws://127.0.0.1:18789",
+  "gatewayToken": "<auto-detected from ~/.openclaw/openclaw.json>",
+  "stateDir": "~/.openalerts",
+  "watch": {
+    "openclawDir": "~/.openclaw",
+    "workspaces": ["workspace", "workspace-study"]
+  },
+  "server": {
+    "port": 4242,
+    "host": "127.0.0.1"
+  },
+  "channels": [
+    { "type": "telegram", "token": "BOT_TOKEN", "chatId": "CHAT_ID" },
+    { "type": "webhook", "webhookUrl": "https://your-endpoint" },
+    { "type": "console" }
+  ],
+  "quiet": false
+}
+```
 
-https://github.com/user-attachments/assets/0b6ed26e-1eb0-47b2-ae4f-947516f024b4
+**Gateway token** is auto-detected from `gateway.auth.token` in `~/.openclaw/openclaw.json` — no manual copy needed.
 
-## Dashboard
+**Channels**: configure at least one. Falls back to `console` if none are set.
 
-A real-time web dashboard is embedded in the gateway at:
+---
 
-```
-http://127.0.0.1:18789/openalerts
-```
+## What it monitors
 
-- **Activity** — Live event timeline with session flows, tool calls, LLM usage
-- **System Logs** — Filtered, structured logs with search
-- **Health** — Rule status, alert history, system stats
+Captures everything from the OpenClaw gateway WebSocket in real time:
 
-## Alert Rules
+| Event | What's captured |
+| ----- | --------------- |
+| Agent runs | Start, streaming, complete, error, aborted |
+| Tool calls | Tool name, duration, result |
+| LLM usage | Token counts, cost per call |
+| Shell exec | Command, pid, output, exit code |
+| Heartbeats | Gateway health, active sessions, queue depth |
+| Cron jobs | Schedule, last run, next run, errors |
+| Sessions | Active sessions, costs, message counts |
+| Workspace docs | SOUL.md, HEARTBEAT.md, MEMORY.md per agent |
 
-Eight rules run against every event in real-time. All thresholds and cooldowns are configurable.
+---
 
-| Rule              | Watches for                           | Severity | Threshold (default) |
-| ----------------- | ------------------------------------- | -------- | ------------------- |
-| `llm-errors`      | LLM/agent failures in 1 min window    | ERROR    | `1` error           |
-| `infra-errors`    | Infrastructure errors in 1 min window | ERROR    | `1` error           |
-| `gateway-down`    | No heartbeat received                 | CRITICAL | `30000` ms (30s)    |
-| `session-stuck`   | Session idle too long                 | WARN     | `120000` ms (2 min) |
-| `high-error-rate` | Message failure rate over last 20     | ERROR    | `50`%               |
-| `queue-depth`     | Queued items piling up                | WARN     | `10` items          |
-| `tool-errors`     | Tool failures in 1 min window         | WARN     | `1` error           |
-| `heartbeat-fail`  | Consecutive heartbeat failures        | ERROR    | `3` failures        |
+## Alert rules
 
-Every rule also accepts:
+Ten rules run against every event in real time. All thresholds and cooldowns are configurable via the `rules` key in config.
 
-- **`enabled`** — `false` to disable the rule (default: `true`)
-- **`cooldownMinutes`** — minutes before the same rule can fire again (default: `15`)
+| Rule | Triggers when | Threshold | Cooldown |
+| ---- | ------------- | --------- | -------- |
+| `infra-errors` | `infra.error` events in 1 min | 1 | 15 min |
+| `llm-errors` | `llm.error` or `agent.error` in 1 min | 1 | 15 min |
+| `tool-errors` | `tool.error` in 1 min | 1 | 15 min |
+| `heartbeat-fail` | Consecutive heartbeat failures | 3 | 30 min |
+| `session-stuck` | Session idle too long | 120 s | 30 min |
+| `high-error-rate` | Error % of last 20 calls | 50% | 30 min |
+| `queue-depth` | Items in delivery queue | 10 | 15 min |
+| `gateway-down` | No heartbeat from watchdog | 30 s | 60 min |
+| `cost-hourly-spike` | LLM cost per hour | $5 | 30 min |
+| `cost-daily-budget` | LLM cost per day | $20 | 6 h |
 
-To tune rules, add a `rules` object in your plugin config:
+Override a rule threshold in config:
 
-```jsonc
+```json
 {
-	"plugins": {
-		"entries": {
-			"openalerts": {
-				"config": {
-					"cooldownMinutes": 10,
-					"rules": {
-						"llm-errors": { "threshold": 5 },
-						"infra-errors": { "cooldownMinutes": 30 },
-						"high-error-rate": { "enabled": false },
-						"gateway-down": { "threshold": 60000 },
-					},
-				},
-			},
-		},
-	},
+  "rules": {
+    "llm-errors": { "threshold": 5 },
+    "gateway-down": { "enabled": false },
+    "heartbeat-fail": { "cooldownMinutes": 60 }
+  }
 }
 ```
 
-Set `"quiet": true` at the config level for log-only mode (no messages sent).
+---
 
-## LLM-Enriched Alerts
+## Dashboard
 
-OpenAlerts can optionally use your configured LLM to enrich alerts with a human-friendly summary and an actionable suggestion. **This feature is disabled by default** — opt in by setting `"llmEnriched": true` in your plugin config:
+Open **http://127.0.0.1:4242** after starting.
 
-```jsonc
-{
-	"plugins": {
-		"entries": {
-			"openalerts": {
-				"config": {
-					"llmEnriched": true,
-				},
-			},
-		},
-	},
-}
-```
+| Tab | What's shown |
+| --- | ------------ |
+| **Overview** | Gateway health log, live activity feed, 24h stats, recent alerts |
+| **Workspaces** | Per-agent SOUL.md, HEARTBEAT.md, MEMORY.md, USER.md previews |
+| **Alerts** | Full alert history with severity, rule ID, fingerprint |
+| **Sessions** | Active sessions with status, token counts, cost |
+| **Live Monitor** | Real-time per-run timeline — steps, tool calls, LLM responses, exec |
+| **Cron Jobs** | Scheduled job status, last/next run, consecutive errors |
+| **Diagnostics** | Raw engine event log |
+| **Delivery Queue** | Pending/failed alert delivery items |
 
-When enabled, alerts include an LLM-generated summary and action:
+Live Monitor sidebar shows sessions colour-coded by status:
+- Green pulse = active (idle, waiting for input)
+- Yellow pulse = thinking (LLM streaming in progress)
+- Grey = no recent activity
 
-```
-1 agent error(s) on unknown in the last minute. Last: 401 Incorrect API key...
+---
 
-Summary: Your OpenAI API key is invalid or expired — the agent cannot make LLM calls.
-Action: Update your API key in ~/.openclaw/.env with a valid key from platform.openai.com/api-keys
-```
+## REST API
+
+All endpoints return JSON. CORS enabled.
+
+| Method | Path | Description |
+| ------ | ---- | ----------- |
+| `GET` | `/api/state` | Full dashboard snapshot |
+| `GET` | `/api/activity` | Unified activity log (actions + diagnostics merged) |
+| `GET` | `/api/logs` | OpenClaw-style log format (`ts`, `level`, `subsystem`, `message`) |
+| `GET` | `/api/actions` | Raw agent/tool/chat action rows |
+| `GET` | `/api/heartbeats` | Gateway heartbeat history |
+| `GET` | `/api/alerts` | Fired alert history |
+| `GET` | `/api/diagnostics` | Engine diagnostic events |
+| `GET` | `/api/engine` | Engine stats, uptime, gateway connection status |
+| `POST` | `/api/test` | Fire a test alert |
+| `GET` | `/events` | SSE stream (live push to dashboard) |
+| `GET` | `/health` | `{ok, ts, sseClients, gatewayConnected}` |
+
+Most list endpoints accept `?limit=N` (default 100, max 500) and `/api/activity`, `/api/actions`, `/api/logs` also accept `?session=KEY`.
+
+### SSE events (`GET /events`)
+
+| Event | Payload |
+| ----- | ------- |
+| `state` | Full dashboard snapshot — sent on connect and on file changes |
+| `openalerts` | Alert fired: `{rule_id, severity, title, detail, ts, fingerprint}` |
+| `action` | Agent step: `{id, runId, sessionKey, type, toolName, content, ts}` |
+| `health` | Gateway heartbeat: `{queueDepth, activeSessions, sessions, ts}` |
+| `diagnostic` | Engine event: `{event_type, ts, summary, session_key}` |
+| `exec` | Shell command: `{type, runId, pid, command, output, exitCode, ts}` |
 
-- **Model**: reads from `agents.defaults.model.primary` in your `openclaw.json` (e.g. `"openai/gpt-4o-mini"`)
-- **API key**: reads from the corresponding environment variable (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GROQ_API_KEY`, etc.)
-- **Supported providers**: OpenAI, Anthropic, Groq, Together, DeepSeek (and any OpenAI-compatible API)
-- **Graceful fallback**: if the LLM call fails or times out (10s), the original alert is sent unchanged
+---
 
-## Commands
+## Architecture
 
-Zero-token chat commands available in any connected channel:
+```
+openalerts
+├── cli.ts                  Entry point — wires everything together
+├── config.ts               Config loading + gateway token auto-detection
+├── core/
+│   ├── engine.ts           Alert engine — ingests events, evaluates rules, fires alerts
+│   ├── evaluator.ts        Sliding-window + cooldown rule state
+│   ├── rules.ts            10 alert rule definitions
+│   └── types.ts            Event and alert type definitions
+├── watchers/
+│   ├── gateway.ts          WebSocket client for OpenClaw gateway
+│   ├── gateway-adapter.ts  Translates gateway frames → engine events + SSE payloads
+│   └── files.ts            node:fs watcher for OpenClaw workspace files
+├── readers/
+│   └── openclaw.ts         Reads SOUL.md, cron jobs, sessions, delivery queue, config
+├── channels/
+│   ├── telegram.ts         Telegram Bot API (no SDK, direct HTTP)
+│   ├── webhook.ts          HTTP POST to any webhook URL
+│   └── console.ts          Console fallback
+├── server/
+│   ├── index.ts            HTTP server bootstrap
+│   ├── routes.ts           All REST + SSE route handlers
+│   ├── sse.ts              SSE manager (15s keepalive, broadcast)
+│   └── dashboard.ts        Embedded dashboard HTML (vanilla JS, zero framework)
+└── db/
+    ├── index.ts            SQLite open + periodic prune
+    ├── schema.ts           12 tables: sessions, actions, alerts, heartbeats, cron_jobs…
+    └── queries.ts          Typed query functions including getActivityLog (UNION query)
+```
 
-| Command      | What it does                                          |
-| ------------ | ----------------------------------------------------- |
-| `/health`    | System health snapshot — uptime, active alerts, stats |
-| `/alerts`    | Recent alert history with severity and timestamps     |
-| `/dashboard` | Returns the dashboard URL                             |
+**Storage**: SQLite at `~/.openalerts/openalerts.db` using Node 22's built-in `node:sqlite` — no native build step, no binaries to compile.
 
-## Roadmap
+**Zero heavy dependencies**: only `ws` (WebSocket client). No Express, no ORM, no native modules.
 
-- [ ] [nanobot](https://github.com/HKUDS/nanobot) adapter
-- [ ] [OpenManus](https://github.com/FoundationAgents/OpenManus) adapter
+---
 
-## Development
+## Data flow
 
-```bash
-npm install        # install dependencies
-npm run build      # compile TypeScript
-npm run typecheck  # type-check without emitting
-npm run clean      # remove dist/
 ```
+OpenClaw gateway (ws://127.0.0.1:18789)
+    │  health, agent, chat, exec events
+    ▼
+gateway-adapter.ts ──► engine.ingest() ──► rule evaluation ──► Telegram / webhook
+    │                        │
+    │                   SQLite DB              JSONL event store
+    │                (actions, alerts,         (warm-start rule
+    │                 heartbeats, sessions)     state on restart)
+    ▼
+SSE broadcast ──► dashboard live updates
+
+OpenClaw workspace files (~/.openclaw/)
+    │  SOUL.md, HEARTBEAT.md, cron/jobs.json, sessions.json…
+    ▼
+openclaw.ts reader ──► SQLite (agent_info, cron_jobs, sessions)
+    │
+node:fs watcher triggers re-reads on change
+```
+
+---
 
 ## License
 

package/dist/channels/console.d.ts

@@ -0,0 +1,6 @@
+import type { AlertChannel, AlertEvent } from "../core/types.js";
+export declare class ConsoleChannel implements AlertChannel {
+    readonly name = "console";
+    send(alert: AlertEvent, formatted: string): void;
+}
+//# sourceMappingURL=console.d.ts.map

package/dist/channels/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../src/channels/console.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEjE,qBAAa,cAAe,YAAW,YAAY;IACjD,QAAQ,CAAC,IAAI,aAAa;IAC1B,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;CAMjD"}

package/dist/channels/console.js

@@ -0,0 +1,10 @@
+export class ConsoleChannel {
+    name = "console";
+    send(alert, formatted) {
+        const prefix = alert.severity === "critical" ? "🚨" :
+            alert.severity === "error" ? "❌" :
+                alert.severity === "warn" ? "⚠️" : "ℹ️";
+        console.log(`\n${prefix} ALERT [${alert.ruleId}]\n${formatted}\n`);
+    }
+}
+//# sourceMappingURL=console.js.map

package/dist/channels/console.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.js","sourceRoot":"","sources":["../../src/channels/console.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,cAAc;IAChB,IAAI,GAAG,SAAS,CAAC;IAC1B,IAAI,CAAC,KAAiB,EAAE,SAAiB;QACvC,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACtC,KAAK,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;gBAClC,KAAK,CAAC,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;QACvD,OAAO,CAAC,GAAG,CAAC,KAAK,MAAM,WAAW,KAAK,CAAC,MAAM,MAAM,SAAS,IAAI,CAAC,CAAC;IACrE,CAAC;CACF"}

package/dist/channels/telegram.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Telegram alert channel — uses Bot API directly (no OpenClaw dependency).
+ */
+import type { AlertChannel, AlertEvent } from "../core/types.js";
+export declare class TelegramChannel implements AlertChannel {
+    readonly name = "telegram";
+    private token;
+    private chatId;
+    constructor(token: string, chatId: string);
+    send(_alert: AlertEvent, formatted: string): Promise<void>;
+}
+//# sourceMappingURL=telegram.d.ts.map

package/dist/channels/telegram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram.d.ts","sourceRoot":"","sources":["../../src/channels/telegram.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEjE,qBAAa,eAAgB,YAAW,YAAY;IAClD,QAAQ,CAAC,IAAI,cAAc;IAC3B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAS;gBAEX,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAKnC,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAoBjE"}

package/dist/channels/telegram.js

@@ -0,0 +1,28 @@
+export class TelegramChannel {
+    name = "telegram";
+    token;
+    chatId;
+    constructor(token, chatId) {
+        this.token = token;
+        this.chatId = chatId;
+    }
+    async send(_alert, formatted) {
+        const url = `https://api.telegram.org/bot${this.token}/sendMessage`;
+        const body = JSON.stringify({
+            chat_id: this.chatId,
+            text: formatted,
+            parse_mode: "HTML",
+            disable_web_page_preview: true,
+        });
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`Telegram API ${res.status}: ${text.substring(0, 200)}`);
+        }
+    }
+}
+//# sourceMappingURL=telegram.js.map

package/dist/channels/telegram.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram.js","sourceRoot":"","sources":["../../src/channels/telegram.ts"],"names":[],"mappings":"AAKA,MAAM,OAAO,eAAe;IACjB,IAAI,GAAG,UAAU,CAAC;IACnB,KAAK,CAAS;IACd,MAAM,CAAS;IAEvB,YAAY,KAAa,EAAE,MAAc;QACvC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,MAAkB,EAAE,SAAiB;QAC9C,MAAM,GAAG,GAAG,+BAA+B,IAAI,CAAC,KAAK,cAAc,CAAC;QACpE,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC;YAC1B,OAAO,EAAE,IAAI,CAAC,MAAM;YACpB,IAAI,EAAE,SAAS;YACf,UAAU,EAAE,MAAM;YAClB,wBAAwB,EAAE,IAAI;SAC/B,CAAC,CAAC;QAEH,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;YAC3B,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI;SACL,CAAC,CAAC;QAEH,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;YACZ,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;YAC9C,MAAM,IAAI,KAAK,CAAC,gBAAgB,GAAG,CAAC,MAAM,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QAC3E,CAAC;IACH,CAAC;CACF"}

package/dist/channels/webhook.d.ts

@@ -0,0 +1,8 @@
+import type { AlertChannel, AlertEvent } from "../core/types.js";
+export declare class WebhookChannel implements AlertChannel {
+    readonly name = "webhook";
+    private url;
+    constructor(url: string);
+    send(alert: AlertEvent, formatted: string): Promise<void>;
+}
+//# sourceMappingURL=webhook.d.ts.map

package/dist/channels/webhook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook.d.ts","sourceRoot":"","sources":["../../src/channels/webhook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEjE,qBAAa,cAAe,YAAW,YAAY;IACjD,QAAQ,CAAC,IAAI,aAAa;IAC1B,OAAO,CAAC,GAAG,CAAS;gBAER,GAAG,EAAE,MAAM;IAEjB,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAQhE"}

package/dist/channels/webhook.js

@@ -0,0 +1,15 @@
+export class WebhookChannel {
+    name = "webhook";
+    url;
+    constructor(url) { this.url = url; }
+    async send(alert, formatted) {
+        const res = await fetch(this.url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ alert, formatted }),
+        });
+        if (!res.ok)
+            throw new Error(`Webhook ${res.status}`);
+    }
+}
+//# sourceMappingURL=webhook.js.map

package/dist/channels/webhook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook.js","sourceRoot":"","sources":["../../src/channels/webhook.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,cAAc;IAChB,IAAI,GAAG,SAAS,CAAC;IAClB,GAAG,CAAS;IAEpB,YAAY,GAAW,IAAI,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC;IAE5C,KAAK,CAAC,IAAI,CAAC,KAAiB,EAAE,SAAiB;QAC7C,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE;YAChC,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;SAC3C,CAAC,CAAC;QACH,IAAI,CAAC,GAAG,CAAC,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,WAAW,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;IACxD,CAAC;CACF"}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}