chainlesschain 0.45.4 → 0.45.6

package/src/lib/notifiers/index.js

@@ -0,0 +1,183 @@
+/**
+ * NotificationManager — unified multi-channel notification dispatcher.
+ *
+ * Supported channels:
+ *   telegram  — Telegram Bot API
+ *   wecom     — 企业微信群机器人 Webhook
+ *   dingtalk  — 钉钉群机器人 Webhook (支持加签)
+ *   feishu    — 飞书群机器人 Webhook (支持签名校验)
+ *   websocket — Real-time push back over the triggering WS connection
+ *
+ * Supported incoming command sources (via HTTP Webhook receiver):
+ *   wecom     — 企业微信 回调 (XML format)
+ *   dingtalk  — 钉钉 outgoing webhook
+ *   feishu    — 飞书 event subscription
+ *
+ * Configuration (any combination via env vars or options):
+ *   TELEGRAM_BOT_TOKEN + TELEGRAM_CHAT_ID
+ *   WECOM_WEBHOOK_URL
+ *   DINGTALK_WEBHOOK_URL  [+ DINGTALK_SECRET]
+ *   FEISHU_WEBHOOK_URL    [+ FEISHU_SECRET]
+ *
+ * Usage:
+ *   const nm = NotificationManager.fromEnv();
+ *   await nm.notifySuccess({ taskId, description, ... });
+ *
+ *   // With WebSocket channel:
+ *   nm.addWebSocketChannel({ send: (data) => ws._send(ws, data), requestId });
+ */
+
+import { TelegramNotifier } from "./telegram.js";
+import { WeComNotifier } from "./wecom.js";
+import { DingTalkNotifier } from "./dingtalk.js";
+import { FeishuNotifier } from "./feishu.js";
+import { WebSocketNotifier } from "./websocket.js";
+
+// ─── Incoming command parsers ─────────────────────────────────────
+
+/**
+ * Parse a 钉钉 outgoing webhook payload into a command string.
+ * DingTalk sends: { msgtype: "text", text: { content: "..." }, ... }
+ */
+export function parseDingTalkIncoming(body) {
+  if (body?.msgtype === "text") {
+    return body.text?.content?.trim() || null;
+  }
+  return null;
+}
+
+/**
+ * Parse a 飞书 event subscription payload into a command string.
+ * Feishu sends: { event: { message: { content: '{"text":"..."}' } } }
+ */
+export function parseFeishuIncoming(body) {
+  try {
+    const content = body?.event?.message?.content;
+    if (content) {
+      const parsed = JSON.parse(content);
+      return parsed.text?.trim() || null;
+    }
+  } catch (_err) {
+    // ignore
+  }
+  return null;
+}
+
+/**
+ * Parse a 企业微信 回调 XML body into a command string.
+ * WeCom sends XML; this extracts the <Content> field using simple regex
+ * (no heavy XML parser needed for plain text messages).
+ */
+export function parseWeComIncoming(xmlBody) {
+  const match = String(xmlBody).match(
+    /<Content><!\[CDATA\[([^\]]*)\]\]><\/Content>/,
+  );
+  return match ? match[1].trim() : null;
+}
+
+// ─── Notification Manager ─────────────────────────────────────────
+
+export class NotificationManager {
+  constructor() {
+    /** @type {Array<object>} registered notifier instances */
+    this._channels = [];
+  }
+
+  /**
+   * Build a NotificationManager from environment variables.
+   * Any configured channel is automatically added.
+   */
+  static fromEnv(options = {}) {
+    const nm = new NotificationManager();
+
+    const telegram = new TelegramNotifier(options.telegram || {});
+    if (telegram.isConfigured) nm.add("telegram", telegram);
+
+    const wecom = new WeComNotifier(options.wecom || {});
+    if (wecom.isConfigured) nm.add("wecom", wecom);
+
+    const dingtalk = new DingTalkNotifier(options.dingtalk || {});
+    if (dingtalk.isConfigured) nm.add("dingtalk", dingtalk);
+
+    const feishu = new FeishuNotifier(options.feishu || {});
+    if (feishu.isConfigured) nm.add("feishu", feishu);
+
+    return nm;
+  }
+
+  /**
+   * Register a notifier under a name.
+   * @param {string} name
+   * @param {object} notifier - must implement notifySuccess/notifyFailure/notifyStart
+   */
+  add(name, notifier) {
+    // Remove existing channel with same name before re-adding
+    this._channels = this._channels.filter((c) => c.name !== name);
+    this._channels.push({ name, notifier });
+    return this;
+  }
+
+  /**
+   * Add (or replace) the WebSocket channel.
+   * Call this when an orchestration task is triggered from a WS connection.
+   *
+   * @param {object} options
+   * @param {Function} options.send      - (data: object) => void
+   * @param {string}  [options.requestId] - correlating request ID
+   */
+  addWebSocketChannel(options) {
+    const notifier = new WebSocketNotifier(options);
+    this.add("websocket", notifier);
+    return notifier; // caller may use directly for agent output streaming
+  }
+
+  /** Remove a channel by name. */
+  remove(name) {
+    this._channels = this._channels.filter((c) => c.name !== name);
+    return this;
+  }
+
+  /** List active channel names. */
+  get activeChannels() {
+    return this._channels.map((c) => c.name);
+  }
+
+  get isConfigured() {
+    return this._channels.length > 0;
+  }
+
+  // ─── Broadcast methods ──────────────────────────────────────────
+
+  /** Fan-out to all channels; collect results. */
+  async _broadcast(method, payload) {
+    const results = await Promise.allSettled(
+      this._channels.map(({ name, notifier }) =>
+        notifier[method]?.(payload)
+          .then((r) => ({ channel: name, ...r }))
+          .catch((err) => ({ channel: name, ok: false, reason: err.message })),
+      ),
+    );
+    return results.map((r) =>
+      r.status === "fulfilled" ? r.value : { ok: false, ...r.reason },
+    );
+  }
+
+  async notifyStart(summary) {
+    return this._broadcast("notifyStart", summary);
+  }
+
+  async notifySuccess(summary) {
+    return this._broadcast("notifySuccess", summary);
+  }
+
+  async notifyFailure(summary) {
+    return this._broadcast("notifyFailure", summary);
+  }
+}
+
+// Re-export individual notifiers for direct use
+export { TelegramNotifier } from "./telegram.js";
+export { WeComNotifier } from "./wecom.js";
+export { DingTalkNotifier } from "./dingtalk.js";
+export { FeishuNotifier } from "./feishu.js";
+export { WebSocketNotifier } from "./websocket.js";

package/src/lib/notifiers/telegram.js

@@ -0,0 +1,131 @@
+/**
+ * Telegram Notifier — sends CI pass/fail notifications via Telegram Bot API.
+ *
+ * Configure via .chainlesschain/config.json:
+ *   { "telegramBotToken": "...", "telegramChatId": "..." }
+ * or environment variables:
+ *   TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID
+ */
+
+const TELEGRAM_API = "https://api.telegram.org";
+
+export class TelegramNotifier {
+  /**
+   * @param {object} options
+   * @param {string} options.token  - Bot token (from BotFather)
+   * @param {string} options.chatId - Chat/group/channel ID
+   */
+  constructor(options = {}) {
+    this.token = options.token || process.env.TELEGRAM_BOT_TOKEN || "";
+    this.chatId = options.chatId || process.env.TELEGRAM_CHAT_ID || "";
+  }
+
+  get isConfigured() {
+    return Boolean(this.token && this.chatId);
+  }
+
+  /**
+   * Send a raw text message (Markdown V2).
+   * @param {string} text
+   */
+  async send(text) {
+    if (!this.isConfigured) return { ok: false, reason: "not configured" };
+
+    try {
+      const res = await fetch(`${TELEGRAM_API}/bot${this.token}/sendMessage`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          chat_id: this.chatId,
+          text,
+          parse_mode: "HTML",
+        }),
+      });
+      const data = await res.json();
+      return { ok: data.ok, data };
+    } catch (err) {
+      return { ok: false, reason: err.message };
+    }
+  }
+
+  /**
+   * Notify that a task's CI pipeline passed.
+   * @param {object} summary
+   * @param {string} summary.taskId
+   * @param {string} summary.description   - Short task description
+   * @param {number} summary.agentCount    - How many agents worked on it
+   * @param {number} summary.duration      - Total ms
+   * @param {string[]} summary.filesChanged
+   */
+  async notifySuccess(summary) {
+    const {
+      taskId,
+      description,
+      agentCount = 1,
+      duration,
+      filesChanged = [],
+    } = summary;
+    const mins = duration ? Math.round(duration / 60_000) : "?";
+    const files = filesChanged.length
+      ? `\n📁 <b>Files:</b> ${filesChanged.slice(0, 5).join(", ")}${filesChanged.length > 5 ? ` +${filesChanged.length - 5} more` : ""}`
+      : "";
+
+    const text =
+      `✅ <b>CI Passed</b>\n` +
+      `📝 <b>Task:</b> ${_escape(description)}\n` +
+      `🤖 <b>Agents:</b> ${agentCount}  ⏱ <b>Time:</b> ${mins}m` +
+      files +
+      `\n🔑 <code>${taskId}</code>`;
+
+    return this.send(text);
+  }
+
+  /**
+   * Notify that CI failed and agents are being retried.
+   * @param {object} summary
+   * @param {string} summary.taskId
+   * @param {string} summary.description
+   * @param {string[]} summary.errors     - CI error messages
+   * @param {number} summary.retryNumber  - Which retry attempt
+   */
+  async notifyFailure(summary) {
+    const { taskId, description, errors = [], retryNumber = 1 } = summary;
+    const errPreview = errors
+      .slice(0, 3)
+      .map((e) => `  • ${_escape(e.slice(0, 120))}`)
+      .join("\n");
+
+    const text =
+      `❌ <b>CI Failed</b> (retry #${retryNumber})\n` +
+      `📝 <b>Task:</b> ${_escape(description)}\n` +
+      (errPreview ? `\n<b>Errors:</b>\n${errPreview}\n` : "") +
+      `🔄 Dispatching fix to agents…\n` +
+      `🔑 <code>${taskId}</code>`;
+
+    return this.send(text);
+  }
+
+  /**
+   * Notify that orchestration is starting.
+   * @param {object} summary
+   * @param {string} summary.taskId
+   * @param {string} summary.description
+   * @param {number} summary.subtaskCount
+   */
+  async notifyStart(summary) {
+    const { taskId, description, subtaskCount = 1 } = summary;
+    const text =
+      `🚀 <b>Orchestration Started</b>\n` +
+      `📝 <b>Task:</b> ${_escape(description)}\n` +
+      `🤖 <b>Subtasks:</b> ${subtaskCount}\n` +
+      `🔑 <code>${taskId}</code>`;
+    return this.send(text);
+  }
+}
+
+function _escape(str) {
+  return String(str)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}

package/src/lib/notifiers/websocket.js

@@ -0,0 +1,67 @@
+/**
+ * WebSocket Notifier — pushes orchestration events back over the active WS connection.
+ *
+ * When `cc orchestrate` is triggered via the WebSocket interface, notifications
+ * are sent to the originating client in real-time instead of (or in addition to)
+ * external channels.
+ *
+ * The caller passes a `sendFn` bound to the specific WS client:
+ *   const wsNotifier = new WebSocketNotifier({ send: (data) => _send(ws, data) });
+ */
+
+export class WebSocketNotifier {
+  /**
+   * @param {object} options
+   * @param {Function} options.send - (data: object) => void  — bound to one WS client
+   * @param {string}  [options.taskId] - correlate events to the originating request
+   */
+  constructor(options = {}) {
+    this._send = options.send || (() => {});
+    this.requestId = options.requestId || null;
+  }
+
+  get isConfigured() {
+    return typeof this._send === "function";
+  }
+
+  /** Send a typed orchestration event to the WebSocket client. */
+  send(event, payload = {}) {
+    this._send({
+      type: "orchestrate:event",
+      event,
+      requestId: this.requestId,
+      ...payload,
+      ts: Date.now(),
+    });
+  }
+
+  async notifyStart(summary) {
+    this.send("start", summary);
+    return { ok: true };
+  }
+
+  async notifySuccess(summary) {
+    this.send("ci:pass", summary);
+    return { ok: true };
+  }
+
+  async notifyFailure(summary) {
+    this.send("ci:fail", summary);
+    return { ok: true };
+  }
+
+  /** Forward real-time agent output chunk to the client. */
+  sendAgentOutput({ agentId, taskId, chunk }) {
+    this.send("agent:output", { agentId, taskId, chunk });
+  }
+
+  /** Forward task status update. */
+  sendStatus(task) {
+    this.send("task:status", {
+      taskId: task.id,
+      status: task.status,
+      retries: task.retries,
+      subtasks: task.subtasks?.length,
+    });
+  }
+}

package/src/lib/notifiers/wecom.js

@@ -0,0 +1,74 @@
+/**
+ * WeCom (企业微信) Notifier — sends notifications via 企业微信群机器人 Webhook.
+ *
+ * Configure via env:
+ *   WECOM_WEBHOOK_URL=https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx
+ * or options.webhookUrl
+ */
+
+export class WeComNotifier {
+  constructor(options = {}) {
+    this.webhookUrl = options.webhookUrl || process.env.WECOM_WEBHOOK_URL || "";
+  }
+
+  get isConfigured() {
+    return Boolean(this.webhookUrl);
+  }
+
+  /**
+   * Send a markdown message to the 企业微信 group bot.
+   * @param {string} content - Markdown content (企业微信 subset)
+   */
+  async send(content) {
+    if (!this.isConfigured) return { ok: false, reason: "not configured" };
+    try {
+      const res = await fetch(this.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          msgtype: "markdown",
+          markdown: { content },
+        }),
+      });
+      const data = await res.json();
+      return { ok: data.errcode === 0, data };
+    } catch (err) {
+      return { ok: false, reason: err.message };
+    }
+  }
+
+  async notifySuccess(summary) {
+    const { taskId, description, agentCount = 1, duration } = summary;
+    const mins = duration ? Math.round(duration / 60_000) : "?";
+    const content =
+      `## ✅ CI 通过\n` +
+      `**任务**: ${description.slice(0, 100)}\n` +
+      `**Agent 数**: ${agentCount}  **耗时**: ${mins}m\n` +
+      `**ID**: \`${taskId}\``;
+    return this.send(content);
+  }
+
+  async notifyFailure(summary) {
+    const { taskId, description, errors = [], retryNumber = 1 } = summary;
+    const errLines = errors
+      .slice(0, 3)
+      .map((e) => `> ${e.slice(0, 100)}`)
+      .join("\n");
+    const content =
+      `## ❌ CI 失败 (第 ${retryNumber} 次重试)\n` +
+      `**任务**: ${description.slice(0, 100)}\n` +
+      (errLines ? `**错误**:\n${errLines}\n` : "") +
+      `**ID**: \`${taskId}\``;
+    return this.send(content);
+  }
+
+  async notifyStart(summary) {
+    const { taskId, description, subtaskCount = 1 } = summary;
+    const content =
+      `## 🚀 开始编排\n` +
+      `**任务**: ${description.slice(0, 100)}\n` +
+      `**子任务**: ${subtaskCount}\n` +
+      `**ID**: \`${taskId}\``;
+    return this.send(content);
+  }
+}