feat: make each plugin an npm workspace built by a termix-plugin CLI

plugins/automations/src/backend/notify.ts

@@ -0,0 +1,193 @@
+import { statsLogger } from "../../../../src/backend/utils/logger.js";
+import { automationFetch } from "./http.js";
+import type { TemplateContext } from "./template.js";
+
+/**
+ * Notification delivery for automations.
+ *
+ * The alert engine special-cased Discord because its dispatcher only knew
+ * webhook and ntfy; here every transport goes through one switch, so adding a
+ * channel type is a single edit.
+ */
+export interface AutomationChannel {
+  id: number;
+  type: string;
+  config: string;
+}
+
+export interface AutomationNotification {
+  title: string;
+  body: string;
+  severity: "info" | "warning" | "critical";
+  context?: TemplateContext;
+}
+
+const NTFY_PRIORITY: Record<string, number> = {
+  info: 2,
+  warning: 3,
+  critical: 5,
+};
+
+const NTFY_TAGS: Record<string, string> = {
+  info: "information_source",
+  warning: "warning",
+  critical: "rotating_light",
+};
+
+const DISCORD_COLORS: Record<string, number> = {
+  info: 3066993,
+  warning: 16753920,
+  critical: 15158332,
+};
+
+export async function sendAutomationNotification(
+  channel: AutomationChannel,
+  notification: AutomationNotification,
+): Promise<void> {
+  let config: Record<string, unknown>;
+  try {
+    config = JSON.parse(channel.config) as Record<string, unknown>;
+  } catch {
+    throw new Error("Channel configuration is not valid JSON");
+  }
+
+  const allowPrivateNetwork = config.allowPrivateNetwork === true;
+
+  switch (channel.type) {
+    case "webhook":
+      return sendWebhook(config, notification, allowPrivateNetwork);
+    case "ntfy":
+      return sendNtfy(config, notification, allowPrivateNetwork);
+    case "discord":
+      return sendDiscord(config, notification, allowPrivateNetwork);
+    default:
+      throw new Error(`Unsupported channel type: ${channel.type}`);
+  }
+}
+
+function requireUrl(config: Record<string, unknown>): string {
+  const url = typeof config.url === "string" ? config.url.trim() : "";
+  if (!url) throw new Error("Channel is missing a URL");
+  return url;
+}
+
+async function sendWebhook(
+  config: Record<string, unknown>,
+  notification: AutomationNotification,
+  allowPrivateNetwork: boolean,
+): Promise<void> {
+  const url = requireUrl(config);
+  const method = config.method === "PUT" ? "PUT" : "POST";
+  const headers =
+    config.headers && typeof config.headers === "object"
+      ? (config.headers as Record<string, string>)
+      : {};
+
+  const response = await automationFetch(url, {
+    method,
+    headers,
+    body: JSON.stringify({
+      title: notification.title,
+      hostName:
+        notification.context?.host?.name ??
+        notification.context?.trigger?.hostName,
+      hostId:
+        notification.context?.host?.id ?? notification.context?.trigger?.hostId,
+      ruleName: notification.title,
+      ruleId: notification.context?.run?.automationId,
+      triggerType: notification.context?.trigger?.type,
+      value: notification.context?.trigger?.value,
+      threshold: notification.context?.trigger?.threshold,
+      message: notification.body,
+      severity: notification.severity,
+      timestamp: new Date().toISOString(),
+    }),
+    allowPrivateNetwork,
+  });
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} ${response.statusText}`);
+  }
+}
+
+async function sendNtfy(
+  config: Record<string, unknown>,
+  notification: AutomationNotification,
+  allowPrivateNetwork: boolean,
+): Promise<void> {
+  const base = requireUrl(config).replace(/\/$/, "");
+  const topic = typeof config.topic === "string" ? config.topic.trim() : "";
+  if (!topic) throw new Error("ntfy channel is missing a topic");
+
+  const headers: Record<string, string> = {
+    Title: notification.title || "Termix automation",
+    Priority: String(NTFY_PRIORITY[notification.severity] ?? 3),
+    Tags: NTFY_TAGS[notification.severity] ?? "information_source",
+  };
+  if (typeof config.token === "string" && config.token) {
+    headers.Authorization = `Bearer ${config.token}`;
+  }
+
+  const response = await automationFetch(`${base}/${topic}`, {
+    method: "POST",
+    headers,
+    body: notification.body || notification.title,
+    allowPrivateNetwork,
+  });
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} ${response.statusText}`);
+  }
+}
+
+async function sendDiscord(
+  config: Record<string, unknown>,
+  notification: AutomationNotification,
+  allowPrivateNetwork: boolean,
+): Promise<void> {
+  const url = requireUrl(config);
+  const payload: Record<string, unknown> = {
+    embeds: [
+      {
+        title: notification.title || "Termix automation",
+        description: notification.body || undefined,
+        color: DISCORD_COLORS[notification.severity] ?? 3447003,
+        timestamp: new Date().toISOString(),
+      },
+    ],
+  };
+  if (typeof config.username === "string" && config.username) {
+    payload.username = config.username;
+  }
+  if (typeof config.avatar_url === "string" && config.avatar_url) {
+    payload.avatar_url = config.avatar_url;
+  }
+
+  const response = await automationFetch(url, {
+    method: "POST",
+    body: JSON.stringify(payload),
+    allowPrivateNetwork,
+  });
+
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(
+      `HTTP ${response.status} ${response.statusText}${detail ? `: ${detail}` : ""}`,
+    );
+  }
+}
+
+/** Fire-and-forget wrapper for callers that must not block on delivery. */
+export function sendAutomationNotificationSafely(
+  channel: AutomationChannel,
+  notification: AutomationNotification,
+): void {
+  sendAutomationNotification(channel, notification).catch((error) => {
+    statsLogger.warn("Automation notification failed", {
+      operation: "automation_notification_error",
+      channelId: channel.id,
+      type: channel.type,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  });
+}