minimax-status 1.0.0

package/README.md

@@ -0,0 +1,239 @@
+# MiniMax StatusBar
+
+[![npm version](https://img.shields.io/npm/v/minimax-status.svg)](https://www.npmjs.com/package/minimax-status)
+[![npm downloads](https://img.shields.io/npm/dm/minimax-status.svg)](https://www.npmjs.com/package/minimax-status)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+MiniMax Claude Code 使用状态监控工具，支持 CLI 命令和 Claude Code 状态栏集成。
+
+![MiniMax StatusBar](https://img.shields.io/badge/StatusBar-MiniMax-blue?style=flat-square)
+
+## 特性
+
+- ✅ **实时状态监控**: 显示 MiniMax Claude Code 使用额度、剩余次数、重置时间
+- ✅ **多种显示模式**: 详细模式、紧凑模式、持续状态栏
+- ✅ **Claude Code 集成**: 可在 Claude Code 底部状态栏显示
+- ✅ **智能颜色编码**: 根据使用率自动切换颜色和图标
+- ✅ **简洁命令**: `minimax status` 查看状态
+- ✅ **安全存储**: 凭据存储在独立的配置文件中
+
+## 快速开始
+
+### 1. 安装
+
+```bash
+npm install -g minimax-status
+```
+
+### 2. 配置认证
+
+```bash
+minimax auth <token> <groupId>
+```
+
+配置信息将保存在 `~/.minimax-config.json` 文件中。
+
+获取令牌和组 ID:
+
+1. 访问 [MiniMax 开放平台](https://platform.minimaxi.com/user-center/payment/coding-plan)
+2. 登录并进入控制台
+3. 账户信息中复制 groupID
+4. Coding Plan 中创建或获取 API Key
+
+### 3. 查看状态
+
+```bash
+# 详细模式
+minimax status
+
+# 紧凑模式
+minimax status --compact
+
+# 持续监控模式
+minimax status --watch
+```
+
+## Claude Code 集成
+
+将 MiniMax 使用状态显示在 Claude Code 底部状态栏。
+
+### 配置步骤
+
+1. **安装和配置工具**:
+
+   ```bash
+   npm install -g minimax-status
+   minimax auth <token> <groupId>
+   ```
+
+2. **配置 Claude Code**:
+
+   编辑 `~/.claude/settings.json`:
+
+   ```json
+   {
+     "statusLine": {
+       "command": "minimax statusline"
+     }
+   }
+   ```
+
+3. **重启 Claude Code**
+
+集成成功后，底部状态栏将显示:
+
+```
+📁 my-app | 🤖 MiniMax-M2 | 40% | ↻ 2690/4500 | 200K | ⏱️ 35m ✓
+```
+
+显示格式：`📁 目录 | 🤖 模型 | 使用率 | ↻ 剩余次数/总数 | 上下文窗口 | ⏱️ 剩余时间 状态图标`
+
+**注意**: MiniMax 的配置独立存储在 `~/.minimax-config.json`，与 Claude Code 的配置分离。
+
+## 显示示例
+
+### 详细模式
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ MiniMax Claude Code 使用状态                        │
+│                                                             │
+│ 当前模型: MiniMax-M2                          │
+│ 时间窗口: 10:00-15:00(UTC+8)                          │
+│ 剩余时间: 1 小时 26 分钟后重置                  │
+│                                                             │
+│ 已用额度: █████████████████████░░░░░░░░░ 27% │
+│      剩余: 3307/4500 次调用                   │
+│                                                             │
+│ 状态: ✓ 正常使用                                   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### 紧凑模式
+
+```
+● MiniMax-M2 27% • 1 小时 26 分钟后重置 • ✓ 正常使用
+```
+
+### 持续状态栏模式
+
+```
+✓ MiniMax 状态栏已启动
+按 Ctrl+C 退出
+
+[?25l● MiniMax-M2 27% • 3307/4500 • 1h26m ⚡
+```
+
+## 命令说明
+
+| 命令             | 描述                               | 示例                             |
+| ---------------- | ---------------------------------- | -------------------------------- |
+| `minimax auth`   | 设置认证凭据                       | `minimax auth <token> <groupId>` |
+| `minimax status` | 显示当前使用状态（支持 --compact、--watch） | `minimax status`                 |
+| `minimax bar`    | 终端底部持续状态栏                 | `minimax bar`                    |
+| `minimax statusline` | Claude Code 状态栏集成         | 用于 Claude Code 配置            |
+
+## 状态说明
+
+### 状态图标
+
+| 使用率 | 图标 | 含义       |
+| ------ | ---- | ---------- |
+| < 60%  | ✓    | 正常使用   |
+| 60-85% | ⚡   | 注意使用   |
+| ≥ 85%  | ⚠    | 危险状态   |
+
+## 配置文件
+
+### 默认位置
+
+- 独立配置文件: `~/.minimax-config.json`
+
+### 配置示例
+
+```json
+{
+  "token": "your_access_token_here",
+  "groupId": "your_group_id_here"
+}
+```
+
+### Claude Code 配置
+
+Claude Code 只需要配置状态栏命令，不包含 MiniMax 配置：
+
+```json
+// ~/.claude/settings.json
+{
+  "statusLine": {
+    "command": "minimax statusline"
+  }
+}
+```
+
+### 安全说明
+
+凭据仅存储在本地，不会上传到任何服务器。
+
+## 故障排除
+
+### 命令未找到
+
+```bash
+# 确保已全局安装
+npm install -g minimax-status
+
+# 重新打开终端
+```
+
+### 认证失败
+
+```bash
+# 检查令牌和组 ID
+minimax status
+
+# 重新设置认证
+minimax auth <new_token> <new_groupId>
+```
+
+### 状态栏不显示
+
+1. 检查 Claude Code 配置
+2. 重启 Claude Code
+3. 手动测试: `minimax statusline`
+
+## 开发
+
+### 构建项目
+
+```bash
+git clone <repository>
+cd minimax-status
+npm install
+```
+
+### 测试
+
+```bash
+# 运行示例
+node cli/example.js
+
+# 测试 CLI 命令
+node cli/index.js status
+```
+
+## 许可证
+
+MIT License - 详见 [LICENSE](LICENSE) 文件
+
+## 贡献
+
+欢迎提交 Issue 和 Pull Request！
+
+## 相关链接
+
+- [MiniMax 开放平台](https://platform.minimaxi.com/)
+
+---
+
+**注意**: 本工具仅用于监控 MiniMax Claude Code 使用状态，不存储或传输任何用户数据。

package/cli/index.js

@@ -0,0 +1,352 @@
+#!/usr/bin/env node
+
+const { Command } = require("commander");
+const chalk = require("chalk").default;
+const ora = require("ora").default;
+const MinimaxAPI = require("./api");
+const StatusBar = require("./status");
+
+const program = new Command();
+const api = new MinimaxAPI();
+
+program
+  .name("minimax-status")
+  .description("MiniMax Claude Code 使用状态监控工具")
+  .version("1.0.0");
+
+// Auth command
+program
+  .command("auth")
+  .description("设置认证凭据")
+  .argument("<token>", "MiniMax 访问令牌")
+  .argument("<groupId>", "MiniMax 组 ID")
+  .action((token, groupId) => {
+    api.setCredentials(token, groupId);
+    console.log(chalk.green("✓ 认证信息已保存"));
+  });
+
+// Status command
+program
+  .command("status")
+  .description("显示当前使用状态")
+  .option("-c, --compact", "紧凑模式显示")
+  .option("-w, --watch", "实时监控模式")
+  .action(async (options) => {
+    const spinner = ora("获取使用状态中...").start();
+
+    try {
+      const apiData = await api.getUsageStatus();
+      const usageData = api.parseUsageData(apiData);
+      const statusBar = new StatusBar(usageData);
+
+      spinner.succeed("状态获取成功");
+
+      if (options.compact) {
+        console.log(statusBar.renderCompact());
+      } else {
+        console.log("\n" + statusBar.render() + "\n");
+      }
+
+      if (options.watch) {
+        console.log(chalk.gray("监控中... 按 Ctrl+C 退出"));
+        startWatching(api, statusBar);
+      }
+    } catch (error) {
+      spinner.fail(chalk.red("获取状态失败"));
+      console.error(chalk.red(`错误: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// List command
+program
+  .command("list")
+  .description("显示所有模型的使用状态")
+  .action(async () => {
+    const spinner = ora("获取使用状态中...").start();
+
+    try {
+      const apiData = await api.getUsageStatus();
+      const usageData = api.parseUsageData(apiData);
+      const statusBar = new StatusBar(usageData);
+
+      spinner.succeed("状态获取成功");
+      console.log("\n" + statusBar.render() + "\n");
+    } catch (error) {
+      spinner.fail(chalk.red("获取状态失败"));
+      console.error(chalk.red(`错误: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// StatusBar command - 持续显示在终端底部
+program
+  .command("bar")
+  .description("在终端底部持续显示状态栏（类似 ccline）")
+  .action(async () => {
+    const TerminalStatusBar = require("./statusbar");
+    const statusBar = new TerminalStatusBar();
+    await statusBar.start();
+  });
+
+// 上下文窗口大小映射表（仅MiniMax模型）
+const MODEL_CONTEXT_SIZES = {
+  "minimax-m2": 200000,
+  "minimax-m2-stable": 200000,
+  "minimax-m1": 200000,
+  "minimax-m1-stable": 200000,
+};
+
+// 解析转录文件，借鉴ccline的实现
+async function parseTranscriptUsage(transcriptPath) {
+  const fs = require('fs').promises;
+  const path = require('path');
+
+  try {
+    const fileContent = await fs.readFile(transcriptPath, 'utf8');
+    const lines = fileContent.trim().split('\n');
+
+    if (lines.length === 0) {
+      return null;
+    }
+
+    // 解析最后一行JSON
+    const lastLine = lines[lines.length - 1].trim();
+    const lastEntry = JSON.parse(lastLine);
+
+    // 如果是summary类型，查找usage
+    if (lastEntry.type === 'summary' && lastEntry.leafUuid) {
+      // 在所有行中查找对应的leafUuid
+      for (let i = lines.length - 2; i >= 0; i--) {
+        const entry = JSON.parse(lines[i].trim());
+        if (entry.leafUuid === lastEntry.leafUuid) {
+          if (entry.message && entry.message.usage) {
+            return calculateUsageTokens(entry.message.usage);
+          }
+          break;
+        }
+      }
+    }
+
+    // 查找最新的assistant消息
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line) continue;
+
+      const entry = JSON.parse(line);
+      if (entry.type === 'assistant' && entry.message) {
+        if (entry.message.usage) {
+          return calculateUsageTokens(entry.message.usage);
+        }
+      }
+    }
+
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+// 计算token使用量（参考ccline的normalize逻辑）
+function calculateUsageTokens(usage) {
+  // 根据不同格式计算display tokens
+  if (usage.total_tokens) {
+    return usage.total_tokens;
+  } else if (usage.input_tokens && usage.output_tokens) {
+    return usage.input_tokens + usage.output_tokens;
+  } else if (usage.context_tokens) {
+    return usage.context_tokens;
+  } else if (usage.cache_creation_input_tokens && usage.cache_read_input_tokens) {
+    return usage.input_tokens + usage.cache_creation_input_tokens + usage.cache_read_input_tokens;
+  }
+  return 0;
+}
+
+// Statusline command
+program
+  .command("statusline")
+  .description("Claude Code状态栏集成（从stdin读取数据，输出单行状态）")
+  .action(async () => {
+    try {
+      // 读取stdin数据（如果可用）
+      let stdinData = null;
+      if (!process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+          chunks.push(chunk);
+        }
+        const stdinString = Buffer.concat(chunks).toString();
+        if (stdinString.trim()) {
+          try {
+            stdinData = JSON.parse(stdinString);
+          } catch (e) {
+            // 忽略JSON解析错误
+          }
+        }
+      }
+
+      // 获取使用状态
+      const apiData = await api.getUsageStatus();
+      const usageData = api.parseUsageData(apiData);
+
+      // 构建状态信息
+      const { usage, modelName, remaining } = usageData;
+      const percentage = usage.percentage;
+
+      // 从stdin数据获取Claude Code信息
+      let displayModel = modelName;
+      let currentDir = null;
+      let modelId = null;
+      let contextSize = 200000; // 默认值
+
+      // 获取CLI当前目录
+      const cliCurrentDir = process.cwd().split(/[\\/]/).pop();
+
+      if (stdinData) {
+        // Claude Code传递的模型信息
+        if (stdinData.model && stdinData.model.display_name) {
+          displayModel = stdinData.model.display_name;
+          modelId = stdinData.model.id;
+        } else if (stdinData.model && stdinData.model.id) {
+          displayModel = stdinData.model.id;
+          modelId = stdinData.model.id;
+        }
+
+        // 当前工作目录（从stdin获取）
+        if (stdinData.workspace && stdinData.workspace.current_directory) {
+          currentDir = stdinData.workspace.current_directory.split('/').pop();
+        }
+      } else {
+        // 如果没有stdin，使用API返回的模型名作为ID
+        modelId = modelName.toLowerCase().replace(/\s+/g, '-');
+      }
+
+      // 查找上下文窗口大小
+      if (modelId) {
+        const modelKey = modelId.toLowerCase();
+        for (const [key, value] of Object.entries(MODEL_CONTEXT_SIZES)) {
+          if (modelKey.includes(key.toLowerCase())) {
+            contextSize = value;
+            break;
+          }
+        }
+      }
+
+      // 尝试从转录文件获取真实token使用量（类似ccline）
+      let contextUsageTokens = null;
+      let contextUsagePercentage = null;
+      if (stdinData && stdinData.transcript_path) {
+        contextUsageTokens = await parseTranscriptUsage(stdinData.transcript_path);
+        if (contextUsageTokens) {
+          contextUsagePercentage = Math.round((contextUsageTokens / contextSize) * 100);
+        }
+      }
+
+      const formatContextSize = (size) => {
+        if (size >= 1000000) {
+          return `${Math.round(size / 100000) / 10}M`;
+        } else if (size >= 1000) {
+          return `${Math.round(size / 1000)}K`;
+        }
+        return `${size}`;
+      };
+
+      const formatTokens = (tokens) => {
+        if (tokens >= 1000000) {
+          return `${Math.round(tokens / 100000) / 10}M`;
+        } else if (tokens >= 1000) {
+          return `${Math.round(tokens / 100) / 10}k`;
+        }
+        return `${tokens}`;
+      };
+
+      const contextSizeText = formatContextSize(contextSize);
+
+      // 状态图标（基于真实上下文使用情况，否则基于额度）
+      const displayPercentage = contextUsagePercentage || percentage;
+      const statusIcon = displayPercentage >= 85 ? "⚠" : displayPercentage >= 60 ? "⚡" : "✓";
+
+      // 剩余时间文本
+      const remainingText =
+        remaining.hours > 0
+          ? `${remaining.hours}h${remaining.minutes}m`
+          : `${remaining.minutes}m`;
+
+      // 构建带图标的状态行
+      let statusLine = '';
+
+      // 显示目录（优先使用Claude Code的目录，否则显示CLI当前目录）
+      const displayDir = currentDir || cliCurrentDir || '';
+      if (displayDir) {
+        statusLine += `📁 ${displayDir} | `;
+      }
+
+      // 模型信息
+      statusLine += `🤖 ${displayModel} | `;
+
+      // 账户使用额度百分比
+      statusLine += `${percentage}% | `;
+
+      // 剩余次数 - 使用更简洁的图标
+      statusLine += `↻ ${usage.used}/${usage.total} | `;
+
+      // 上下文使用情况（参考ccline：⚡ 百分比 · token数/总大小）
+      if (contextUsageTokens) {
+        statusLine += `⚡ ${displayPercentage}% · ${formatTokens(contextUsageTokens)}/${contextSizeText} | `;
+      } else {
+        // 没有转录数据时，显示上下文窗口大小
+        statusLine += `${contextSizeText} | `;
+      }
+
+      // 剩余时间和状态图标
+      statusLine += `⏱ ${remainingText} ${statusIcon}`;
+
+      // 输出单行状态（纯文本，无颜色）
+      console.log(statusLine);
+    } catch (error) {
+      // 输出错误状态（纯文本）
+      console.log(`❌ MiniMax 错误: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+function startWatching(api, statusBar) {
+  let intervalId;
+
+  const update = async () => {
+    try {
+      const apiData = await api.getUsageStatus();
+      const usageData = api.parseUsageData(apiData);
+      const newStatusBar = new StatusBar(usageData);
+
+      // Clear previous output
+      process.stdout.write("\x1Bc");
+
+      console.log("\n" + newStatusBar.render() + "\n");
+      console.log(chalk.gray(`最后更新: ${new Date().toLocaleTimeString()}`));
+    } catch (error) {
+      console.error(chalk.red(`更新失败: ${error.message}`));
+    }
+  };
+
+  // Initial update
+  update();
+
+  // Update every 30 seconds
+  intervalId = setInterval(update, 30000);
+
+  // Handle Ctrl+C
+  process.on("SIGINT", () => {
+    clearInterval(intervalId);
+    console.log(chalk.yellow("\n监控已停止"));
+    process.exit(0);
+  });
+}
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+  process.exit(1);
+}
+
+program.parse();

package/cli/statusbar.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+const chalk = require('chalk').default;
+const readline = require('readline');
+const MinimaxAPI = require('./api');
+
+class StatusBar {
+  constructor(data) {
+    this.data = data;
+  }
+
+  render() {
+    const { usage, remaining, modelName } = this.data;
+    const percentage = usage.percentage;
+
+    // 基于已使用百分比：使用越多越危险
+    let color = chalk.green;
+    if (percentage >= 85) {
+      color = chalk.red;
+    } else if (percentage >= 60) {
+      color = chalk.yellow;
+    }
+
+    const statusIcon = percentage >= 85 ? '⚠' : percentage >= 60 ? '⚡' : '✓';
+    const remainingText = remaining.hours > 0
+      ? `${remaining.hours}h${remaining.minutes}m`
+      : `${remaining.minutes}m`;
+
+    return `${color('●')} ${modelName} ${color(percentage + '%')} (${usage.used}/${usage.total}) ${remainingText} ${statusIcon}`;
+  }
+}
+
+class TerminalStatusBar {
+  constructor() {
+    this.api = new MinimaxAPI();
+    this.currentLine = '';
+    this.isActive = false;
+  }
+
+  async start() {
+    const configPath = require('path').join(
+      process.env.HOME || process.env.USERPROFILE,
+      '.minimax-config.json'
+    );
+
+    if (!require('fs').existsSync(configPath)) {
+      console.log(chalk.red('错误：未找到配置文件'));
+      console.log(chalk.yellow('请先运行: minimax-status auth <token> <groupId>'));
+      process.exit(1);
+    }
+
+    this.isActive = true;
+    console.log(chalk.green('✓ MiniMax 状态栏已启动'));
+    console.log(chalk.gray('按 Ctrl+C 退出\n'));
+
+    // 隐藏光标
+    process.stdout.write('\x1B[?25l');
+    this.startUpdating();
+  }
+
+  async startUpdating() {
+    const update = async () => {
+      if (!this.isActive) return;
+
+      try {
+        const apiData = await this.api.getUsageStatus();
+        const usageData = this.api.parseUsageData(apiData);
+        const statusBar = new StatusBar(usageData);
+        const newLine = statusBar.render();
+
+        // 清除上一行并显示新状态
+        if (this.currentLine) {
+          readline.clearLine(process.stdout, 0);
+          readline.cursorTo(process.stdout, 0);
+        }
+
+        process.stdout.write(newLine);
+        this.currentLine = newLine;
+
+        // 移动光标到底部下一行
+        process.stdout.write('\n');
+        readline.cursorTo(process.stdout, 0);
+
+      } catch (error) {
+        // 显示错误但不退出
+        readline.clearLine(process.stdout, 0);
+        readline.cursorTo(process.stdout, 0);
+        process.stdout.write(chalk.red(`错误: ${error.message}`));
+        process.stdout.write('\n');
+        readline.cursorTo(process.stdout, 0);
+      }
+    };
+
+    // 立即更新一次
+    await update();
+
+    // 每 30 秒更新
+    setInterval(update, 30000);
+
+    // 处理 Ctrl+C
+    process.on('SIGINT', () => {
+      this.stop();
+    });
+
+    // 处理进程退出
+    process.on('exit', () => {
+      this.cleanup();
+    });
+  }
+
+  stop() {
+    this.isActive = false;
+    console.log(chalk.yellow('\n\n状态栏已停止'));
+    this.cleanup();
+    process.exit(0);
+  }
+
+  cleanup() {
+    // 显示光标
+    process.stdout.write('\x1B[?25h');
+
+    // 清除状态行
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+  }
+}
+
+// 如果直接运行此文件
+if (require.main === module) {
+  const statusBar = new TerminalStatusBar();
+  statusBar.start().catch(error => {
+    console.error(chalk.red('启动失败:'), error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = TerminalStatusBar;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "minimax-status",
+  "version": "1.0.0",
+  "description": "MiniMax Claude Code 使用状态监控工具",
+  "bin": {
+    "minimax-status": "./cli/index.js",
+    "minimax": "./cli/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "minimax",
+    "claude",
+    "status",
+    "monitor"
+  ],
+  "author": "Jochen Yang",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.13.2",
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "dayjs": "^1.11.19",
+    "ora": "^9.0.0"
+  }
+}

package/vscode-extension/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "minimax-status-vscode",
+  "displayName": "MiniMax Status",
+  "description": "在 VS Code 状态栏显示 MiniMax Claude Code 使用状态",
+  "version": "1.0.0",
+  "publisher": "your-name",
+  "engines": {
+    "vscode": "^1.74.0"
+  },
+  "categories": [
+    "Other"
+  ],
+  "activationEvents": [
+    "onStartupFinished"
+  ],
+  "main": "./extension.js",
+  "contributes": {
+    "configuration": {
+      "title": "MiniMax Status",
+      "properties": {
+        "minimaxStatus.token": {
+          "type": "string",
+          "default": "",
+          "description": "MiniMax 访问令牌",
+          "order": 1
+        },
+        "minimaxStatus.groupId": {
+          "type": "string",
+          "default": "",
+          "description": "MiniMax 组 ID",
+          "order": 2
+        },
+        "minimaxStatus.refreshInterval": {
+          "type": "number",
+          "default": 30,
+          "description": "刷新间隔（秒）",
+          "order": 3
+        },
+        "minimaxStatus.showTooltip": {
+          "type": "boolean",
+          "default": true,
+          "description": "显示详细提示信息",
+          "order": 4
+        }
+      }
+    }
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "pretest": "npm run lint",
+    "test": "node ./test/runTest.js",
+    "package": "vsce package"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.74.0",
+    "eslint": "^8.56.0",
+    "@vscode/vsce": "^2.22.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.2"
+  },
+  "keywords": [
+    "minimax",
+    "status",
+    "claude"
+  ],
+  "author": "",
+  "license": "ISC"
+}