iflow-feishu 1.1.3 → 1.1.5

package/bin/iflow-feishu.js

@@ -2,19 +2,19 @@
 
 /**
  * iFlow Feishu CLI 入口
- * 
- * 启动流程：
- * 1. 检测 iFlow CLI -> 未安装则引导安装
- * 2. 检测 PM2 -> 未安装则自动安装
- * 3. 检测飞书配置 -> 未配置则引导输入
- * 4. 启动服务
  */
 
 const { spawn, execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const readline = require('readline');
 
+// 跨平台获取用户主目录
+function getHomeDir() {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir() || '.';
+}
+
 // 颜色输出
 const colors = {
   red: '\x1b[0;31m',
@@ -49,7 +49,11 @@ const VERSION = getVersion();
 // 检查命令是否存在
 function commandExists(cmd) {
   try {
-    execSync(`which ${cmd} 2>/dev/null || command -v ${cmd} 2>/dev/null`, { stdio: 'ignore' });
+    // 跨平台检测
+    const checkCmd = process.platform === 'win32' 
+      ? `where ${cmd} 2>nul` 
+      : `which ${cmd} 2>/dev/null || command -v ${cmd} 2>/dev/null`;
+    execSync(checkCmd, { stdio: 'ignore' });
     return true;
   } catch {
     return false;
@@ -89,7 +93,6 @@ async function checkIFlowCLI() {
   
   if (commandExists('iflow')) {
     const version = getCommandVersion('iflow');
-    // 验证 iFlow CLI 是否真正可用
     try {
       execSync('iflow --version', { stdio: 'pipe', timeout: 5000 });
       log.success(`iFlow CLI 已安装 (版本: ${version})`);
@@ -112,7 +115,6 @@ async function checkIFlowCLI() {
     log.info('正在安装 iFlow CLI...');
     try {
       execSync('npm install -g @iflow-ai/iflow-cli', { stdio: 'inherit' });
-      // 再次验证
       if (commandExists('iflow')) {
         log.success('iFlow CLI 安装成功');
         return true;
@@ -157,15 +159,15 @@ async function checkPM2() {
     } catch (err) {
       log.warn(`PM2 安装失败: ${err.message}`);
       console.log('服务将以前台模式运行');
-      return true; // PM2 可选，继续运行
+      return true;
     }
   }
   
-  return true; // PM2 可选
+  return true;
 }
 
-// 配置文件路径
-const CONFIG_DIR = path.join(process.env.HOME, '.feishu-config');
+// 配置文件路径（跨平台）
+const CONFIG_DIR = path.join(getHomeDir(), '.feishu-config');
 const CONFIG_PATH = path.join(CONFIG_DIR, 'feishu-app.json');
 
 // 验证飞书凭证
@@ -339,8 +341,6 @@ async function checkFeishuConfig() {
 // 启动服务
 function startService() {
   log.step('启动服务...');
-  
-  // 直接运行服务
   require('../src/index.js');
 }
 

package/package.json

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

package/src/config/config.js

@@ -1,18 +1,21 @@
 /**
  * 配置管理模块
- * 
- * 负责加载和验证配置，支持交互式配置向导
  */
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const readline = require('readline');
-const { DEFAULT_MODEL, DEFAULT_MAX_TOKENS, MODEL_MAX_TOKENS } = require('../core/constants');
+const { DEFAULT_MODEL, DEFAULT_MAX_TOKENS, MODEL_CONTEXT_LIMITS, getModelContextLimit } = require('../core/constants');
 
-const CONFIG_DIR = path.join(process.env.HOME, '.feishu-config');
+// 跨平台获取用户主目录
+function getHomeDir() {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir() || '/tmp';
+}
+
+const CONFIG_DIR = path.join(getHomeDir(), '.feishu-config');
 const CONFIG_PATH = path.join(CONFIG_DIR, 'feishu-app.json');
 
-// 获取版本号
 function getVersion() {
   try {
     const pkgPath = path.join(__dirname, '..', '..', 'package.json');
@@ -25,10 +28,6 @@ function getVersion() {
 
 const VERSION = getVersion();
 
-/**
- * 加载飞书配置
- * @returns {Object|null}
- */
 function loadFeishuConfig() {
   try {
     if (fs.existsSync(CONFIG_PATH)) {
@@ -41,28 +40,18 @@ function loadFeishuConfig() {
   } catch (err) {
     console.error(`[ERROR] 读取飞书配置失败: ${err.message}`);
   }
-  
   return null;
 }
 
-/**
- * 保存飞书配置
- * @param {string} appId 
- * @param {string} appSecret 
- */
 function saveFeishuConfig(appId, appSecret) {
   if (!fs.existsSync(CONFIG_DIR)) {
     fs.mkdirSync(CONFIG_DIR, { recursive: true });
   }
-  
   const config = { appId, appSecret };
   fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
   console.log(`\n✅ 配置已保存到: ${CONFIG_PATH}\n`);
 }
 
-/**
- * 配置向导 - 交互式创建配置
- */
 async function setupWizard() {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -94,37 +83,19 @@ async function setupWizard() {
   }
 
   rl.close();
-
   saveFeishuConfig(appId.trim(), appSecret.trim());
-  
   return { appId: appId.trim(), appSecret: appSecret.trim() };
 }
 
-/**
- * 验证配置
- * @param {Object} config - 配置对象
- * @throws {Error} - 配置无效时抛出错误
- */
 function validateConfig(config) {
-  if (!config.feishu?.appId) {
-    throw new Error('缺少飞书 App ID');
-  }
-  
-  if (!config.feishu?.appSecret) {
-    throw new Error('缺少飞书 App Secret');
-  }
-  
-  if (!config.server?.port || config.server.port < 1 || config.server.port > 65535) {
-    throw new Error('无效的服务端口');
-  }
-  
+  if (!config.feishu?.appId) throw new Error('缺少飞书 App ID');
+  if (!config.feishu?.appSecret) throw new Error('缺少飞书 App Secret');
+  if (!config.server?.port || config.server.port < 1 || config.server.port > 65535) throw new Error('无效的服务端口');
   return true;
 }
 
-/**
- * 构建完整配置对象
- */
 function buildConfig(feishuConfig) {
+  const homeDir = getHomeDir();
   return {
     version: VERSION,
     feishu: {
@@ -134,37 +105,28 @@ function buildConfig(feishuConfig) {
     iflow: {
       command: 'iflow',
       timeout: 300000,
-      workDir: process.env.HOME || '/data/data/com.termux/files/home',
+      workDir: homeDir,
       maxTokens: DEFAULT_MAX_TOKENS,
-      modelMaxTokens: MODEL_MAX_TOKENS
+      modelMaxTokens: MODEL_CONTEXT_LIMITS
     },
     server: { 
       port: parseInt(process.env.PORT, 10) || 18080,
       host: '0.0.0.0'
     },
     sessions: {
-      dir: path.join(process.env.HOME || '/tmp', '.iflow-feishu', 'sessions'),
+      dir: path.join(homeDir, '.iflow-feishu', 'sessions'),
       maxHistory: 15,
     },
     card: {
       titleFontSize: 'small',
-      colors: {
-        model: 'blue',
-        generating: 'orange',
-        completed: 'green'
-      }
+      colors: { model: 'blue', generating: 'orange', completed: 'green' }
     }
   };
 }
 
-/**
- * 初始化配置（异步，支持交互式向导）
- * @returns {Promise<Object>} 配置对象
- */
 async function initConfig() {
   let feishuConfig = loadFeishuConfig();
   
-  // 检查环境变量
   if (!feishuConfig && process.env.FEISHU_APP_ID && process.env.FEISHU_APP_SECRET) {
     feishuConfig = {
       appId: process.env.FEISHU_APP_ID,
@@ -172,20 +134,15 @@ async function initConfig() {
     };
   }
   
-  // 配置缺失，启动向导
   if (!feishuConfig) {
     console.log('\n⚠️  未找到飞书配置文件');
     console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-    
     feishuConfig = await setupWizard();
   }
   
   const config = buildConfig(feishuConfig);
-  
-  // 验证配置
   validateConfig(config);
   
-  // 确保会话目录存在
   if (!fs.existsSync(config.sessions.dir)) {
     fs.mkdirSync(config.sessions.dir, { recursive: true });
   }
@@ -197,5 +154,6 @@ module.exports = {
   initConfig,
   getVersion,
   VERSION,
-  CONFIG_PATH
+  CONFIG_PATH,
+  getHomeDir
 };

package/src/core/constants.js

@@ -1,5 +1,5 @@
 /**
- * 常量定义
+ * 常量定义 - 动态模型上下文容量
  */
 
 const fs = require('fs');
@@ -22,45 +22,90 @@ const RECONNECT_MAX_DELAY = 30000;
 const DEFAULT_MODEL = 'glm-5';
 const DEFAULT_MAX_TOKENS = 128000;
 
-const MODEL_MAX_TOKENS = {
-  'qwen3-coder-plus': 128000,
-  'glm-5': 128000,
-  'gpt-4': 128000,
-  'gpt-4-turbo': 128000,
-  'gpt-3.5-turbo': 16384,
-  'claude-3': 200000,
-  'claude-3-opus': 200000,
-  'claude-3-sonnet': 200000,
-  'claude-3-haiku': 200000,
-  'llama-3': 8192,
-  'llama-3-70b': 8192,
-  'mixtral': 32768,
-  'mistral-large': 32768
+/**
+ * 模型上下文容量映射表
+ */
+const MODEL_CONTEXT_LIMITS = {
+  // GLM 系列
+  'glm-4': 128000, 'glm-4-plus': 128000, 'glm-4-air': 128000, 'glm-4-flash': 128000,
+  'glm-5': 128000, 'glm-z1-air': 128000, 'glm-z1-airx': 128000, 'glm-z1-flash': 128000,
+  
+  // GPT 系列
+  'gpt-4': 128000, 'gpt-4-turbo': 128000, 'gpt-4o': 128000, 'gpt-4o-mini': 128000,
+  'gpt-3.5-turbo': 16384, 'o1': 200000, 'o1-mini': 128000, 'o1-preview': 128000,
+  
+  // Claude 系列
+  'claude-3-opus': 200000, 'claude-3-sonnet': 200000, 'claude-3-haiku': 200000,
+  'claude-3.5-sonnet': 200000, 'claude-3.5-haiku': 200000,
+  
+  // Qwen 系列
+  'qwen-turbo': 131072, 'qwen-plus': 131072, 'qwen-max': 32768,
+  'qwen2.5': 131072, 'qwen3': 131072, 'qwen3-coder-plus': 128000, 'qwen3-coder': 131072,
+  
+  // DeepSeek 系列
+  'deepseek-chat': 64000, 'deepseek-coder': 16384, 'deepseek-reasoner': 64000,
+  
+  // LLaMA 系列
+  'llama-3': 8192, 'llama-3-8b': 8192, 'llama-3-70b': 8192,
+  'llama-3.1': 131072, 'llama-3.2': 131072,
+  
+  // Mistral 系列
+  'mistral-small': 32768, 'mistral-medium': 32768, 'mistral-large': 32768, 'mixtral': 32768,
+  
+  // Yi 系列
+  'yi-lightning': 16384, 'yi-large': 32768,
+  
+  // Moonshot (Kimi)
+  'moonshot-v1-8k': 8192, 'moonshot-v1-32k': 32768, 'moonshot-v1-128k': 131072, 'kimi': 131072,
+  
+  // 其他
+  'gemini-pro': 32760, 'gemini-1.5-pro': 1048576, 'gemini-1.5-flash': 1048576
 };
 
-// 从 package.json 读取版本号
+/**
+ * 动态获取模型上下文上限
+ */
+function getModelContextLimit(modelName) {
+  if (!modelName) return DEFAULT_MAX_TOKENS;
+  
+  const name = modelName.toLowerCase();
+  
+  // 1. 精确匹配
+  if (MODEL_CONTEXT_LIMITS[modelName]) return MODEL_CONTEXT_LIMITS[modelName];
+  if (MODEL_CONTEXT_LIMITS[name]) return MODEL_CONTEXT_LIMITS[name];
+  
+  // 2. 模糊匹配
+  for (const [key, limit] of Object.entries(MODEL_CONTEXT_LIMITS)) {
+    if (name.includes(key) || key.includes(name)) return limit;
+  }
+  
+  // 3. 按系列推断
+  if (name.includes('glm')) return 128000;
+  if (name.includes('gpt-4') || name.includes('gpt4')) return 128000;
+  if (name.includes('gpt-3')) return 16384;
+  if (name.includes('claude')) return 200000;
+  if (name.includes('qwen')) return 131072;
+  if (name.includes('deepseek')) return 64000;
+  if (name.includes('llama')) return 8192;
+  if (name.includes('mistral') || name.includes('mixtral')) return 32768;
+  if (name.includes('gemini-1.5')) return 1048576;
+  if (name.includes('gemini')) return 32760;
+  
+  return DEFAULT_MAX_TOKENS;
+}
+
 function getVersion() {
   try {
     const pkgPath = path.join(__dirname, '..', '..', 'package.json');
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
     return pkg.version || '1.0.0';
-  } catch {
-    return '1.0.0';
-  }
+  } catch { return '1.0.0'; }
 }
 
 const VERSION = getVersion();
 
 module.exports = {
-  SEARCH_KEYWORDS,
-  CARD_UPDATE_INTERVAL,
-  TIMER_UPDATE_INTERVAL,
-  CARD_UPDATE_DELAY,
-  RECONNECT_MAX_ATTEMPTS,
-  RECONNECT_BASE_DELAY,
-  RECONNECT_MAX_DELAY,
-  DEFAULT_MODEL,
-  DEFAULT_MAX_TOKENS,
-  MODEL_MAX_TOKENS,
-  VERSION
+  SEARCH_KEYWORDS, CARD_UPDATE_INTERVAL, TIMER_UPDATE_INTERVAL, CARD_UPDATE_DELAY,
+  RECONNECT_MAX_ATTEMPTS, RECONNECT_BASE_DELAY, RECONNECT_MAX_DELAY,
+  DEFAULT_MODEL, DEFAULT_MAX_TOKENS, MODEL_CONTEXT_LIMITS, getModelContextLimit, VERSION
 };

package/src/core/iflow-client.js

@@ -79,19 +79,28 @@ class IFlowClient {
         reject(new Error(`iFlow CLI 超时 (${this.config.iflow.timeout}ms)`));
       }, this.config.iflow.timeout);
 
-      child.on('close', (code) => {
-        clearTimeout(timer);
-        logger.info(`⏱️ iFlow CLI 完成, 退出码: ${code}`);
-        
-        if (code === 0 || stdout) {
-          resolve({
-            stdout,
-            stderr,
-            success: true
-          });
-        } else {
-          reject(new Error(`iFlow CLI failed: ${stderr || 'Unknown error'}`));
-        }
+      // 使用 exit 事件而不是 close，确保所有 IO 完成
+      // 使用 exit 事件而不是 close，确保所有 IO 完成
+      child.on('exit', (code) => {
+        // 给一点时间让最后的 stdout/stderr 数据被收集
+        setTimeout(() => {
+          clearTimeout(timer);
+          logger.info(`⏱️ iFlow CLI 完成, 退出码: ${code}`);
+          // <Execution Info> 在 stderr 中，合并到 stdout 以便提取 token 信息
+          const fullOutput = stdout + '\n' + stderr;
+          logger.info(`📊 stdout 长度: ${stdout.length}, stderr 长度: ${stderr.length}`);
+          logger.info(`📊 包含 Execution Info: ${fullOutput.includes('<Execution Info>')}`);
+          
+          if (code === 0 || stdout) {
+            resolve({
+              stdout: fullOutput,  // 返回完整输出，包含 stderr 中的 Execution Info
+              stderr,
+              success: true
+            });
+          } else {
+            reject(new Error(`iFlow CLI failed: ${stderr || 'Unknown error'}`));
+          }
+        }, 100);
       });
 
       child.on('error', (err) => {

package/src/core/message-processor.js

@@ -2,26 +2,26 @@
  * 消息处理器模块
  */
 
-const { SEARCH_KEYWORDS, DEFAULT_MODEL, DEFAULT_MAX_TOKENS, MODEL_MAX_TOKENS } = require('./constants');
+const os = require('os');
+const { SEARCH_KEYWORDS, DEFAULT_MODEL, DEFAULT_MAX_TOKENS, getModelContextLimit } = require('./constants');
 const { logger } = require('../utils/logger');
 
+// 跨平台获取用户主目录
+function getHomeDir() {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir() || '/tmp';
+}
+
 class MessageProcessor {
   constructor(service) {
     this.service = service;
   }
 
-  /**
-   * 解析消息事件
-   * @param {Object} event - 飞书事件
-   * @returns {Object|null} - 解析后的消息对象
-   */
   parseMessage(event) {
     const message = event.event?.message || event.body?.event?.message || event.message;
     if (!message) {
       logger.warn('无法解析消息，消息格式不正确');
       return null;
     }
-    
     return {
       chatId: message.chat_id,
       msgId: message.message_id,
@@ -30,14 +30,8 @@ class MessageProcessor {
     };
   }
 
-  /**
-   * 提取文本内容
-   * @param {Object} message - 消息对象
-   * @returns {string} - 提取的文本
-   */
   extractText(message) {
     const content = message.raw?.content || message.content;
-    
     try {
       if (typeof content === 'string') {
         return JSON.parse(content).text || content;
@@ -49,24 +43,15 @@ class MessageProcessor {
     }
   }
 
-  /**
-   * 检测是否需要搜索
-   * @param {string} text - 用户文本
-   * @returns {boolean}
-   */
   needsSearch(text) {
     return SEARCH_KEYWORDS.some(keyword => text.includes(keyword));
   }
 
-  /**
-   * 获取当前模型名称
-   * @returns {string}
-   */
   getModelName() {
     try {
       const fs = require('fs');
       const path = require('path');
-      const settingsPath = path.join(process.env.HOME, '.iflow/settings.json');
+      const settingsPath = path.join(getHomeDir(), '.iflow', 'settings.json');
       
       if (fs.existsSync(settingsPath)) {
         const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
@@ -78,22 +63,10 @@ class MessageProcessor {
     return DEFAULT_MODEL;
   }
 
-  /**
-   * 获取模型最大 token 数
-   * @param {string} modelName - 模型名称
-   * @returns {number}
-   */
   getMaxTokens(modelName = DEFAULT_MODEL) {
-    const modelMaxTokens = this.service.config.iflow.modelMaxTokens || {};
-    return modelMaxTokens[modelName] || this.service.config.iflow.maxTokens || DEFAULT_MAX_TOKENS;
+    return getModelContextLimit(modelName);
   }
 
-  /**
-   * 构建带上下文的 prompt
-   * @param {string} chatId - 聊天ID
-   * @param {string} userText - 用户文本
-   * @returns {Object} - 包含 prompt 和历史信息
-   */
   buildPromptWithContext(chatId, userText) {
     const session = this.service.sessionManager.get(chatId);
     let messageWithContext = userText;
@@ -126,13 +99,6 @@ class MessageProcessor {
     };
   }
 
-  /**
-   * 计算剩余上下文百分比
-   * @param {string} chatId - 聊天ID
-   * @param {number} outputLength - 输出长度
-   * @param {string} modelName - 模型名称
-   * @returns {number}
-   */
   calculateContentLeftPercent(chatId, outputLength, modelName) {
     const session = this.service.sessionManager.get(chatId);
     const historyLength = session.messages.reduce((sum, msg) => sum + (msg.content?.length || 0), 0);

package/src/core/service.js

@@ -244,12 +244,10 @@ class FeishuService {
     let hasDetectedThinking = false;
     let isInThinkingPhase = false;
     
-    // 计算初始上下文百分比
-    const session = this.sessionManager.get(chatId);
-    const historyLength = session.messages.reduce((sum, msg) => sum + (msg.content?.length || 0), 0);
-    const initialPercent = this.messageProcessor.calculateContentLeftPercent(chatId, 0, modelName);
+    // 使用上次保存的上下文百分比作为初始值
+    const initialPercent = this.sessionManager.getContentLeftPercent(chatId);
     
-    logger.info(`初始上下文 - 剩余: ${initialPercent}%`);
+    logger.info(`初始上下文 - 剩余: ${initialPercent}% (来自上次保存)`);
     
     // 创建卡片更新器
     const updater = this.streamHandler.createCardUpdater(cardId, startTime, modelName, initialPercent);
@@ -290,10 +288,17 @@ class FeishuService {
           updater.setReasoning(extracted.reasoning);
           updater.setContent(extracted.content || '');
           
-          // 更新上下文百分比
-          const currentLength = (stdoutSoFar || '').length;
-          const percent = this.messageProcessor.calculateContentLeftPercent(chatId, currentLength, modelName);
-          updater.setPercent(percent);
+          // 优先从流式输出中实时提取 token 信息
+          const streamPercent = this.streamHandler.extractTokenUsageFromChunk(stdoutSoFar, modelName);
+          if (streamPercent !== null) {
+            // 流式检测到 Execution Info，使用准确的 token 信息
+            updater.setPercent(streamPercent);
+            logger.debug(`📊 流式更新 left: ${streamPercent}%`);
+          } else if (extracted.contentLeftPercent !== null) {
+            // 从完整提取中得到
+            updater.setPercent(extracted.contentLeftPercent);
+          }
+          // 否则保持之前的百分比值（初始值或上次保存的值）
           
           updater.update();
         },
@@ -304,7 +309,10 @@ class FeishuService {
       updater.endStream(Date.now());
       
       // 获取最终结果
-      const finalExtracted = this.streamHandler.extractResponse(output.stdout || output, chatId, modelName);
+      const finalOutput = output.stdout || output;
+      logger.info(`📊 最终输出长度: ${finalOutput?.length || 0}, 最后500字符: ${finalOutput?.slice(-500)}`);
+      const finalExtracted = this.streamHandler.extractResponse(finalOutput, chatId, modelName);
+      logger.info(`📊 最终提取的 contentLeftPercent: ${finalExtracted.contentLeftPercent}`);
       if (finalExtracted.contentLeftPercent !== null) {
         updater.setPercent(finalExtracted.contentLeftPercent);
       }
@@ -327,6 +335,12 @@ class FeishuService {
       
       logger.info(`完成 - 思考: ${finalThinkingTime || 0}ms, 回复: ${finalResponseTime}ms`);
       
+      // 保存新的上下文剩余百分比
+      if (finalExtracted.contentLeftPercent !== null) {
+        this.sessionManager.setContentLeftPercent(chatId, finalExtracted.contentLeftPercent);
+        logger.info(`📊 保存上下文剩余: ${finalExtracted.contentLeftPercent}%`);
+      }
+      
       // 更新最终卡片
       if (cardId) {
         const hasReasoning = finalExtracted.reasoning && finalExtracted.reasoning.trim();

package/src/core/session.js

@@ -16,7 +16,7 @@ class SessionManager {
       const filePath = path.join(this.config.dir, `${chatId}.json`);
       this.sessions.set(chatId, fs.existsSync(filePath) 
         ? JSON.parse(fs.readFileSync(filePath, 'utf8')) 
-        : { messages: [], createdAt: Date.now() }
+        : { messages: [], createdAt: Date.now(), lastContentLeftPercent: 100 }
       );
     }
     return this.sessions.get(chatId);
@@ -30,10 +30,34 @@ class SessionManager {
       session.messages = session.messages.slice(-this.config.maxHistory);
     }
     
+    this.save(chatId);
+    return session;
+  }
+  
+  /**
+   * 保存上下文剩余百分比
+   */
+  setContentLeftPercent(chatId, percent) {
+    const session = this.get(chatId);
+    session.lastContentLeftPercent = percent;
+    this.save(chatId);
+  }
+  
+  /**
+   * 获取上下文剩余百分比
+   */
+  getContentLeftPercent(chatId) {
+    const session = this.get(chatId);
+    return session.lastContentLeftPercent || 100;
+  }
+  
+  /**
+   * 保存会话到文件
+   */
+  save(chatId) {
+    const session = this.get(chatId);
     const filePath = path.join(this.config.dir, `${chatId}.json`);
     fs.writeFileSync(filePath, JSON.stringify(session, null, 2));
-    
-    return session;
   }
   
   clear(chatId) {

package/src/core/stream-handler.js

@@ -3,19 +3,22 @@
  */
 
 const { logger } = require('../utils/logger');
-const { CARD_UPDATE_INTERVAL, TIMER_UPDATE_INTERVAL, CARD_UPDATE_DELAY } = require('./constants');
+const { CARD_UPDATE_INTERVAL, TIMER_UPDATE_INTERVAL, CARD_UPDATE_DELAY, getModelContextLimit } = require('./constants');
 
 class StreamHandler {
   constructor(service) {
     this.service = service;
   }
 
+  /**
+   * 获取模型最大 token 数（动态）
+   */
+  getMaxTokens(modelName) {
+    return getModelContextLimit(modelName);
+  }
+
   /**
    * 从输出中提取响应
-   * @param {string|Object} output - 输出内容
-   * @param {string} chatId - 聊天ID
-   * @param {string} modelName - 模型名称
-   * @returns {Object} - { reasoning, content, contentLeftPercent }
    */
   extractResponse(output, chatId, modelName) {
     let text = '';
@@ -32,9 +35,9 @@ class StreamHandler {
     const maxTokens = this.getMaxTokens(modelName);
     
     // 首先尝试从 Execution Info 提取
-    let contentLeftPercent = this.extractTokenUsage(text, maxTokens);
+    let contentLeftPercent = this.extractTokenUsage(text, maxTokens, modelName);
     
-    // 如果没有，尝试从回复文本中提取（三元会在回复中报告上下文剩余）
+    // 如果没有，尝试从回复文本中提取
     if (contentLeftPercent === null) {
       contentLeftPercent = this.extractContextFromContent(text);
     }
@@ -51,12 +54,41 @@ class StreamHandler {
     return { reasoning, content: content || '(无法提取响应)', contentLeftPercent };
   }
 
+  /**
+   * 从流式 chunk 中实时提取 token 使用信息
+   */
+  extractTokenUsageFromChunk(accumulatedOutput, modelName) {
+    if (!accumulatedOutput || typeof accumulatedOutput !== 'string') {
+      return null;
+    }
+    
+    const execInfoMatch = accumulatedOutput.match(/<Execution Info>([\s\S]*?)(?:<\/Execution Info>|$)/);
+    if (execInfoMatch) {
+      try {
+        const jsonStr = execInfoMatch[1].trim();
+        const braceCount = (jsonStr.match(/{/g) || []).length - (jsonStr.match(/}/g) || []).length;
+        if (braceCount === 0) {
+          const execInfo = JSON.parse(jsonStr);
+          if (execInfo.tokenUsage && execInfo.tokenUsage.input > 0) {
+            const maxTokens = this.getMaxTokens(modelName);
+            const used = execInfo.tokenUsage.input;
+            const remaining = Math.max(0, maxTokens - used);
+            const percent = Math.round((remaining / maxTokens) * 100);
+            logger.info(`📊 流式检测 token - 模型: ${modelName}, 上限: ${maxTokens}, 已用: ${used}, 剩余: ${percent}%`);
+            return percent;
+          }
+        }
+      } catch (e) {
+        // JSON 还不完整，忽略
+      }
+    }
+    return null;
+  }
+
   /**
    * 从回复内容中提取上下文剩余百分比
-   * 匹配格式: "📊 剩余 ~77%", "剩余 ~77%", "剩余 77%" 等
    */
   extractContextFromContent(text) {
-    // 匹配多种格式: 剩余 ~77%, 剩余 77%, 📊 剩余 ~77%
     const patterns = [
       /剩余\s*~?(\d+)%/i,
       /📊\s*剩余\s*~?(\d+)%/i,
@@ -76,35 +108,30 @@ class StreamHandler {
     return null;
   }
 
-  /**
-   * 获取模型最大 token 数
-   */
-  getMaxTokens(modelName) {
-    const modelMaxTokens = this.service.config.iflow.modelMaxTokens || {};
-    return modelMaxTokens[modelName] || this.service.config.iflow.maxTokens || 128000;
-  }
-
   /**
    * 从输出中提取 token 使用信息
    */
-  extractTokenUsage(text, maxTokens) {
+  extractTokenUsage(text, maxTokens, modelName) {
+    if (!text || typeof text !== 'string') {
+      return null;
+    }
+    
     const execInfoMatch = text.match(/<Execution Info>([\s\S]*?)<\/Execution Info>/);
     if (execInfoMatch) {
       try {
         const execInfo = JSON.parse(execInfoMatch[1]);
         logger.info(`📊 解析到 Execution Info: ${JSON.stringify(execInfo.tokenUsage)}`);
-        if (execInfo.tokenUsage && execInfo.tokenUsage.total > 0) {
-          const used = execInfo.tokenUsage.total;
+        // 使用 input 来计算剩余上下文（input 包含历史对话 + 本次请求）
+        if (execInfo.tokenUsage && execInfo.tokenUsage.input > 0) {
+          const used = execInfo.tokenUsage.input;
           const remaining = Math.max(0, maxTokens - used);
           const percent = Math.round((remaining / maxTokens) * 100);
-          logger.info(`📊 Token 计算: 已用=${used}, 剩余=${remaining}, 百分比=${percent}%`);
+          logger.info(`📊 Token 计算 - 模型: ${modelName}, 上限: ${maxTokens}, 输入: ${used}, 剩余: ${percent}%`);
           return percent;
         }
       } catch (e) {
         logger.warn(`📊 解析 Execution Info 失败: ${e.message}`);
       }
-    } else {
-      logger.info(`📊 未找到 Execution Info 标签`);
     }
     return null;
   }
@@ -151,7 +178,7 @@ class StreamHandler {
     try {
       const fs = require('fs');
       const path = require('path');
-      const logDir = path.join(process.env.HOME, '.iflow', 'log');
+      const logDir = path.join(getHomeDir(), '.iflow', 'log');
       
       const maxTokens = this.getMaxTokens(modelName);
       
@@ -172,10 +199,8 @@ class StreamHandler {
       const tokenMatch = lastPart.match(/(\d+)\s+tokens\s+from\s+the\s+input\s+messages\s+and\s+(\d+)\s+tokens\s+for\s+the\s+completion/);
       if (tokenMatch) {
         const inputTokens = parseInt(tokenMatch[1], 10);
-        const outputTokens = parseInt(tokenMatch[2], 10);
-        const totalUsed = inputTokens + outputTokens;
-        const remaining = Math.max(0, maxTokens - totalUsed);
-        logger.info(`📊 从日志读取 token: 输入=${inputTokens}, 输出=${outputTokens}, 总计=${totalUsed}/${maxTokens}`);
+        const remaining = Math.max(0, maxTokens - inputTokens);
+        logger.info(`📊 从日志读取 token - 模型: ${modelName}, 上限: ${maxTokens}, 输入: ${inputTokens}`);
         return Math.round((remaining / maxTokens) * 100);
       }
       
@@ -266,4 +291,4 @@ class StreamHandler {
   }
 }
 
-module.exports = { StreamHandler };
+module.exports = { StreamHandler };

package/src/handlers/commands.js

@@ -4,8 +4,14 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const { logger } = require('../utils/logger');
 
+// 跨平台获取用户主目录
+function getHomeDir() {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir() || '/tmp';
+}
+
 class CommandHandler {
   constructor(service) {
     this.service = service;
@@ -66,7 +72,7 @@ class CommandHandler {
   }
 
   async handleMode(chatId, args) {
-    const settingsPath = path.join(process.env.HOME, '.iflow/settings.json');
+    const settingsPath = path.join(getHomeDir(), '.iflow', 'settings.json');
     
     let currentMode = 'default';
     try {
@@ -79,7 +85,6 @@ class CommandHandler {
     }
     
     if (args.length === 0) {
-      // 显示当前模式
       const text = `🎛️ 当前模式：**${currentMode}**
 
 可用模式：
@@ -95,7 +100,6 @@ class CommandHandler {
       return true;
     }
     
-    // 切换模式
     const newMode = args[0];
     const validModes = ['default', 'yolo', 'plan', 'smart'];
     
@@ -136,7 +140,7 @@ class CommandHandler {
     let currentMode = 'default';
     
     try {
-      const settingsPath = path.join(process.env.HOME, '.iflow/settings.json');
+      const settingsPath = path.join(getHomeDir(), '.iflow', 'settings.json');
       if (fs.existsSync(settingsPath)) {
         const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
         modelName = settings.modelName || 'glm-5';