minimax-status 1.0.21 → 1.1.0

package/cli/api.js

@@ -142,6 +142,134 @@ class MinimaxAPI {
     }
   }
 
+  /**
+   * Get billing records from the account/amount API
+   * @param {number} page - Page number (1-based)
+   * @param {number} limit - Number of records per page (max 100)
+   * @returns {Promise<Object>} Billing records response
+   */
+  async getBillingRecords(page = 1, limit = 100) {
+    try {
+      const response = await axios.get(
+        `https://www.minimaxi.com/account/amount`,
+        {
+          params: {
+            page: page,
+            limit: limit,
+            aggregate: false,
+            GroupId: this.groupId,
+          },
+          headers: {
+            Authorization: `Bearer ${this.token}`,
+            Accept: "application/json",
+          },
+          timeout: 10000,
+          httpsAgent,
+        }
+      );
+
+      return response.data;
+    } catch (error) {
+      throw new Error(`账单 API 请求失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * Fetch all billing records with pagination
+   * @param {number} maxPages - Maximum number of pages to fetch
+   * @returns {Promise<Array>} All billing records
+   */
+  async getAllBillingRecords(maxPages = 10) {
+    const allRecords = [];
+
+    for (let page = 1; page <= maxPages; page++) {
+      try {
+        const response = await this.getBillingRecords(page, 100);
+        const records = response.charge_records || [];
+
+        if (records.length === 0) {
+          break;
+        }
+
+        allRecords.push(...records);
+
+        if (records.length < 100) {
+          break;
+        }
+      } catch (error) {
+        console.error(`Failed to fetch billing records page ${page}:`, error.message);
+        break;
+      }
+    }
+
+    return allRecords;
+  }
+
+  /**
+   * Calculate usage statistics from billing records
+   * @param {Array} records - Billing records from account/amount API
+   * @param {number} planStartTime - Plan start time in milliseconds
+   * @param {number} planEndTime - Plan end time in milliseconds
+   * @returns {Object} Usage statistics
+   */
+  calculateUsageStats(records, planStartTime, planEndTime) {
+    const now = Date.now();
+
+    // 账单记录是秒级时间戳，需要统一转换为毫秒
+    const planStartMs = planStartTime;
+    const planEndMs = planEndTime;
+
+    // 昨日（0点到现在）或者取最近一次账单的日期
+    // 账单记录不是实时的，当日消耗要明天才显示，所以显示"昨日"
+    const todayStart = new Date().setHours(0, 0, 0, 0);
+    const yesterdayStart = todayStart - 24 * 60 * 60 * 1000;
+    const weekAgo = now - 7 * 24 * 60 * 60 * 1000;
+
+    const stats = {
+      lastDayUsage: 0,
+      weeklyUsage: 0,
+      planTotalUsage: 0,
+    };
+
+    for (const record of records) {
+      const tokens = parseInt(record.consume_token, 10) || 0;
+      // 账单记录的 created_at 是秒级时间戳，转换为毫秒
+      const createdAt = (record.created_at || 0) * 1000;
+
+      // 昨日消耗（从昨日0点到现在）
+      if (createdAt >= yesterdayStart && createdAt < todayStart) {
+        stats.lastDayUsage += tokens;
+      }
+
+      // 近7天消耗
+      if (createdAt >= weekAgo) {
+        stats.weeklyUsage += tokens;
+      }
+
+      // 套餐期内总消耗
+      if (createdAt >= planStartMs && createdAt <= planEndMs) {
+        stats.planTotalUsage += tokens;
+      }
+    }
+
+    return stats;
+  }
+
+  /**
+   * Format number to human readable format (万, 亿)
+   * @param {number} num - Number to format
+   * @returns {string} Formatted string
+   */
+  formatNumber(num) {
+    if (num >= 100000000) {
+      return (num / 100000000).toFixed(1).replace(/\.0$/, "") + "亿";
+    }
+    if (num >= 10000) {
+      return (num / 10000).toFixed(1).replace(/\.0$/, "") + "万";
+    }
+    return num.toLocaleString("zh-CN");
+  }
+
   // 清除缓存
   clearCache() {
     this.cache = {

package/cli/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 // Force color output even in non-TTY environments (e.g., Claude Code statusline)
 process.env.FORCE_COLOR = "1";
@@ -114,7 +114,35 @@ program
         api.getSubscriptionDetails(),
       ]);
       const usageData = api.parseUsageData(apiData, subscriptionData);
-      const statusBar = new StatusBar(usageData);
+
+      // 获取账单数据用于消耗统计
+      let usageStats = null;
+      try {
+        const billingRecords = await api.getAllBillingRecords(10);
+        if (billingRecords.length > 0) {
+          // 计算套餐开始时间：到期时间往前推1个月
+          let planStartTime = 0;
+          if (subscriptionData &&
+              subscriptionData.current_subscribe &&
+              subscriptionData.current_subscribe.current_subscribe_end_time) {
+            const expiryDateStr = subscriptionData.current_subscribe.current_subscribe_end_time;
+            const [month, day, year] = expiryDateStr.split('/').map(Number);
+            planStartTime = new Date(year, month - 2, day).getTime();
+          }
+
+          const now = Date.now();
+          usageStats = api.calculateUsageStats(
+            billingRecords,
+            planStartTime > 0 ? planStartTime : 0,
+            now
+          );
+        }
+      } catch (billingError) {
+        // 账单数据获取失败不影响主要功能
+        console.error(chalk.gray(`消耗统计获取失败: ${billingError.message}`));
+      }
+
+      const statusBar = new StatusBar(usageData, usageStats, api);
 
       spinner.succeed("状态获取成功");
 

package/cli/status.js

@@ -4,12 +4,56 @@ const { default: boxen } = require('boxen');
 const { default: stringWidth } = require('string-width');
 
 class StatusBar {
-  constructor(data) {
+  constructor(data, usageStats = null, api = null) {
     this.data = data;
+    this.usageStats = usageStats;
+    this.api = api;
     this.totalWidth = 63; // 总宽度包括边框
     this.borderWidth = 4; // '│ ' (2) + ' │' (2) = 4
   }
 
+  // 格式化数字
+  formatNumber(num) {
+    if (this.api) {
+      return this.api.formatNumber(num);
+    }
+    if (num >= 100000000) {
+      return (num / 100000000).toFixed(1).replace(/\.0$/, "") + "亿";
+    }
+    if (num >= 10000) {
+      return (num / 10000).toFixed(1).replace(/\.0$/, "") + "万";
+    }
+    return num.toLocaleString("zh-CN");
+  }
+
+  // 渲染消耗统计表格
+  renderConsumptionStats() {
+    if (!this.usageStats) {
+      return '';
+    }
+
+    const lines = [];
+    lines.push('');
+    lines.push(chalk.bold('📊 Token 消耗统计'));
+
+    // 计算表格宽度
+    const leftWidth = 12; // "昨日消耗:  "
+    const rightWidth = 15; // "1732.1万  "
+    const padding = this.totalWidth - this.borderWidth - leftWidth - rightWidth;
+
+    const pad = ' '.repeat(Math.max(0, padding));
+
+    const formatLine = (label, value) => {
+      return `│ ${chalk.cyan(label)}${pad}${this.formatNumber(value)}`;
+    };
+
+    lines.push(formatLine('昨日消耗: ', this.usageStats.lastDayUsage));
+    lines.push(formatLine('近7天消耗: ', this.usageStats.weeklyUsage));
+    lines.push(formatLine('套餐总消耗: ', this.usageStats.planTotalUsage));
+
+    return lines.join('\n');
+  }
+
   // 辅助函数：填充内容到正确长度，处理 chalk 代码和中文字符
   padLine(leftContent, rightContent) {
     // 移除 chalk 代码以便计算
@@ -72,6 +116,11 @@ class StatusBar {
       contentLines.push(`${chalk.cyan('套餐到期:')} ${expiryText}`);
     }
 
+    // 添加消耗统计（如果有数据）
+    if (this.usageStats) {
+      contentLines.push(this.renderConsumptionStats());
+    }
+
     contentLines.push('');
 
     // 状态行

package/cli/transcript-parser.js

@@ -1,207 +1,207 @@
-#!/usr/bin/env node
-
-const fs = require('fs');
-const path = require('path');
-const readline = require('readline');
-
-class TranscriptParser {
-  constructor() {
-    this.toolMap = new Map();
-    this.agentMap = new Map();
-    this.latestTodos = [];
-  }
-
-  async parse(transcriptPath) {
-    const result = {
-      tools: [],
-      agents: [],
-      todos: [],
-      sessionStart: null,
-      contextTokens: 0,
-    };
-
-    if (typeof transcriptPath !== 'string' || !fs.existsSync(transcriptPath)) {
-      return result;
-    }
-
-    try {
-      const fileStream = fs.createReadStream(transcriptPath);
-      const rl = readline.createInterface({
-        input: fileStream,
-        crlfDelay: Infinity,
-      });
-
-      for await (const line of rl) {
-        if (!line.trim()) continue;
-
-        try {
-          const entry = JSON.parse(line);
-          this.processEntry(entry, result);
-        } catch {
-          // Skip malformed lines
-        }
-      }
-    } catch {
-      // Return partial results on error
-    }
-
-    result.tools = Array.from(this.toolMap.values()).slice(-20);
-    result.agents = Array.from(this.agentMap.values()).slice(-10);
-    result.todos = this.latestTodos;
-
-    return result;
-  }
-
-  processEntry(entry, result) {
-    const timestamp = entry.timestamp ? new Date(entry.timestamp) : new Date();
-
-    if (!result.sessionStart && entry.timestamp) {
-      result.sessionStart = timestamp;
-    }
-
-    const content = entry.message?.content;
-    if (!content || !Array.isArray(content)) return;
-
-    for (const block of content) {
-      if (block.type === 'tool_use' && block.id && block.name) {
-        const toolEntry = {
-          id: block.id,
-          name: block.name,
-          target: this.extractTarget(block.name, block.input),
-          status: 'running',
-          startTime: timestamp,
-        };
-
-        if (block.name === 'Task') {
-          const input = block.input || {};
-          const agentEntry = {
-            id: block.id,
-            type: input.subagent_type || 'unknown',
-            model: input.model,
-            description: input.description,
-            status: 'running',
-            startTime: timestamp,
-          };
-          this.agentMap.set(block.id, agentEntry);
-        } else if (block.name === 'TodoWrite') {
-          const input = block.input || {};
-          if (input.todos && Array.isArray(input.todos)) {
-            this.latestTodos.length = 0;
-            this.latestTodos.push(...input.todos);
-          }
-        } else {
-          this.toolMap.set(block.id, toolEntry);
-        }
-      }
-
-      if (block.type === 'tool_result' && block.tool_use_id) {
-        const tool = this.toolMap.get(block.tool_use_id);
-        if (tool) {
-          tool.status = block.is_error ? 'error' : 'completed';
-          tool.endTime = timestamp;
-        }
-
-        const agent = this.agentMap.get(block.tool_use_id);
-        if (agent) {
-          agent.status = 'completed';
-          agent.endTime = timestamp;
-        }
-      }
-    }
-  }
-
-  extractTarget(toolName, input) {
-    if (!input) return undefined;
-
-    switch (toolName) {
-      case 'Read':
-      case 'Write':
-      case 'Edit':
-        return input.file_path || input.path;
-      case 'Glob':
-        return input.pattern;
-      case 'Grep':
-        return input.pattern;
-      case 'Bash':
-        const cmd = input.command;
-        if (typeof cmd === 'string') {
-          return cmd.slice(0, 30) + (cmd.length > 30 ? '...' : '');
-        }
-        return undefined;
-    }
-    return undefined;
-  }
-
-  calculateContextTokens(usage) {
-    const inputTokens = usage?.input_tokens || usage?.prompt_tokens || 0;
-    const outputTokens = usage?.output_tokens || usage?.completion_tokens || 0;
-    const cacheCreation = usage?.cache_creation_input_tokens || usage?.cache_creation_prompt_tokens || 0;
-    const cacheRead = usage?.cache_read_input_tokens || usage?.cache_read_prompt_tokens || usage?.cached_tokens || 0;
-
-    return inputTokens + outputTokens + cacheCreation + cacheRead;
-  }
-
-  async findLatestUsage(transcriptPath) {
-    if (typeof transcriptPath !== 'string' || !fs.existsSync(transcriptPath)) {
-      return null;
-    }
-
-    try {
-      const fileContent = fs.readFileSync(transcriptPath, 'utf8');
-      const lines = fileContent.trim().split('\n').filter(line => line.trim());
-
-      if (lines.length === 0) {
-        return null;
-      }
-
-      const lastLine = lines[lines.length - 1].trim();
-      const lastEntry = JSON.parse(lastLine);
-
-      if (lastEntry.type === 'summary' && lastEntry.leafUuid) {
-        return this.findUsageByUuid(transcriptPath, lastEntry.leafUuid);
-      }
-
-      for (let i = lines.length - 1; i >= 0; i--) {
-        const line = lines[i].trim();
-        if (!line) continue;
-
-        try {
-          const entry = JSON.parse(line);
-          if (entry.type === 'assistant' && entry.message?.usage) {
-            return this.calculateContextTokens(entry.message.usage);
-          }
-        } catch {
-          continue;
-        }
-      }
-
-      return null;
-    } catch {
-      return null;
-    }
-  }
-
-  async findUsageByUuid(filePath, targetUuid) {
-    try {
-      const fileContent = fs.readFileSync(filePath, 'utf8');
-      const lines = fileContent.trim().split('\n').filter(line => line.trim());
-
-      for (const line of lines) {
-        try {
-          const entry = JSON.parse(line.trim());
-          if (entry.uuid === targetUuid && entry.message?.usage) {
-            return this.calculateContextTokens(entry.message.usage);
-          }
-        } catch {
-          continue;
-        }
-      }
-
-      return null;
-    } catch {
-      return null;
-    }
-  }
-}
-
-module.exports = TranscriptParser;
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+class TranscriptParser {
+  constructor() {
+    this.toolMap = new Map();
+    this.agentMap = new Map();
+    this.latestTodos = [];
+  }
+
+  async parse(transcriptPath) {
+    const result = {
+      tools: [],
+      agents: [],
+      todos: [],
+      sessionStart: null,
+      contextTokens: 0,
+    };
+
+    if (typeof transcriptPath !== 'string' || !fs.existsSync(transcriptPath)) {
+      return result;
+    }
+
+    try {
+      const fileStream = fs.createReadStream(transcriptPath);
+      const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity,
+      });
+
+      for await (const line of rl) {
+        if (!line.trim()) continue;
+
+        try {
+          const entry = JSON.parse(line);
+          this.processEntry(entry, result);
+        } catch {
+          // Skip malformed lines
+        }
+      }
+    } catch {
+      // Return partial results on error
+    }
+
+    result.tools = Array.from(this.toolMap.values()).slice(-20);
+    result.agents = Array.from(this.agentMap.values()).slice(-10);
+    result.todos = this.latestTodos;
+
+    return result;
+  }
+
+  processEntry(entry, result) {
+    const timestamp = entry.timestamp ? new Date(entry.timestamp) : new Date();
+
+    if (!result.sessionStart && entry.timestamp) {
+      result.sessionStart = timestamp;
+    }
+
+    const content = entry.message?.content;
+    if (!content || !Array.isArray(content)) return;
+
+    for (const block of content) {
+      if (block.type === 'tool_use' && block.id && block.name) {
+        const toolEntry = {
+          id: block.id,
+          name: block.name,
+          target: this.extractTarget(block.name, block.input),
+          status: 'running',
+          startTime: timestamp,
+        };
+
+        if (block.name === 'Task') {
+          const input = block.input || {};
+          const agentEntry = {
+            id: block.id,
+            type: input.subagent_type || 'unknown',
+            model: input.model,
+            description: input.description,
+            status: 'running',
+            startTime: timestamp,
+          };
+          this.agentMap.set(block.id, agentEntry);
+        } else if (block.name === 'TodoWrite') {
+          const input = block.input || {};
+          if (input.todos && Array.isArray(input.todos)) {
+            this.latestTodos.length = 0;
+            this.latestTodos.push(...input.todos);
+          }
+        } else {
+          this.toolMap.set(block.id, toolEntry);
+        }
+      }
+
+      if (block.type === 'tool_result' && block.tool_use_id) {
+        const tool = this.toolMap.get(block.tool_use_id);
+        if (tool) {
+          tool.status = block.is_error ? 'error' : 'completed';
+          tool.endTime = timestamp;
+        }
+
+        const agent = this.agentMap.get(block.tool_use_id);
+        if (agent) {
+          agent.status = 'completed';
+          agent.endTime = timestamp;
+        }
+      }
+    }
+  }
+
+  extractTarget(toolName, input) {
+    if (!input) return undefined;
+
+    switch (toolName) {
+      case 'Read':
+      case 'Write':
+      case 'Edit':
+        return input.file_path || input.path;
+      case 'Glob':
+        return input.pattern;
+      case 'Grep':
+        return input.pattern;
+      case 'Bash':
+        const cmd = input.command;
+        if (typeof cmd === 'string') {
+          return cmd.slice(0, 30) + (cmd.length > 30 ? '...' : '');
+        }
+        return undefined;
+    }
+    return undefined;
+  }
+
+  calculateContextTokens(usage) {
+    const inputTokens = usage?.input_tokens || usage?.prompt_tokens || 0;
+    const outputTokens = usage?.output_tokens || usage?.completion_tokens || 0;
+    const cacheCreation = usage?.cache_creation_input_tokens || usage?.cache_creation_prompt_tokens || 0;
+    const cacheRead = usage?.cache_read_input_tokens || usage?.cache_read_prompt_tokens || usage?.cached_tokens || 0;
+
+    return inputTokens + outputTokens + cacheCreation + cacheRead;
+  }
+
+  async findLatestUsage(transcriptPath) {
+    if (typeof transcriptPath !== 'string' || !fs.existsSync(transcriptPath)) {
+      return null;
+    }
+
+    try {
+      const fileContent = fs.readFileSync(transcriptPath, 'utf8');
+      const lines = fileContent.trim().split('\n').filter(line => line.trim());
+
+      if (lines.length === 0) {
+        return null;
+      }
+
+      const lastLine = lines[lines.length - 1].trim();
+      const lastEntry = JSON.parse(lastLine);
+
+      if (lastEntry.type === 'summary' && lastEntry.leafUuid) {
+        return this.findUsageByUuid(transcriptPath, lastEntry.leafUuid);
+      }
+
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (!line) continue;
+
+        try {
+          const entry = JSON.parse(line);
+          if (entry.type === 'assistant' && entry.message?.usage) {
+            return this.calculateContextTokens(entry.message.usage);
+          }
+        } catch {
+          continue;
+        }
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  async findUsageByUuid(filePath, targetUuid) {
+    try {
+      const fileContent = fs.readFileSync(filePath, 'utf8');
+      const lines = fileContent.trim().split('\n').filter(line => line.trim());
+
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line.trim());
+          if (entry.uuid === targetUuid && entry.message?.usage) {
+            return this.calculateContextTokens(entry.message.usage);
+          }
+        } catch {
+          continue;
+        }
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+}
+
+module.exports = TranscriptParser;

package/package.json

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