iflow-feishu 1.0.8 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iflow-feishu",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "iFlow CLI 飞书插件 - 将 iFlow AI 助手接入飞书机器人",
   "main": "src/index.js",
   "bin": {

package/src/core/feishu-client.js

@@ -5,6 +5,8 @@
 const http = require('http');
 const https = require('https');
 const { URL } = require('url');
+const fs = require('fs');
+const path = require('path');
 const { logger } = require('../utils/logger');
 
 class FeishuClient {
@@ -194,6 +196,181 @@ class FeishuClient {
       return false;
     }
   }
+
+  /**
+   * 上传文件到飞书
+   * @param {string} filePath - 本地文件路径
+   * @returns {Promise<string|null>} - 返回 file_key 或 null
+   */
+  async uploadFile(filePath) {
+    try {
+      const token = await this.getToken();
+      
+      // 检查文件是否存在
+      if (!fs.existsSync(filePath)) {
+        logger.error('❌ 文件不存在:', filePath);
+        return null;
+      }
+      
+      // 读取文件
+      const fileBuffer = fs.readFileSync(filePath);
+      const fileName = path.basename(filePath);
+      
+      // 生成 boundary
+      const boundary = `----iFlowBoundary${Date.now()}`;
+      
+      // 构建 multipart/form-data body
+      const parts = [];
+      
+      // 文件类型字段
+      parts.push(`--${boundary}\r\n`);
+      parts.push(`Content-Disposition: form-data; name="file_type"\r\n\r\n`);
+      parts.push(`stream\r\n`);
+      
+      // 文件名字段
+      parts.push(`--${boundary}\r\n`);
+      parts.push(`Content-Disposition: form-data; name="file_name"\r\n\r\n`);
+      parts.push(`${fileName}\r\n`);
+      
+      // 文件内容
+      parts.push(`--${boundary}\r\n`);
+      parts.push(`Content-Disposition: form-data; name="file"; filename="${fileName}"\r\n`);
+      parts.push(`Content-Type: application/octet-stream\r\n\r\n`);
+      
+      const bodyParts = Buffer.concat([
+        Buffer.from(parts.join(''), 'utf8'),
+        fileBuffer,
+        Buffer.from(`\r\n--${boundary}--\r\n`, 'utf8')
+      ]);
+      
+      logger.info(`📤 正在上传文件: ${fileName} (${(fileBuffer.length / 1024).toFixed(2)} KB)`);
+      
+      // 发送请求
+      const result = await this.httpRequestMultipart(
+        'https://open.feishu.cn/open-apis/im/v1/files',
+        {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': `multipart/form-data; boundary=${boundary}`,
+            'Content-Length': bodyParts.length
+          }
+        },
+        bodyParts
+      );
+      
+      if (result.ok && result.data?.data?.file_key) {
+        logger.info('✅ 文件上传成功, file_key:', result.data.data.file_key);
+        return result.data.data.file_key;
+      }
+      
+      logger.error('❌ 文件上传失败:', JSON.stringify(result.data));
+      return null;
+    } catch (err) {
+      logger.error('上传文件错误:', err.message);
+      return null;
+    }
+  }
+
+  /**
+   * 发送 multipart/form-data 请求
+   */
+  async httpRequestMultipart(url, options, body) {
+    return new Promise((resolve, reject) => {
+      const u = new URL(url);
+      
+      const req = https.request({
+        hostname: u.hostname,
+        port: u.port || 443,
+        path: u.pathname + u.search,
+        method: options.method || 'POST',
+        headers: options.headers || {},
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            resolve({
+              ok: res.statusCode >= 200 && res.statusCode < 300,
+              data: JSON.parse(data),
+              status: res.statusCode
+            });
+          } catch {
+            resolve({
+              ok: res.statusCode >= 200 && res.statusCode < 300,
+              data,
+              status: res.statusCode
+            });
+          }
+        });
+      });
+      
+      req.on('error', reject);
+      req.setTimeout(60000, () => {  // 文件上传超时时间更长
+        req.destroy();
+        reject(new Error('Upload timeout'));
+      });
+      
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+
+  /**
+   * 发送文件消息
+   * @param {string} chatId - 群聊 ID
+   * @param {string} fileKey - 文件 key（由 uploadFile 返回）
+   * @param {string} fileName - 文件名（可选，用于日志）
+   * @returns {Promise<boolean>} - 发送是否成功
+   */
+  async sendFileMessage(chatId, fileKey, fileName = '') {
+    try {
+      const token = await this.getToken();
+      
+      const r = await this.httpRequest(
+        'https://open.feishu.cn/open-apis/im/v1/messages?receive_id_type=chat_id',
+        {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json'
+          },
+        },
+        JSON.stringify({
+          receive_id: chatId,
+          msg_type: 'file',
+          content: JSON.stringify({ file_key: fileKey })
+        })
+      );
+      
+      if (r.ok && r.data?.data?.message_id) {
+        logger.info(`📤 文件消息已发送: ${fileName || fileKey}`);
+        return true;
+      }
+      
+      logger.error('❌ 发送文件消息失败:', JSON.stringify(r.data));
+      return false;
+    } catch (err) {
+      logger.error('发送文件消息错误:', err.message);
+      return false;
+    }
+  }
+
+  /**
+   * 上传并发送文件（便捷方法）
+   * @param {string} chatId - 群聊 ID
+   * @param {string} filePath - 本地文件路径
+   * @returns {Promise<boolean>} - 发送是否成功
+   */
+  async sendFile(chatId, filePath) {
+    const fileKey = await this.uploadFile(filePath);
+    if (!fileKey) {
+      return false;
+    }
+    
+    const fileName = path.basename(filePath);
+    return await this.sendFileMessage(chatId, fileKey, fileName);
+  }
 }
 
 module.exports = { FeishuClient };

package/src/core/http-server.js

@@ -46,6 +46,12 @@ class HTTPServer {
       return;
     }
     
+    // 发送文件 API
+    if (url.pathname === '/send-file' && req.method === 'POST') {
+      await this.handleSendFile(req, res);
+      return;
+    }
+    
     // 404
     res.writeHead(404);
     res.end('Not Found');
@@ -101,6 +107,48 @@ class HTTPServer {
     });
   }
 
+  /**
+   * 处理发送文件请求
+   */
+  async handleSendFile(req, res) {
+    let body = '';
+    
+    req.on('data', chunk => body += chunk);
+    
+    req.on('end', async () => {
+      try {
+        const data = JSON.parse(body);
+        const { chatId, filePath, message } = data;
+        
+        // 验证必需参数
+        if (!chatId || !filePath) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ code: 400, msg: '缺少必需参数: chatId 或 filePath' }));
+          return;
+        }
+        
+        logger.info(`发送文件请求: chatId=${chatId}, filePath=${filePath}`);
+        
+        // 如果有消息，先发送文字消息
+        if (message) {
+          await this.service.feishuClient.sendMessage(chatId, message);
+          logger.info(`文字消息已发送: ${message}`);
+        }
+        
+        // 上传并发送文件
+        const result = await this.service.feishuClient.sendFile(chatId, filePath);
+        logger.info(`文件发送成功: ${JSON.stringify(result)}`);
+        
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ code: 0, msg: 'success', data: result }));
+      } catch (err) {
+        logger.error(`发送文件错误: ${err.message}`);
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ code: 500, msg: err.message }));
+      }
+    });
+  }
+
   /**
    * 关闭服务器
    */

package/src/core/service.js

@@ -287,6 +287,7 @@ class FeishuService {
           
           // 提取响应
           const extracted = this.streamHandler.extractResponse(stdoutSoFar, chatId, modelName);
+          // 内容变化会自动触发卡片更新，无需显式调用 update()
           updater.setReasoning(extracted.reasoning);
           updater.setContent(extracted.content || '');
           
@@ -294,8 +295,6 @@ class FeishuService {
           const currentLength = (stdoutSoFar || '').length;
           const percent = this.messageProcessor.calculateContentLeftPercent(chatId, currentLength, modelName);
           updater.setPercent(percent);
-          
-          updater.update();
         },
         { mode: 'default', thinking: false }
       );

package/src/core/stream-handler.js

@@ -155,6 +155,7 @@ class StreamHandler {
 
   /**
    * 创建卡片更新器
+   * 优化：只在内容变化时才调用API，计时变化不单独触发更新
    */
   createCardUpdater(cardId, startTime, modelName, initialPercent) {
     let lastUpdate = 0;
@@ -167,6 +168,9 @@ class StreamHandler {
     let isCompleted = false;
     let thinkingStartTime = null;
     let thinkingEndTime = null;
+    let lastReasoning = '';
+    let lastContent = '';
+    let pendingUpdate = false;
     
     const update = async (force = false) => {
       if (!cardId || isCompleted) return;
@@ -175,6 +179,9 @@ class StreamHandler {
       if (!force && now - lastUpdate < CARD_UPDATE_INTERVAL) return;
       
       lastUpdate = now;
+      lastReasoning = currentReasoning;
+      lastContent = currentContent;
+      pendingUpdate = false;
       
       const elapsed = isStreamEnded && streamEndTime 
         ? streamEndTime - startTime 
@@ -198,10 +205,30 @@ class StreamHandler {
       }
     };
     
+    // 检查内容是否有变化
+    const hasContentChanged = () => {
+      return currentReasoning !== lastReasoning || currentContent !== lastContent;
+    };
+    
+    // 内容变化时触发更新
+    const triggerUpdate = () => {
+      if (hasContentChanged() && !pendingUpdate) {
+        pendingUpdate = true;
+        update();
+      }
+    };
+    
     return {
       update,
-      setReasoning: (r) => { currentReasoning = r; },
-      setContent: (c) => { currentContent = c; },
+      triggerUpdate,
+      setReasoning: (r) => { 
+        currentReasoning = r; 
+        triggerUpdate();
+      },
+      setContent: (c) => { 
+        currentContent = c; 
+        triggerUpdate();
+      },
       setPercent: (p) => { currentPercent = p; },
       setThinking: (isThinking) => { isInThinking = isThinking; },
       setThinkingStart: (t) => { thinkingStartTime = t; },
@@ -218,12 +245,12 @@ class StreamHandler {
 
   /**
    * 创建定时器
+   * 优化：定时器不再主动更新，只在完成时强制更新一次显示最终耗时
    */
   createTimer(updater) {
     return setInterval(() => {
-      if (!updater.isCompleted()) {
-        updater.update();
-      }
+      // 不再主动更新，只检查是否完成
+      // 卡片更新由内容变化触发
     }, TIMER_UPDATE_INTERVAL);
   }
 }