minimax-status 1.1.3 → 1.1.5

package/README.md

@@ -126,10 +126,10 @@ npm run package
 集成成功后，底部状态栏将显示:
 
 ```
-📁 my-app | 🤖 MiniMax-M2 | ⚡ 85%·150.0k tokens | ↻ 6%·4227/4500 | ⌛ 1h20m | 1 CLAUDE.md | 8 rules | 6 MCPs | 到期: 5天
+my-app │ main * │ MiniMax-M2 │ 205K │ Usage ██████░░░░ 60% (2700/4500) │ ⏱ 1h20m │ 到期 5天
 ```
 
-显示格式：`📁 目录 | 🌿 分支 | 🤖 模型 | ⚡ 上下文 | ↻ 使用量 | ⌛ 重置 | 配置项 | 到期时间`
+显示格式：`目录 │ 分支 │ 模型 │ 上下文 │ Usage 进度条 百分比(剩余/总数) │ ⏱ 倒计时 │ 到期 天数`
 
 **颜色说明**:
 
@@ -141,17 +141,14 @@ npm run package
 状态栏会显示当前 Git 分支信息：
 
 ```
-📁 my-app | ✦ main ↓2 • | 🤖 MiniMax-M2 | ...
+my-app │ main * │ ...
 ```
 
 **符号说明**:
 
 | 符号 | 含义 |
 |------|------|
-| 🌿 | Git 分支图标（emoji） |
-| ⬆n | 有 n 个 commit 未推送到远程 |
-| ⬇n | 有 n 个 commit 未从远程拉取（优先显示） |
-| • | 有未提交的更改 |
+| * | 有未提交的更改 |
 
 **颜色规则**:
 
@@ -183,6 +180,55 @@ npm run package
 
 **注意**: MiniMax 的配置独立存储在 `~/.minimax-config.json`，与 Claude Code 的配置分离。
 
+## Droid 集成
+
+将 MiniMax 使用状态显示在 Droid 底部状态栏。
+
+### 配置步骤
+
+1. **安装和配置工具**:
+
+   ```bash
+   npm install -g minimax-status
+   minimax auth <token> <groupId>
+   ```
+
+2. **配置 Droid**:
+
+   编辑 `~/.factory/settings.json`:
+
+   ```json
+   {
+     "statusLine": {
+       "type": "command",
+       "command": "minimax droid-statusline"
+     }
+   }
+   ```
+
+3. **重启 Droid**
+
+集成成功后，底部状态栏将显示:
+
+```
+minimax-status │ main * │ Usage █░░░░░░░░ 10% (4047/4500) │ ⏱ 12m │ 到期 21天
+```
+
+显示格式：`目录 │ 分支 │ Usage 进度条 百分比(剩余/总数) │ ⏱ 倒计时 │ 到期 天数`
+
+### 进度条风格
+
+使用 `█` 和 `░` 字符显示进度条：
+
+- `█░░░░░░░░` - 10% 使用量
+- `█████░░░░` - 50% 使用量
+- `██████████` - 100% 使用量
+
+**颜色说明**:
+
+- **使用量**: ≥85%红色 | 60-85%黄色 | <60%绿色
+- **到期时间**: ≤3天红色 | ≤7天黄色 | >7天绿色
+
 ## 显示示例
 
 ### 详细模式
@@ -225,26 +271,35 @@ npm run package
 
 ## 命令说明
 
-| 命令                 | 描述                                        | 示例                             |
-| -------------------- | ------------------------------------------- | -------------------------------- |
-| `minimax auth`       | 设置认证凭据                                | `minimax auth <token> <groupId>` |
-| `minimax status`     | 显示当前使用状态（支持 --compact、--watch） | `minimax status`                 |
-| `minimax bar`        | 终端底部持续状态栏                          | `minimax bar`                    |
-| `minimax statusline` | Claude Code 状态栏集成                      | 用于 Claude Code 配置            |
+| 命令                    | 描述                                        | 示例                             |
+| --------------------- | ------------------------------------------- | -------------------------------- |
+| `minimax auth`        | 设置认证凭据                                | `minimax auth <token> <groupId>` |
+| `minimax status`      | 显示当前使用状态（支持 --compact、--watch） | `minimax status`                 |
+| `minimax bar`         | 终端底部持续状态栏                          | `minimax bar`                    |
+| `minimax statusline`  | Claude Code 状态栏集成                      | 用于 Claude Code 配置            |
+| `minimax droid-statusline` | Droid 状态栏集成                      | 用于 Droid 配置            |
 
 ## 状态说明
 
-### 状态图标
-
-| 元素   | 图标 | 说明                               |
-| ------ | ---- | ---------------------------------- |
-| 目录   | 📁   | 当前工作目录                       |
-| 模型   | 🤖   | MiniMax 模型名称                   |
-| 上下文 | ⚡   | 上下文窗口使用率（百分比·已用tokens）|
-| 使用量 | ↻    | 使用率·剩余次数/总数               |
-| 重置   | ⌛   | 额度重置倒计时                     |
-| 配置项 | -    | CLAUDE.md、rules、MCPs 数量       |
-| 到期   | -    | 订阅到期时间（颜色动态变化）        |
+### 显示元素
+
+| 元素   | 说明                               |
+| ------ | ---------------------------------- |
+| 目录   | 当前工作目录                       |
+| 分支   | Git 分支名称                       |
+| 模型   | MiniMax 模型名称                   |
+| 上下文 | 上下文窗口使用率                  |
+| Usage  | 使用量进度条和百分比(剩余/总数)    |
+| ⏱     | 额度重置倒计时                     |
+| 到期   | 订阅到期时间（颜色动态变化）        |
+
+### 进度条
+
+使用 `█` 和 `░` 字符显示进度条：
+
+- `█░░░░░░░░` - 10% 使用量
+- `█████░░░░░` - 50% 使用量
+- `██████████` - 100% 使用量
 
 ### 颜色规则
 

package/cli/index.js

@@ -246,7 +246,7 @@ program
       let displayModel = modelName;
       let currentDir = null;
       let modelId = null;
-      let contextSize = 200000;
+      let contextSize = 204800;
 
       if (stdinData) {
         if (stdinData.model && stdinData.model.display_name) {
@@ -265,13 +265,8 @@ program
       }
 
       if (modelId) {
-        const modelKey = modelId.toLowerCase();
-        for (const [key, value] of Object.entries(MODEL_CONTEXT_SIZES)) {
-          if (modelKey.includes(key.toLowerCase())) {
-            contextSize = value;
-            break;
-          }
-        }
+        // MiniMax 模型统一使用 208K context window
+        contextSize = 204800;
       }
 
       let contextUsageTokens = null;
@@ -282,9 +277,18 @@ program
       const displayDir = currentDir || cliCurrentDir || "";
 
       let configCounts = { claudeMdCount: 0, rulesCount: 0, mcpCount: 0, hooksCount: 0 };
-      const workspacePath = stdinData?.workspace?.current_directory;
-      if (workspacePath && typeof workspacePath === 'string') {
-        configCounts = await configCounter.count(workspacePath);
+      // 优先使用 stdin 传入的 workspacePath，否则 fallback 到 process.cwd()
+      const workspacePath = stdinData?.workspace?.current_directory || process.cwd();
+      if (workspacePath) {
+        try {
+          // 添加超时防止挂起
+          configCounts = await Promise.race([
+            configCounter.count(workspacePath),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('config timeout')), 2000))
+          ]);
+        } catch (e) {
+          // 超时或失败，保持默认值
+        }
       }
 
       // 获取 git 分支信息
@@ -301,12 +305,14 @@ program
             gitBranch = { name: branch };
 
             // 获取 ahead/behind
+            let hasUpstream = false;
             try {
               const revList = require('child_process').execSync(
                 'git rev-list --left-right --count HEAD...@{upstream}',
                 { cwd: gitSearchPath, encoding: 'utf8', timeout: 3000 }
               ).trim();
               if (revList) {
+                hasUpstream = true;
                 const [behind, ahead] = revList.split(/\s+/).map(n => parseInt(n) || 0);
                 if (ahead > 0 || behind > 0) {
                   gitBranch.ahead = ahead;
@@ -317,6 +323,23 @@ program
               // 无 upstream 或获取失败，静默跳过
             }
 
+            // 如果没有 upstream，尝试获取本地 commit 数作为提示
+            if (!hasUpstream) {
+              try {
+                const localCommits = require('child_process').execSync(
+                  'git rev-list --count HEAD',
+                  { cwd: gitSearchPath, encoding: 'utf8', timeout: 3000 }
+                ).trim();
+                const commitCount = parseInt(localCommits) || 0;
+                // 如果有本地 commits（大于1，因为初始commit算1个），标记有待推送
+                if (commitCount > 1) {
+                  gitBranch.ahead = -1; // -1 表示有未知数量的待推送
+                }
+              } catch (e) {
+                // 获取失败，静默跳过
+              }
+            }
+
             // 检查未提交的更改
             try {
               const status = require('child_process').execSync(
@@ -373,13 +396,303 @@ program
     }
   });
 
-// 模型上下文窗口大小映射表（仅MiniMax模型）
-const MODEL_CONTEXT_SIZES = {
-  "minimax-m2": 200000,
-  "minimax-m2-stable": 200000,
-  "minimax-m1": 200000,
-  "minimax-m1-stable": 200000,
-};
+// Droid-statusline command - Droid 状态栏集成（从 session 文件读取数据）
+program
+  .command("droid-statusline")
+  .description("Droid状态栏集成（从 session 文件读取数据，单次输出）")
+  .argument("[sessionPath]", "Droid session 目录路径（可选，默认自动查找）")
+  .action(async (sessionPath) => {
+    const fs = require("fs");
+    const path = require("path");
+
+    // 查找 session 目录
+    let targetSessionPath = sessionPath;
+    const currentCwd = process.cwd().replace(/\\/g, "/");
+    
+    if (!targetSessionPath) {
+      const sessionsDir = path.join(process.env.HOME || process.env.USERPROFILE, ".factory", "sessions");
+      
+      if (!fs.existsSync(sessionsDir)) {
+        console.log("❌ 未找到 Droid sessions 目录");
+        process.exit(1);
+      }
+
+      // 优先查找与当前工作目录匹配的 session
+      const userDirs = fs.readdirSync(sessionsDir);
+      let matchedSession = null;
+      let latestSession = null;
+      let latestStartTime = 0;
+
+      for (const userDir of userDirs) {
+        const userPath = path.join(sessionsDir, userDir);
+        if (!fs.statSync(userPath).isDirectory()) continue;
+
+        const sessions = fs.readdirSync(userPath);
+        for (const session of sessions) {
+          if (!session.endsWith(".jsonl")) continue;
+          
+          const jsonlPath = path.join(userPath, session);
+          try {
+            const content = fs.readFileSync(jsonlPath, "utf8");
+            const firstLine = content.split("\n")[0];
+            const entry = JSON.parse(firstLine);
+            
+            if (entry.cwd) {
+              const sessionCwd = entry.cwd.replace(/\\/g, "/");
+              // 优先匹配当前工作目录
+              if (sessionCwd === currentCwd || currentCwd.includes(sessionCwd) || sessionCwd.includes(currentCwd)) {
+                if (!matchedSession) {
+                  matchedSession = userPath;
+                }
+              }
+            }
+            
+            // 记录最新 session
+            if (entry.timestamp) {
+              const startTime = new Date(entry.timestamp).getTime();
+              if (startTime > latestStartTime) {
+                latestStartTime = startTime;
+                latestSession = userPath;
+              }
+            }
+          } catch (e) {
+            // continue
+          }
+        }
+      }
+
+      // 优先使用匹配的 session，否则用最新的
+      targetSessionPath = matchedSession || latestSession;
+
+      if (!targetSessionPath) {
+        console.log("❌ 未找到 Droid session");
+        process.exit(1);
+      }
+    }
+
+    // 读取 settings.json
+    const settingsFiles = fs.readdirSync(targetSessionPath).filter(f => f.endsWith(".settings.json"));
+    let settings = {};
+    
+    for (const sf of settingsFiles) {
+      try {
+        const content = fs.readFileSync(path.join(targetSessionPath, sf), "utf8");
+        const parsed = JSON.parse(content);
+        if (parsed.tokenUsage) {
+          settings = parsed;
+          break;
+        }
+      } catch (e) {
+        // continue
+      }
+    }
+
+    // 读取 jsonl 获取 cwd 和模型信息，以及实时 token 使用量
+    let cwd = process.cwd();
+    let jsonlTokens = null;
+    const jsonlFiles = fs.readdirSync(targetSessionPath).filter(f => f.endsWith(".jsonl"));
+    
+    for (const jf of jsonlFiles) {
+      try {
+        const content = fs.readFileSync(path.join(targetSessionPath, jf), "utf8");
+        const lines = content.split('\n').filter(l => l.trim());
+        
+        // 获取第一行获取 cwd
+        if (lines.length > 0) {
+          try {
+            const firstEntry = JSON.parse(lines[0]);
+            if (firstEntry.cwd) {
+              cwd = firstEntry.cwd;
+            }
+          } catch (e) {}
+        }
+        
+        // 从最后的消息中解析实时 token 使用量
+        for (let i = lines.length - 1; i >= 0; i--) {
+          try {
+            const entry = JSON.parse(lines[i]);
+            // 查找 assistant 消息中的 usage
+            if (entry.type === 'message' && entry.message?.role === 'assistant' && entry.message?.usage) {
+              const u = entry.message.usage;
+              jsonlTokens = {
+                inputTokens: u.input_tokens || u.prompt_tokens || 0,
+                outputTokens: u.output_tokens || u.completion_tokens || 0,
+                cacheCreationTokens: u.cache_creation_input_tokens || u.cache_creation_prompt_tokens || 0,
+                cacheReadTokens: u.cache_read_input_tokens || u.cache_read_prompt_tokens || 0,
+                thinkingTokens: u.thinking_tokens || 0
+              };
+              break;
+            }
+          } catch (e) {
+            continue;
+          }
+        }
+      } catch (e) {
+        // continue
+      }
+    }
+
+    const currentDir = cwd.split(/[/\\]/).pop();
+
+    // 优先使用 jsonl 中的实时 token 使用量，否则用 settings 中的累计值
+    const tokenUsage = (jsonlTokens && (jsonlTokens.inputTokens > 0 || jsonlTokens.outputTokens > 0)) 
+      ? jsonlTokens 
+      : (settings.tokenUsage || {});
+    
+    const inputTokens = tokenUsage.inputTokens || 0;
+    const outputTokens = tokenUsage.outputTokens || 0;
+    const cacheCreationTokens = tokenUsage.cacheCreationTokens || 0;
+    const cacheReadTokens = tokenUsage.cacheReadTokens || 0;
+    const thinkingTokens = tokenUsage.thinkingTokens || 0;
+    
+    // 实时上下文使用量（不包括累计的 cacheReadTokens）
+    const contextTokens = inputTokens + outputTokens + cacheCreationTokens + thinkingTokens;
+    // 累计 token（用于显示）
+    const totalTokens = inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens + thinkingTokens;
+
+    // 获取模型信息
+    const modelName = settings.model || "MiniMax-M2.5-highspeed";
+    const modelDisplayName = modelName.replace(/^custom:/, "").replace(/-[0-9]+$/, "");
+
+    // 获取 API 使用量
+    let usageData = null;
+    try {
+      const [apiData, subscriptionData] = await Promise.all([
+        api.getUsageStatus(),
+        api.getSubscriptionDetails(),
+      ]);
+      usageData = api.parseUsageData(apiData, subscriptionData);
+    } catch (e) {
+      usageData = {
+        usage: { percentage: 0, input: 0, output: 0, cached: 0, total: 0 },
+        remaining: "未知",
+        expiry: "未知",
+        modelName: modelDisplayName
+      };
+    }
+
+    const { usage, remaining, expiry } = usageData;
+
+    // 获取 git 分支
+    let gitBranch = null;
+    try {
+      const branch = require('child_process').execSync(
+        'git symbolic-ref --short HEAD',
+        { cwd: cwd, encoding: 'utf8', timeout: 3000 }
+      ).trim();
+      if (branch) {
+        gitBranch = { name: branch };
+        
+        // 检查未提交的更改
+        try {
+          const status = require('child_process').execSync(
+            'git status --porcelain',
+            { cwd: cwd, encoding: 'utf8', timeout: 3000 }
+          ).trim();
+          if (status) {
+            gitBranch.hasChanges = true;
+          }
+        } catch (e) {
+          // ignore
+        }
+      }
+    } catch (e) {
+      // 非 git 目录
+    }
+
+    // 计算上下文使用量（从 session 实时 token）
+    // 使用实时 contextTokens 计算百分比
+    const contextUsageValue = contextTokens;
+    const contextSizeValue = 204800; // MiniMax M2 context window
+
+    // 获取 Droid 全局配置统计（不是当前工作目录）
+    const droidConfigDir = path.join(process.env.HOME || process.env.USERPROFILE, ".factory");
+    let configCounts = { claudeMdCount: 0, rulesCount: 0, mcpCount: 0, hooksCount: 0, skillsCount: 0 };
+    
+    try {
+      const agentsPath = path.join(droidConfigDir, "agents");
+      const rulesPath = path.join(droidConfigDir, "rules");
+      const skillsPath = path.join(droidConfigDir, "skills");
+      const hooksPath = path.join(droidConfigDir, "hooks");
+      const mcpPath = path.join(droidConfigDir, "mcp.json");
+
+      if (fs.existsSync(agentsPath)) {
+        configCounts.claudeMdCount = fs.readdirSync(agentsPath).filter(f => f.endsWith(".md")).length;
+      }
+      if (fs.existsSync(rulesPath)) {
+        configCounts.rulesCount = fs.readdirSync(rulesPath).filter(f => f.endsWith(".md")).length;
+      }
+      if (fs.existsSync(skillsPath)) {
+        configCounts.skillsCount = fs.readdirSync(skillsPath).filter(f => f.endsWith(".md")).length;
+      }
+      if (fs.existsSync(hooksPath)) {
+        configCounts.hooksCount = fs.readdirSync(hooksPath).filter(f => f.endsWith(".ps1") || f.endsWith(".sh")).length;
+      }
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const mcpData = JSON.parse(fs.readFileSync(mcpPath, "utf8"));
+          if (mcpData.mcpServers) {
+            configCounts.mcpCount = Object.keys(mcpData.mcpServers).length;
+          }
+        } catch (e) {}
+      }
+    } catch (e) {
+      // ignore errors
+    }
+
+    // 进度条渲染函数
+    function getBarColor(p) {
+      if (p >= 85) return chalk.red;
+      if (p >= 60) return chalk.yellow;
+      return chalk.green;
+    }
+    const coloredBar = (percent, width = 10) => {
+      const filled = Math.round((percent / 100) * width);
+      const empty = width - filled;
+      const barColor = getBarColor(percent);
+      return barColor('█'.repeat(filled) + '\x1b[2m' + '░'.repeat(empty) + '\x1b[0m');
+    };
+
+    // 简化输出：目录 | git分支 | 使用量(进度条) | 倒计时
+    const parts = [];
+    
+    // 目录
+    if (currentDir) {
+      parts.push(`${chalk.cyan(currentDir)}`);
+    }
+    
+    // Git 分支
+    if (gitBranch && gitBranch.name) {
+      const isMainBranch = gitBranch.name === 'main' || gitBranch.name === 'master';
+      const branchColor = isMainBranch ? chalk.green : chalk.white;
+      let branchStr = branchColor(gitBranch.name);
+      if (gitBranch.hasChanges) {
+        branchStr += chalk.red(' *');
+      }
+      parts.push(branchStr);
+    }
+    
+    // 使用量 - 进度条风格 (显示次数)
+    const usageBar = coloredBar(usage.percentage);
+    const usageColor = usage.percentage >= 85 ? chalk.red : usage.percentage >= 60 ? chalk.yellow : chalk.green;
+    parts.push(`${chalk.yellow('Usage')} ${usageBar} ${usageColor(usage.percentage + '%')} (${usage.remaining}/${usage.total})`);
+    
+    // 倒计时
+    const remainingText = remaining.hours > 0 
+      ? `${remaining.hours}h${remaining.minutes}m` 
+      : `${remaining.minutes}m`;
+    parts.push(`${chalk.yellow('⏱')} ${remainingText}`);
+    
+    // 到期
+    if (expiry) {
+      const expiryColor = expiry.daysRemaining <= 3 ? chalk.red : expiry.daysRemaining <= 7 ? chalk.yellow : chalk.green;
+      parts.push(`${expiryColor('到期 ' + expiry.daysRemaining + '天')}`);
+    }
+    
+    console.log(parts.join(' │ '));
+  });
+
+// 模型上下文窗口大小（仅MiniMax模型）
 
 function startWatching(api, statusBar) {
   let intervalId;

package/cli/renderer.js

@@ -75,7 +75,7 @@ class Renderer {
     const parts = [];
 
     if (currentDir) {
-      parts.push(`${chalk.blue('📁')} ${chalk.cyan(currentDir)}`);
+      parts.push(`${chalk.cyan(currentDir)}`);
     }
 
     // Git 分支显示
@@ -86,62 +86,49 @@ class Renderer {
       const isMainBranch = name === 'main' || name === 'master';
       const branchColor = isMainBranch ? chalk.green : chalk.white;
 
-      // 构建分支显示字符串（使用 emoji 图标）
-      let branchStr = branchColor('🌿 ' + name);
+      // 构建分支显示字符串
+      let branchStr = branchColor(name);
 
-      // 优先显示 behind（未拉取），不同时显示 ahead 和 behind
-      if (behind > 0) {
-        branchStr += chalk.cyan(' ⬇' + behind);
-      } else if (ahead > 0) {
-        branchStr += chalk.yellow(' ⬆' + ahead);
-      }
-
-      // 未提交更改用红色点
+      // 未提交更改用 * 标记
       if (hasChanges) {
-        branchStr += chalk.red(' •');
+        branchStr += chalk.red(' *');
       }
 
       parts.push(branchStr);
     }
 
-    parts.push(`${chalk.magenta('🤖')} ${chalk.magenta(modelName)}`);
+    // 模型
+    parts.push(`${chalk.magenta(modelName)}`);
 
-    // 上下文窗口在前
+    // 上下文窗口
     if (contextUsage !== null && contextUsage !== undefined) {
       const contextPercent = Math.round((contextUsage / contextSize) * 100);
       const contextColor = this.getStatusColor(contextPercent);
-      // 合并百分比和实际使用量，用 · 分割，统一颜色
-      const contextStr = `${contextColor('⚡' + contextPercent + '%')}${contextColor('·')}${contextColor(this.formatTokens(contextUsage) + ' tokens')}`;
-      parts.push(contextStr);
+      parts.push(`${contextColor(contextPercent + '%')} ${chalk.gray(this.formatTokens(contextUsage))}`);
     } else {
-      parts.push(`${chalk.cyan(this.formatContextSize(contextSize))}`);
+      parts.push(chalk.cyan(this.formatContextSize(contextSize)));
     }
 
-    // 使用量合并
+    // 使用量 - 进度条风格
     const usageColor = this.getStatusColor(usagePercentage);
-    parts.push(`${chalk.yellow('↻')} ${usageColor(usagePercentage + '%')}${chalk.yellow('·')}${chalk.white(usage.remaining + '/' + usage.total)}`);
+    const filled = Math.round((usagePercentage / 100) * 10);
+    const empty = 10 - filled;
+    const usageBar = usageColor('█'.repeat(filled) + '\x1b[2m' + '░'.repeat(empty) + '\x1b[0m');
+    parts.push(`${chalk.yellow('Usage')} ${usageBar} ${usageColor(usagePercentage + '%')} (${usage.remaining}/${usage.total})`);
 
+    // 倒计时 - 保留图标
     const remainingText = remaining.hours > 0
       ? `${remaining.hours}h${remaining.minutes}m`
       : `${remaining.minutes}m`;
-    parts.push(`${chalk.yellow('⌛')} ${chalk.white(remainingText)}`);
+    parts.push(`${chalk.yellow('⏱')} ${remainingText}`);
 
-    if (configCounts.claudeMdCount > 0) {
-      parts.push(`${chalk.white(configCounts.claudeMdCount + ' CLAUDE.md')}`);
-    }
-    if (configCounts.rulesCount > 0) {
-      parts.push(`${chalk.cyan(configCounts.rulesCount + ' rules')}`);
-    }
-    if (configCounts.mcpCount > 0) {
-      parts.push(`${chalk.yellow(configCounts.mcpCount + ' MCPs')}`);
-    }
-    
+    // 到期 - 保留图标
     if (expiry) {
       const expiryColor = expiry.daysRemaining <= 3 ? chalk.red : expiry.daysRemaining <= 7 ? chalk.yellow : chalk.green;
-      parts.push(`${expiryColor('到期: ' + expiry.daysRemaining + '天')}`);
+      parts.push(`${expiryColor('到期 ' + expiry.daysRemaining + '天')}`);
     }
 
-    return parts.join(' | ');
+    return parts.join(' │ ');
   }
 
   renderToolsLine(tools) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minimax-status",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "MiniMax Claude Code 使用状态监控工具",
   "bin": {
     "minimax-status": "cli/index.js",