@voko/lite 0.3.1

package/src/server/email-handler.js

@@ -0,0 +1,329 @@
+/**
+ * Email 渠道处理器
+ * 使用 IMAP (IDLE) 接收邮件，SMTP 发送邮件
+ *
+ * 用途：
+ * - 当 agent 需要主人介入时，通过 Email 通知主人
+ * - 主人回复后，将消息转发给对应 agent 的 session
+ */
+
+const { ImapFlow } = require('imapflow');
+const nodemailer = require('nodemailer');
+const PostalMime = require('postal-mime');
+
+class EmailHandler {
+  constructor(config, options = {}) {
+    // Email 配置存储
+    this.config = config;
+    this.ownerEmail = config.ownerEmail;
+    this.agentEmail = config.agentEmail;
+    this.authCode = config.authCode;
+
+    // 回调函数
+    this.onOwnerReply = options.onOwnerReply || null;
+    this.getInterventionByParentMsgId = options.getInterventionByParentMsgId || null;
+    this.getLatestPendingIntervention = options.getLatestPendingIntervention || null;
+    this.getPendingByAgentAndVisitor = options.getPendingByAgentAndVisitor || null;
+    this.isEnabled = options.isEnabled || (() => true);
+
+    // 状态
+    this.imapClient = null;
+    this.enabled = false;
+    this.pollTimer = null;
+    this._generation = 0;
+  }
+
+  async start() {
+    if (this.enabled) {
+      console.log('[Email] 已经启动');
+      return;
+    }
+
+    if (!this.config.smtp || !this.config.imap || !this.config.ownerEmail || !this.config.agentEmail) {
+      console.log('[Email] 配置不完整，跳过启动');
+      return;
+    }
+
+    this.enabled = true;
+    console.log('[Email] 启动 IMAP 监听...');
+    await this.startImapListener();
+
+    // 备用轮询：每 30 秒检查一次未读邮件（防止 IDLE 漏接）
+    this.pollTimer = setInterval(() => {
+      if (this.enabled && this.imapClient) {
+        this.checkUnreadEmails().catch(err => {
+          console.error('[Email] 轮询错误:', err.message);
+        });
+      }
+    }, 30000);
+  }
+
+  async startImapListener() {
+    try {
+      const imapConfig = this.config.imap;
+
+      this.imapClient = new ImapFlow({
+        host: imapConfig.host,
+        port: imapConfig.port,
+        secure: imapConfig.secure,
+        auth: {
+          user: imapConfig.auth.user,
+          pass: imapConfig.auth.pass
+        },
+        logger: false
+      });
+
+      await this.imapClient.connect();
+      console.log('[Email] IMAP 连接成功');
+
+      // 使用 select 方法选择收件箱
+      try {
+        await this.imapClient.mailbox.select('INBOX');
+      } catch (e) {
+        // 使用默认邮箱
+      }
+
+      // 监听新邮件事件（IDLE 模式）
+      this.imapClient.on('mail', (obj) => {
+        if (this.getLatestPendingIntervention) {
+          const pending = this.getLatestPendingIntervention();
+          if (!pending) return;
+        }
+        const messages = (obj && obj.messages) || [];
+        if (messages.length > 0) {
+          const latest = messages[messages.length - 1];
+          const seqNo = typeof latest === 'number' ? latest : (latest?.uid || latest?.seqNo);
+          if (seqNo) {
+            this.processOneEmail(seqNo).catch(err => {
+              console.error('[Email] 处理新邮件错误:', err.message);
+            });
+          }
+        }
+      });
+
+      // 监听连接错误和关闭，自动重连
+      this.imapClient.on('error', (err) => {
+        console.error('[Email] IMAP 连接错误:', err.message);
+      });
+
+      const gen = this._generation;
+      this.imapClient.on('close', () => {
+        console.log('[Email] IMAP 连接已关闭');
+        // 用代数标记避免旧 close 事件覆盖新连接
+        if (gen !== this._generation) return;
+        this.imapClient = null;
+        if (this.enabled) {
+          setTimeout(() => {
+            if (gen !== this._generation) return;
+            if (this.enabled) {
+              this.startImapListener().catch(err => {
+                console.error('[Email] 重连失败:', err.message);
+              });
+            }
+          }, 5000);
+        }
+      });
+
+      // 初始检查未读邮件
+      await this.checkUnreadEmails();
+
+    } catch (err) {
+      console.error('[Email] IMAP 连接失败:', err.message);
+      this.enabled = false;
+    }
+  }
+
+  async checkUnreadEmails() {
+    if (!this.imapClient) return;
+
+    // 如果没有 pending 记录，跳过检查
+    if (this.getLatestPendingIntervention) {
+      const pending = this.getLatestPendingIntervention();
+      if (!pending) return;
+    }
+
+    try {
+      const lock = await this.imapClient.getMailboxLock('INBOX');
+      try {
+        // search 返回 Array<sequenceNumber>，升序排列（旧→新）
+        const seqNumbers = await this.imapClient.search({ seen: false });
+        // 只取最近 100 封（最新），倒序从最新开始查
+        const recentSeqNos = seqNumbers.slice(-100).reverse();
+
+        // 从最新到最旧，逐封检查 VOKO 邮件，找到第一个就处理并停止
+        for (const seqNo of recentSeqNos) {
+          const found = await this.processOneEmail(seqNo);
+          if (found) break;
+        }
+      } finally {
+        if (lock && typeof lock.release === 'function') {
+          lock.release();
+        }
+      }
+    } catch (err) {
+      console.error('[Email] 检查未读邮件错误:', err.message);
+    }
+  }
+
+  async processOneEmail(seqNo) {
+    if (!this.enabled || !this.imapClient) return false;
+
+    try {
+      const raw = await this.imapClient.fetchOne(seqNo, { source: true });
+      if (!raw || !raw.source) {
+        return false;
+      }
+
+      const parser = new PostalMime();
+      const parsed = await parser.parse(raw.source);
+
+      // 只处理 VOKO 干预邮件
+      if (!parsed.subject || !parsed.subject.includes('[VOKO]')) {
+        return false;
+      }
+
+      const fullContent = parsed.text || parsed.html || '';
+
+      // 只取回复部分（分隔符之前），去掉原邮件引用
+      const separator = '---- 回复的原邮件 ----';
+      let content = fullContent;
+      const sepIdx = fullContent.indexOf(separator);
+      if (sepIdx > 0) {
+        content = fullContent.substring(0, sepIdx).trim();
+      }
+
+      // 从标题提取 clientId（格式: [VOKO] xxx [msg_xxx]）
+      const match = parsed.subject.match(/\[VOKO\].*\[(msg_\S+)\]/);
+      if (!match) {
+        console.log('[Email] 标题无追踪 ID，跳过:', parsed.subject);
+        return false;
+      }
+      const msgId = match[1].trim();
+
+      console.log('[Email] 收到干预回复, msgId:', msgId, 'content:', content.substring(0, 100));
+
+      if (this.getInterventionByParentMsgId) {
+        const intervention = this.getInterventionByParentMsgId(msgId);
+        if (intervention) {
+          console.log('[Email] 匹配到干预记录:', intervention.id);
+          if (this.onOwnerReply) {
+            this.onOwnerReply(intervention, content, parsed.messageId);
+          }
+          // 处理成功后标记为已读
+          try {
+            await this.imapClient.messageFlagsAdd(seqNo, ['\\Seen']);
+          } catch (e) {
+            console.error('[Email] 标记已读失败:', e.message);
+          }
+          return true;
+        }
+      }
+      return false;
+    } catch (err) {
+      console.error('[Email] 处理邮件错误:', err.message);
+      return false;
+    }
+  }
+
+  async processNewEmails(events) {
+    if (!this.enabled || !events || !Array.isArray(events)) return;
+    for (const seqNo of events) {
+      await this.processOneEmail(seqNo);
+    }
+  }
+
+  async handleReply(messageId, content, replyMessageId) {
+    // 1. 精确匹配 messageId → parent_message_id
+    if (this.getInterventionByParentMsgId) {
+      const intervention = this.getInterventionByParentMsgId(messageId);
+      if (intervention) {
+        console.log('[Email] 精确匹配到干预记录:', intervention.id);
+        if (this.onOwnerReply) {
+          this.onOwnerReply(intervention, content, replyMessageId);
+        }
+        return true;
+      }
+    }
+
+    // 2. Fallback 已禁用，只保留精确匹配
+    return false;
+    // }
+  }
+
+  /**
+   * 发送邮件给主人（带记录，用于后续匹配）
+   */
+  async sendMessageToOwnerWithTracking(content, visitorId, sessionKey, agentId) {
+    const clientId = `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const subject = agentId
+      ? `[VOKO] ${agentId}的访客${visitorId}的问题需答复 [${clientId}]`
+      : `[VOKO] 访客${visitorId}的问题需答复 [${clientId}]`;
+
+    // 构造邮件正文（content 已包含全部格式化信息）
+    let body = content;
+
+    if (visitorId.startsWith('system_test:')) {
+      body += `\n（这是一条来自 voko 的测试消息）`;
+    }
+
+    return new Promise((resolve, reject) => {
+      const smtpConfig = this.config.smtp;
+
+      const transporter = nodemailer.createTransport({
+        host: smtpConfig.host,
+        port: smtpConfig.port,
+        secure: smtpConfig.secure,
+        auth: {
+          user: smtpConfig.auth.user,
+          pass: smtpConfig.auth.pass
+        }
+      });
+
+      transporter.sendMail({
+        from: this.agentEmail,
+        to: this.ownerEmail,
+        subject,
+        text: body
+      }, (err, info) => {
+        if (err) {
+          console.error('[Email] 发送邮件失败:', err.message);
+          reject(err);
+        } else {
+          console.log('[Email] 邮件发送成功, messageId:', clientId);
+          resolve({ messageId: clientId, sentMessageId: clientId });
+        }
+      });
+    });
+  }
+
+  stop() {
+    this.enabled = false;
+    this._generation++; // 代数递增，使旧 close 回调失效
+    if (this.imapClient) {
+      const client = this.imapClient;
+      this.imapClient = null;
+      if (client.close && typeof client.close.then === 'function') {
+        client.close().catch(err => {
+          if (err.message !== 'Connection closed') {
+            console.error('[Email] 关闭 IMAP 连接错误:', err.message);
+          }
+        });
+      }
+    }
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    console.log('[Email] 已停止');
+  }
+
+  updateConfig(config) {
+    if (config.ownerEmail) this.ownerEmail = config.ownerEmail;
+    if (config.agentEmail) this.agentEmail = config.agentEmail;
+    if (config.authCode) this.authCode = config.authCode;
+    if (config.smtp) this.config.smtp = config.smtp;
+    if (config.imap) this.config.imap = config.imap;
+  }
+}
+
+module.exports = EmailHandler;

package/src/server/feishu-handler.js

@@ -0,0 +1,249 @@
+/**
+ * VOKO Desktop - 飞书消息处理器
+ * 通过轮询接收飞书消息事件
+ *
+ * 用途：
+ * - 当 agent 需要主人介入时，通过飞书通知主人
+ * - 主人回复后，将消息转发给对应 agent 的 session
+ */
+
+const { Client } = require('@larksuiteoapi/node-sdk');
+
+class FeishuHandler {
+  constructor(config, options = {}) {
+    this.appId = config.appId;
+    this.appSecret = config.appSecret;
+    this.ownerOpenId = config.ownerOpenId;
+
+    this.onOwnerReply = options.onOwnerReply;
+    this.getInterventionByParentMsgId = options.getInterventionByParentMsgId || null;
+    this.getLatestPendingIntervention = options.getLatestPendingIntervention || null;
+
+    this.pollInterval = config.pollInterval || 5000;
+    this._replyPollTimer = null;
+    this._ownerChatId = null;
+
+    this.larkClient = null;
+    this.enabled = false;
+  }
+
+  async start() {
+    if (this.enabled) {
+      console.log('[Feishu] 已经启动');
+      return;
+    }
+
+    try {
+      // 禁用 axios 自动检测系统代理（飞书 API 直连可达）
+      process.env.NO_PROXY = process.env.NO_PROXY ? process.env.NO_PROXY + ',open.feishu.cn' : 'open.feishu.cn';
+
+      this.larkClient = new Client({
+        appId: this.appId,
+        appSecret: this.appSecret,
+        domain: 'https://open.feishu.cn'
+      });
+
+      this.enabled = true;
+      console.log('[Feishu] 启动回复轮询...');
+      this.startReplyPolling();
+      console.log('[Feishu] ✅ 飞书处理器已启动');
+    } catch (err) {
+      console.error('[Feishu] 启动失败:', err.message);
+      this.enabled = false;
+      throw err;
+    }
+  }
+
+  stop() {
+    this.larkClient = null;
+    this.enabled = false;
+    this.stopReplyPolling();
+    console.log('[Feishu] 已停止');
+  }
+
+  // ============ 回复轮询 ============
+
+  startReplyPolling() {
+    this.stopReplyPolling();
+    this._replyPollTimer = setInterval(async () => {
+      await this.checkForReplies();
+    }, this.pollInterval);
+    console.log('[Feishu] 回复轮询已启动，间隔', this.pollInterval, 'ms');
+  }
+
+  stopReplyPolling() {
+    if (this._replyPollTimer) {
+      clearInterval(this._replyPollTimer);
+      this._replyPollTimer = null;
+    }
+  }
+
+  async checkForReplies() {
+    if (!this.enabled || !this.getInterventionByParentMsgId || !this.onOwnerReply) return;
+
+    try {
+      const https = require('https');
+      const token = await this._getTenantAccessToken();
+      if (!token) return;
+
+      let chatId = this._ownerChatId;
+      if (!chatId) {
+        const pending = this.getLatestPendingIntervention ? this.getLatestPendingIntervention() : null;
+        if (pending && pending.parentMessageId) {
+          const msgInfo = await new Promise((resolve) => {
+            const req = https.get(`https://open.feishu.cn/open-apis/im/v1/messages/${pending.parentMessageId}`, {
+              headers: { Authorization: `Bearer ${token}` }
+            }, (res) => {
+              let d = '';
+              res.on('data', c => d += c);
+              res.on('end', () => { try { resolve(JSON.parse(d)); } catch(e) { resolve(null); } });
+            });
+            req.on('error', () => resolve(null));
+            req.end();
+          });
+          if (msgInfo?.data?.items?.[0]?.chat_id) {
+            chatId = msgInfo.data.items[0].chat_id;
+            this._ownerChatId = chatId;
+          }
+        }
+        if (!chatId) return;
+      }
+
+      const pending = this.getLatestPendingIntervention ? this.getLatestPendingIntervention() : null;
+      if (!pending) return;
+
+      const result = await new Promise((resolve, reject) => {
+        const req = https.get(`https://open.feishu.cn/open-apis/im/v1/messages?container_id_type=chat&container_id=${chatId}&page_size=20&sort_type=ByCreateTimeDesc`, {
+          headers: { Authorization: `Bearer ${token}` }
+        }, (res) => {
+          let data = '';
+          res.on('data', chunk => data += chunk);
+          res.on('end', () => { try { resolve(JSON.parse(data)); } catch(e) { resolve(null); } });
+        });
+        req.on('error', reject);
+        req.end();
+      });
+
+      if (!result?.data?.items) return;
+
+      for (const msg of result.data.items) {
+        if (!msg.parent_id) continue;
+        if (msg.sender?.id !== this.ownerOpenId) continue;
+
+        const intervention = this.getInterventionByParentMsgId(msg.parent_id);
+        if (!intervention) continue;
+
+        const body = JSON.parse(msg.body?.content || '{}');
+        const content = body.text || '';
+        console.log('[Feishu] 轮询匹配到主人回复:', { parentId: msg.parent_id, content: content?.substring(0, 50) });
+        this.onOwnerReply(intervention, content, msg.message_id);
+        break;
+      }
+    } catch (err) {
+      console.error('[Feishu] 回复轮询错误:', err.message);
+    }
+  }
+
+  async _getTenantAccessToken() {
+    try {
+      const https = require('https');
+      const data = JSON.stringify({ app_id: this.appId, app_secret: this.appSecret });
+      return await new Promise((resolve) => {
+        const req = https.request('https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) }
+        }, (res) => {
+          let body = '';
+          res.on('data', chunk => body += chunk);
+          res.on('end', () => { try { resolve(JSON.parse(body).tenant_access_token); } catch(e) { resolve(null); } });
+        });
+        req.on('error', () => resolve(null));
+        req.write(data);
+        req.end();
+      });
+    } catch { return null; }
+  }
+
+  // ============ 发送消息 ============
+
+  async sendMessageToOwnerWithTracking(content, visitorId, sessionKey, testId) {
+    if (!this.larkClient) {
+      throw new Error('Feishu client not initialized');
+    }
+
+    try {
+      const response = await this.larkClient.im.v1.message.create({
+        params: { receive_id_type: 'open_id' },
+        data: {
+          receive_id: this.ownerOpenId,
+          content: JSON.stringify({ text: content }),
+          msg_type: 'text'
+        }
+      });
+
+      const sentMessageId = response?.data?.message_id || response?.message_id || `sent-${Date.now()}`;
+      const chatId = response?.data?.chat_id;
+      if (chatId) this._ownerChatId = chatId;
+
+      console.log('[Feishu] 发送消息给主人成功:', { sentMessageId, visitorId, sessionKey });
+
+      return { messageId: sentMessageId, sentMessageId };
+    } catch (err) {
+      console.error('[Feishu] 发送消息失败:', err.message);
+      throw err;
+    }
+  }
+
+  async sendMessageToOwner(content) {
+    if (!this.larkClient) {
+      throw new Error('Feishu client not initialized');
+    }
+
+    try {
+      const response = await this.larkClient.im.v1.message.create({
+        params: { receive_id_type: 'open_id' },
+        data: {
+          receive_id: this.ownerOpenId,
+          content: JSON.stringify({ text: content }),
+          msg_type: 'text'
+        }
+      });
+
+      console.log('[Feishu] 发送消息给主人成功');
+      return response;
+    } catch (err) {
+      console.error('[Feishu] 发送消息失败:', err.message);
+      throw err;
+    }
+  }
+
+  async replyToOwnerWithParentId(sentMessageId, content) {
+    if (!this.larkClient) {
+      throw new Error('Feishu client not initialized');
+    }
+
+    try {
+      const response = await this.larkClient.im.v1.message.create({
+        params: { receive_id_type: 'open_id' },
+        data: {
+          receive_id: this.ownerOpenId,
+          content: JSON.stringify({ text: content }),
+          msg_type: 'text',
+          reply_to_message_id: sentMessageId
+        }
+      });
+
+      const messageId = response?.data?.message_id || response?.message_id || `reply-${Date.now()}`;
+      console.log('[Feishu] 回复主人成功:', messageId, 'parent:', sentMessageId);
+
+      return { messageId, sentMessageId };
+    } catch (err) {
+      console.error('[Feishu] 回复主人失败:', err.message);
+      throw err;
+    }
+  }
+
+  getOwnerOpenId() { /* removed - unused */ }
+}
+
+module.exports = FeishuHandler;