devassist-agent 1.0.0

package/src/modules/runtime/notification-center.js

@@ -0,0 +1,443 @@
+/**
+ * NotificationCenter - Multi-channel notification system
+ *
+ * Design from 通知与健康检查基础设施_完整报告.md:
+ *   - 4 channels: log, email, webhook, dingtalk
+ *   - Priority-based routing (INFO, WARN, ERROR, CRITICAL)
+ *   - Rate limiting per channel (prevents alert storms)
+ *   - Deduplication by content signature
+ *
+ * Integrates with InfrastructureGuard via EventBus:
+ *   guard:alert -> NotificationCenter.send()
+ */
+
+const { bus } = require('../../core/event-bus');
+const { Logger } = require('../../core/logger');
+
+const log = new Logger('NotificationCenter');
+
+const LEVELS = {
+  INFO:     { value: 0, label: 'INFO',     color: '\x1b[36m' },
+  WARN:     { value: 1, label: 'WARN',     color: '\x1b[33m' },
+  ERROR:    { value: 2, label: 'ERROR',    color: '\x1b[31m' },
+  CRITICAL: { value: 3, label: 'CRITICAL', color: '\x1b[35m' },
+};
+
+// ============ Channels ============
+
+/**
+ * Base Channel class.
+ */
+class Channel {
+  constructor(name, opts = {}) {
+    this.name = name;
+    this.minLevel = opts.minLevel || LEVELS.INFO;
+    this.rateLimitWindow = opts.rateLimitWindow || 60 * 1000;  // 1 min
+    this.rateLimitMax = opts.rateLimitMax || 50;                // 50 per window
+    this.enabled = opts.enabled !== false;
+
+    this._sentCount = 0;
+    this._rateBuckets = new Map(); // signature -> timestamps[]
+  }
+
+  /**
+   * Send a notification. Override in subclass.
+   */
+  async send(notification) {
+    throw new Error('Channel.send() must be overridden');
+  }
+
+  /**
+   * Check rate limit for a given signature.
+   */
+  _checkRateLimit(signature) {
+    const now = Date.now();
+    const bucket = this._rateBuckets.get(signature) || [];
+    const valid = bucket.filter(t => now - t < this.rateLimitWindow);
+
+    if (valid.length >= this.rateLimitMax) {
+      return false; // Rate limited
+    }
+
+    valid.push(now);
+    this._rateBuckets.set(signature, valid);
+    return true;
+  }
+
+  /**
+   * Clean up old rate limit entries.
+   */
+  _cleanup() {
+    const now = Date.now();
+    for (const [sig, times] of this._rateBuckets) {
+      const valid = times.filter(t => now - t < this.rateLimitWindow);
+      if (valid.length === 0) {
+        this._rateBuckets.delete(sig);
+      } else {
+        this._rateBuckets.set(sig, valid);
+      }
+    }
+  }
+
+  get stats() {
+    return { sent: this._sentCount, enabled: this.enabled };
+  }
+}
+
+/**
+ * Log Channel — writes to console/file logger.
+ */
+class LogChannel extends Channel {
+  constructor(opts = {}) {
+    super('log', { minLevel: LEVELS.INFO, rateLimitMax: 200, ...opts });
+  }
+
+  async send(notification) {
+    const level = LEVELS[notification.level] || LEVELS.INFO;
+    const color = level.color;
+    const reset = '\x1b[0m';
+    const ts = new Date(notification.timestamp).toISOString();
+
+    const line = `${color}[${ts}] ${level.label}${reset} [${notification.source}] ${notification.title}`;
+
+    if (notification.data) {
+      console.log(line);
+      console.log(`  Details: ${JSON.stringify(notification.data, null, 2).split('\n').join('\n  ')}`);
+    } else {
+      console.log(line);
+    }
+
+    if (notification.message) {
+      console.log(`  ${notification.message}`);
+    }
+
+    this._sentCount++;
+    return true;
+  }
+}
+
+/**
+ * Email Channel — sends email notifications (stub — implement with nodemailer).
+ */
+class EmailChannel extends Channel {
+  constructor(opts = {}) {
+    super('email', { minLevel: LEVELS.ERROR, rateLimitMax: 20, ...opts });
+    this.to = opts.to || [];
+    this.from = opts.from || 'devassist@localhost';
+    this.smtpConfig = opts.smtpConfig || null;
+  }
+
+  async send(notification) {
+    if (!this.smtpConfig || this.to.length === 0) {
+      log.debug('Email channel not configured, skipping');
+      return false;
+    }
+
+    // In production, use nodemailer here:
+    // const transporter = nodemailer.createTransport(this.smtpConfig);
+    // await transporter.sendMail({ from, to, subject, text });
+
+    log.info(`[EMAIL] 收件人：${this.to.join(',')} | 主题：[${notification.level}] ${notification.title}`);
+    this._sentCount++;
+    return true;
+  }
+}
+
+/**
+ * Webhook Channel — sends HTTP POST to a URL.
+ */
+class WebhookChannel extends Channel {
+  constructor(opts = {}) {
+    super('webhook', { minLevel: LEVELS.WARN, rateLimitMax: 30, ...opts });
+    this.url = opts.url || null;
+    this.headers = opts.headers || { 'Content-Type': 'application/json' };
+    this.timeout = opts.timeout || 5000;
+  }
+
+  async send(notification) {
+    if (!this.url) {
+      log.debug('Webhook URL not configured, skipping');
+      return false;
+    }
+
+    const body = JSON.stringify({
+      level: notification.level,
+      title: notification.title,
+      message: notification.message,
+      source: notification.source,
+      data: notification.data,
+      timestamp: notification.timestamp,
+    });
+
+    try {
+      const res = await fetch(this.url, {
+        method: 'POST',
+        headers: this.headers,
+        body,
+        signal: AbortSignal.timeout ? AbortSignal.timeout(this.timeout) : undefined,
+      });
+
+      if (!res.ok) {
+        log.warn(`Webhook 返回 ${res.status}：${res.statusText}`);
+        return false;
+      }
+
+      this._sentCount++;
+      return true;
+    } catch (err) {
+      log.error(`Webhook 发送失败：${err.message}`);
+      return false;
+    }
+  }
+}
+
+/**
+ * DingTalk Channel — sends to DingTalk group robot.
+ */
+class DingTalkChannel extends Channel {
+  constructor(opts = {}) {
+    super('dingtalk', { minLevel: LEVELS.WARN, rateLimitMax: 20, ...opts });
+    this.webhookUrl = opts.webhookUrl || null;
+    this.secret = opts.secret || null; // Sign key for security
+  }
+
+  async send(notification) {
+    if (!this.webhookUrl) {
+      log.debug('DingTalk webhook not configured, skipping');
+      return false;
+    }
+
+    const level = LEVELS[notification.level] || LEVELS.INFO;
+    const title = `[${level.label}] ${notification.title}`;
+    let text = `### ${title}\n\n`;
+    text += `**Source:** ${notification.source}\n\n`;
+    if (notification.message) {
+      text += `**Message:** ${notification.message}\n\n`;
+    }
+    if (notification.data) {
+      text += `**Details:**\n\n\`\`\`json\n${JSON.stringify(notification.data, null, 2)}\n\`\`\`\n`;
+    }
+    text += `**Time:** ${new Date(notification.timestamp).toLocaleString('zh-CN')}`;
+
+    const body = {
+      msgtype: 'markdown',
+      markdown: { title, text },
+    };
+
+    // Sign the request if secret is configured
+    let url = this.webhookUrl;
+    if (this.secret) {
+      const timestamp = Date.now();
+      const stringToSign = `${timestamp}\n${this.secret}`;
+      const crypto = require('crypto');
+      const sign = crypto
+        .createHmac('sha256', this.secret)
+        .update(stringToSign)
+        .digest('base64');
+      url += `&timestamp=${timestamp}&sign=${encodeURIComponent(sign)}`;
+    }
+
+    try {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout ? AbortSignal.timeout(5000) : undefined,
+      });
+
+      const j = await res.json().catch(() => ({}));
+      if (j.errcode && j.errcode !== 0) {
+        log.warn(`钉钉错误：${j.errmsg}`);
+        return false;
+      }
+
+      this._sentCount++;
+      return true;
+    } catch (err) {
+      log.error(`钉钉发送失败：${err.message}`);
+      return false;
+    }
+  }
+}
+
+// ============ NotificationCenter ============
+
+class NotificationCenter {
+  constructor() {
+    this._channels = new Map();
+    this._dedupCache = new Map();      // signature -> last sent timestamp
+    this._dedupTTL = 5 * 60 * 1000;   // 5 minutes
+    this._queue = [];
+    this._processing = false;
+    this._stats = { totalSent: 0, totalDeduped: 0, totalRateLimited: 0 };
+
+    // Register default log channel
+    this.registerChannel(new LogChannel());
+
+    // Auto-subscribe to guard:alert events
+    bus.on('guard:alert', async (alert) => {
+      await this.send({
+        level: alert.severity === 'critical' ? 'CRITICAL' : 'WARN',
+        title: `Health Alert: ${alert.probe}`,
+        message: alert.message,
+        source: 'InfrastructureGuard',
+        data: alert.details,
+        timestamp: Date.now(),
+      });
+    });
+  }
+
+  /**
+   * Register a notification channel.
+   */
+  registerChannel(channel) {
+    if (!(channel instanceof Channel)) {
+      throw new Error('Must be a Channel instance');
+    }
+    this._channels.set(channel.name, channel);
+    log.info(`通道已注册：${channel.name}（最低级别：${channel.minLevel.label}）`);
+  }
+
+  /**
+   * Remove a channel.
+   */
+  unregisterChannel(name) {
+    this._channels.delete(name);
+  }
+
+  /**
+   * Send a notification to all eligible channels.
+   *
+   * @param {object} notification - { level, title, message, source, data, timestamp }
+   */
+  async send(notification) {
+    // Normalize
+    const level = typeof notification.level === 'string'
+      ? LEVELS[notification.level]
+      : notification.level;
+
+    if (!level) {
+      log.warn(`未知通知级别：${notification.level}`);
+      return;
+    }
+
+    notification = {
+      ...notification,
+      level: level.label,
+      levelValue: level.value,
+      timestamp: notification.timestamp || Date.now(),
+    };
+
+    // Deduplication — skip if same content was sent recently
+    const signature = this._makeSignature(notification);
+    const lastSent = this._dedupCache.get(signature);
+    if (lastSent && Date.now() - lastSent < this._dedupTTL) {
+      this._stats.totalDeduped++;
+      return;
+    }
+
+    // Send to all eligible channels
+    const promises = [];
+    for (const channel of this._channels.values()) {
+      if (!channel.enabled) continue;
+      if (level.value < channel.minLevel.value) continue;
+
+      // Rate limit check
+      if (!channel._checkRateLimit(signature)) {
+        this._stats.totalRateLimited++;
+        log.warn(`通道 '${channel.name}' 被速率限制：${notification.title}`);
+        continue;
+      }
+
+      promises.push(
+        channel.send(notification).catch(err => {
+          log.error(`通道 '${channel.name}' 发送错误：${err.message}`);
+        })
+      );
+    }
+
+    await Promise.all(promises);
+
+    // Update dedup cache
+    this._dedupCache.set(signature, notification.timestamp);
+    this._stats.totalSent++;
+
+    // Emit event for monitoring
+    bus.emit('notification:sent', {
+      level: notification.level,
+      title: notification.title,
+      source: notification.source,
+      channels: Array.from(this._channels.keys()),
+    });
+  }
+
+  /**
+   * Convenience methods for each level.
+   */
+  async info(title, message, source = 'system', data = null) {
+    return this.send({ level: 'INFO', title, message, source, data });
+  }
+
+  async warn(title, message, source = 'system', data = null) {
+    return this.send({ level: 'WARN', title, message, source, data });
+  }
+
+  async error(title, message, source = 'system', data = null) {
+    return this.send({ level: 'ERROR', title, message, source, data });
+  }
+
+  async critical(title, message, source = 'system', data = null) {
+    return this.send({ level: 'CRITICAL', title, message, source, data });
+  }
+
+  /**
+   * Create a dedup signature from notification content.
+   */
+  _makeSignature(notification) {
+    const parts = [
+      notification.level,
+      notification.title,
+      notification.source,
+      notification.data ? JSON.stringify(notification.data).substring(0, 200) : '',
+    ];
+    return parts.join('|');
+  }
+
+  /**
+   * Clean up old dedup entries.
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [sig, ts] of this._dedupCache) {
+      if (now - ts > this._dedupTTL) {
+        this._dedupCache.delete(sig);
+      }
+    }
+    for (const channel of this._channels.values()) {
+      channel._cleanup();
+    }
+  }
+
+  /**
+   * Get stats.
+   */
+  getStats() {
+    const channels = {};
+    for (const [name, channel] of this._channels) {
+      channels[name] = channel.stats;
+    }
+    return { ...this._stats, channels };
+  }
+
+  /**
+   * Get registered channels.
+   */
+  getChannels() {
+    return Array.from(this._channels.keys());
+  }
+}
+
+// Singleton
+const center = new NotificationCenter();
+
+module.exports = { NotificationCenter, center, Channel, LogChannel, EmailChannel, WebhookChannel, DingTalkChannel, LEVELS };