cfix 1.0.0

package/src/websocket/notifier.js

@@ -0,0 +1,363 @@
+const WebSocket = require('ws');
+const { logger } = require('../logger');
+const EventEmitter = require('events');
+
+/**
+ * WebSocket 通知服务
+ * 支持任务状态实时推送
+ */
+class WebSocketNotifier extends EventEmitter {
+  constructor() {
+    super();
+    this.wss = null;
+    this.clients = new Map(); // taskId -> Set<ws>
+    this.heartbeatInterval = null;
+  }
+
+  /**
+   * 初始化 WebSocket 服务器
+   * @param {Object} server - HTTP 服务器实例
+   */
+  initialize(server) {
+    this.wss = new WebSocket.Server({
+      server,
+      path: '/ws',
+      verifyClient: (info, callback) => {
+        // 可选：验证客户端连接
+        const apiKey = new URL(info.req.url, 'ws://localhost').searchParams.get('apiKey');
+
+        // 如果配置了 API_KEY，则验证
+        if (process.env.API_KEY && apiKey !== process.env.API_KEY) {
+          callback(false, 401, 'Unauthorized');
+          return;
+        }
+
+        callback(true);
+      }
+    });
+
+    this.wss.on('connection', (ws, req) => {
+      this.handleConnection(ws, req);
+    });
+
+    // 启动心跳检测
+    this.startHeartbeat();
+
+    logger.info('✅ WebSocket 服务已启动: /ws');
+  }
+
+  /**
+   * 处理客户端连接
+   */
+  handleConnection(ws, req) {
+    const url = new URL(req.url, 'ws://localhost');
+    const taskId = url.searchParams.get('taskId');
+    const clientId = Math.random().toString(36).substr(2, 9);
+
+    ws.isAlive = true;
+    ws.clientId = clientId;
+    ws.subscribedTasks = new Set();
+
+    logger.info(`WebSocket 客户端已连接: ${clientId}`, { taskId });
+
+    // 如果指定了 taskId，自动订阅
+    if (taskId) {
+      this.subscribe(ws, taskId);
+    }
+
+    // 发送欢迎消息
+    this.send(ws, {
+      type: 'connected',
+      clientId,
+      timestamp: new Date().toISOString(),
+    });
+
+    // 心跳响应
+    ws.on('pong', () => {
+      ws.isAlive = true;
+    });
+
+    // 处理客户端消息
+    ws.on('message', (message) => {
+      this.handleMessage(ws, message);
+    });
+
+    // 处理断开连接
+    ws.on('close', () => {
+      this.handleDisconnect(ws);
+    });
+
+    // 处理错误
+    ws.on('error', (error) => {
+      logger.error(`WebSocket 客户端错误: ${clientId}`, error);
+    });
+  }
+
+  /**
+   * 处理客户端消息
+   */
+  handleMessage(ws, message) {
+    try {
+      const data = JSON.parse(message);
+
+      switch (data.type) {
+        case 'subscribe':
+          // 订阅任务
+          if (data.taskId) {
+            this.subscribe(ws, data.taskId);
+            this.send(ws, {
+              type: 'subscribed',
+              taskId: data.taskId,
+              timestamp: new Date().toISOString(),
+            });
+          }
+          break;
+
+        case 'unsubscribe':
+          // 取消订阅任务
+          if (data.taskId) {
+            this.unsubscribe(ws, data.taskId);
+            this.send(ws, {
+              type: 'unsubscribed',
+              taskId: data.taskId,
+              timestamp: new Date().toISOString(),
+            });
+          }
+          break;
+
+        case 'ping':
+          // 心跳
+          this.send(ws, {
+            type: 'pong',
+            timestamp: new Date().toISOString(),
+          });
+          break;
+
+        default:
+          logger.warn(`未知的消息类型: ${data.type}`);
+      }
+    } catch (error) {
+      logger.error('处理 WebSocket 消息失败:', error);
+    }
+  }
+
+  /**
+   * 订阅任务
+   */
+  subscribe(ws, taskId) {
+    if (!this.clients.has(taskId)) {
+      this.clients.set(taskId, new Set());
+    }
+
+    this.clients.get(taskId).add(ws);
+    ws.subscribedTasks.add(taskId);
+
+    logger.debug(`客户端 ${ws.clientId} 订阅任务: ${taskId}`);
+  }
+
+  /**
+   * 取消订阅任务
+   */
+  unsubscribe(ws, taskId) {
+    if (this.clients.has(taskId)) {
+      this.clients.get(taskId).delete(ws);
+
+      // 如果没有订阅者，删除任务记录
+      if (this.clients.get(taskId).size === 0) {
+        this.clients.delete(taskId);
+      }
+    }
+
+    ws.subscribedTasks.delete(taskId);
+
+    logger.debug(`客户端 ${ws.clientId} 取消订阅任务: ${taskId}`);
+  }
+
+  /**
+   * 处理客户端断开
+   */
+  handleDisconnect(ws) {
+    // 取消所有订阅
+    ws.subscribedTasks.forEach(taskId => {
+      this.unsubscribe(ws, taskId);
+    });
+
+    logger.info(`WebSocket 客户端已断开: ${ws.clientId}`);
+  }
+
+  /**
+   * 发送消息到客户端
+   */
+  send(ws, data) {
+    if (ws.readyState === WebSocket.OPEN) {
+      try {
+        ws.send(JSON.stringify(data));
+      } catch (error) {
+        logger.error('发送 WebSocket 消息失败:', error);
+      }
+    }
+  }
+
+  /**
+   * 广播消息到所有订阅者
+   */
+  broadcast(taskId, data) {
+    const clients = this.clients.get(taskId);
+
+    if (!clients || clients.size === 0) {
+      return;
+    }
+
+    const message = {
+      ...data,
+      taskId,
+      timestamp: new Date().toISOString(),
+    };
+
+    clients.forEach(ws => {
+      this.send(ws, message);
+    });
+
+    logger.debug(`广播消息到 ${clients.size} 个订阅者`, { taskId, type: data.type });
+  }
+
+  /**
+   * 通知任务状态变更
+   */
+  notifyTaskStatus(taskId, status, data = {}) {
+    this.broadcast(taskId, {
+      type: 'task_status',
+      status,
+      ...data,
+    });
+  }
+
+  /**
+   * 通知任务进度
+   */
+  notifyTaskProgress(taskId, step, message, percent = null) {
+    this.broadcast(taskId, {
+      type: 'task_progress',
+      step,
+      message,
+      percent,
+    });
+  }
+
+  /**
+   * 通知任务完成
+   */
+  notifyTaskComplete(taskId, result) {
+    this.broadcast(taskId, {
+      type: 'task_complete',
+      result,
+    });
+  }
+
+  /**
+   * 通知任务失败
+   */
+  notifyTaskFailed(taskId, error) {
+    this.broadcast(taskId, {
+      type: 'task_failed',
+      error: error.message || String(error),
+    });
+  }
+
+  /**
+   * 通知队列状态
+   */
+  notifyQueueStats(stats) {
+    // 广播到所有连接的客户端
+    if (!this.wss) return;
+
+    this.wss.clients.forEach(ws => {
+      if (ws.readyState === WebSocket.OPEN) {
+        this.send(ws, {
+          type: 'queue_stats',
+          stats,
+          timestamp: new Date().toISOString(),
+        });
+      }
+    });
+  }
+
+  /**
+   * 启动心跳检测
+   */
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      if (!this.wss) return;
+
+      this.wss.clients.forEach(ws => {
+        if (ws.isAlive === false) {
+          logger.warn(`客户端心跳超时，断开连接: ${ws.clientId}`);
+          return ws.terminate();
+        }
+
+        ws.isAlive = false;
+        ws.ping();
+      });
+    }, 30000); // 30 秒心跳
+
+    logger.debug('WebSocket 心跳检测已启动');
+  }
+
+  /**
+   * 停止心跳检测
+   */
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+      logger.debug('WebSocket 心跳检测已停止');
+    }
+  }
+
+  /**
+   * 获取统计信息
+   */
+  getStats() {
+    if (!this.wss) {
+      return {
+        enabled: false,
+      };
+    }
+
+    return {
+      enabled: true,
+      totalClients: this.wss.clients.size,
+      subscribedTasks: this.clients.size,
+      subscriptions: Array.from(this.clients.entries()).map(([taskId, clients]) => ({
+        taskId,
+        subscribers: clients.size,
+      })),
+    };
+  }
+
+  /**
+   * 关闭 WebSocket 服务器
+   */
+  close() {
+    this.stopHeartbeat();
+
+    if (this.wss) {
+      this.wss.clients.forEach(ws => {
+        this.send(ws, {
+          type: 'server_shutdown',
+          message: '服务器正在关闭',
+          timestamp: new Date().toISOString(),
+        });
+        ws.close();
+      });
+
+      this.wss.close(() => {
+        logger.info('WebSocket 服务器已关闭');
+      });
+    }
+
+    this.clients.clear();
+  }
+}
+
+module.exports = new WebSocketNotifier();

package/src/wechat-notifier.js

@@ -0,0 +1,97 @@
+const axios = require('axios');
+const { logger } = require('./logger');
+
+/**
+ * 企业微信通知服务
+ */
+class WeChatNotifier {
+  constructor(webhookUrl) {
+    this.webhookUrl = webhookUrl;
+    this.enabled = !!webhookUrl;
+  }
+
+  /**
+   * 发送 Markdown 消息到企业微信
+   * @param {string} content - Markdown 格式的消息内容
+   */
+  async sendMarkdown(content) {
+    if (!this.enabled) {
+      logger.info('企业微信通知未配置，跳过发送');
+      return;
+    }
+
+    try {
+      const response = await axios.post(this.webhookUrl, {
+        msgtype: 'markdown',
+        markdown: {
+          content
+        }
+      });
+
+      if (response.data.errcode === 0) {
+        logger.info('✅ 企业微信通知发送成功');
+      } else {
+        logger.error('❌ 企业微信通知发送失败:', response.data);
+      }
+    } catch (error) {
+      logger.error('❌ 企业微信通知发送异常:', error.message);
+    }
+  }
+
+  /**
+   * 发送任务开始通知
+   */
+  async notifyTaskStart(projectName, requirement) {
+    const content = `## 🚀 自动修复任务已启动
+
+**项目名称**: ${projectName}
+**任务描述**: ${requirement}
+**状态**: 进行中...
+**时间**: ${new Date().toLocaleString('zh-CN')}`;
+
+    await this.sendMarkdown(content);
+  }
+
+  /**
+   * 发送任务成功通知
+   */
+  async notifyTaskSuccess(projectName, branchName, changedFiles, summary) {
+    const filesText = changedFiles.length > 0
+      ? changedFiles.map(f => `- ${f}`).join('\n')
+      : '无文件修改';
+
+    const content = `## ✅ 自动修复任务完成
+
+**项目名称**: ${projectName}
+**分支**: \`${branchName}\`
+**修改文件数**: ${changedFiles.length}
+
+### 修改的文件
+${filesText}
+
+### 修改说明
+${summary}
+
+**完成时间**: ${new Date().toLocaleString('zh-CN')}`;
+
+    await this.sendMarkdown(content);
+  }
+
+  /**
+   * 发送任务失败通知
+   */
+  async notifyTaskFailure(projectName, requirement, error) {
+    const content = `## ❌ 自动修复任务失败
+
+**项目名称**: ${projectName}
+**任务描述**: ${requirement}
+**错误信息**: ${error}
+**失败时间**: ${new Date().toLocaleString('zh-CN')}
+
+请检查日志并手动处理。`;
+
+    await this.sendMarkdown(content);
+  }
+}
+
+module.exports = WeChatNotifier;