kimi-quota-line 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.1.0
+
+- Initial public release of `glm-quota-line`
+- Added Claude Code status line integration with `install` and `uninstall`
+- Added `text`, `compact`, and `bar` styles
+- Added `config set` and `config show`
+- Added official auth variable compatibility for `ANTHROPIC_AUTH_TOKEN` and `ANTHROPIC_BASE_URL`
+- Added 5 minute lazy refresh with per-session first refresh

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 caojian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# kimi-quota-line
+
+English | [中文文档](README.zh-CN.md)
+
+A lightweight CLI for Claude Code status bar to display Moonshot Kimi Code usage quota.
+
+Inspired by [glm-quota-line](https://github.com/deluo/glm-quota-line), modified to support Kimi.
+
+It fetches the quota API, caches successful results, and outputs a single line suitable for display in the status bar.
+
+## Features
+
+- Compatible with Claude Code `statusLine.command`
+- Uses API Key for Kimi authentication (via `ANTHROPIC_AUTH_TOKEN`)
+- Force refresh on first session, then cache for 5 minutes
+- Supports three styles: `text`, `compact`, and `bar`
+- Auto-install and uninstall Claude Code status bar configuration
+
+## Display Styles
+
+### `bar` (Default)
+
+```text
+Kimi ■□□□□□□□□□ 91% | 14:47
+```
+
+### `text`
+
+```text
+Kimi | 91% left | reset 14:47
+```
+
+### `compact`
+
+```text
+Kimi 91% | 14:47
+```
+
+Legend:
+
+- `■` = Used
+- `□` = Remaining
+
+## Installation
+
+Install from local repository:
+
+```bash
+npm install -g .
+```
+
+Or install from npm (when published):
+
+```bash
+npm install -g kimi-quota-line
+```
+
+## Usage
+
+Install Claude Code status bar:
+
+```bash
+kimi-quota-line install
+```
+
+Switch styles (default is `bar`):
+
+```bash
+kimi-quota-line config set style text
+kimi-quota-line config set style compact
+kimi-quota-line config set style bar
+```
+
+Switch display modes:
+
+```bash
+kimi-quota-line config set display left    # Show remaining percentage
+kimi-quota-line config set display used    # Show used percentage
+kimi-quota-line config set display both    # Show both
+```
+
+View current configuration:
+
+```bash
+kimi-quota-line config show
+```
+
+Uninstall status bar:
+
+```bash
+kimi-quota-line uninstall
+```
+
+## Environment Variables
+
+Required:
+
+- `ANTHROPIC_AUTH_TOKEN` - Claude Code official environment variable. Set this to your Kimi Code API Key. If you already configured Claude Code with this variable, no additional setup is needed:
+  ```bash
+  export ANTHROPIC_BASE_URL=https://api.kimi.com/coding/
+  export ANTHROPIC_AUTH_TOKEN=sk-your-kimi-api-key
+  export ANTHROPIC_MODEL="kimi-k2.5"
+  export ANTHROPIC_DEFAULT_OPUS_MODEL="kimi-k2.5"
+  export ANTHROPIC_DEFAULT_SONNET_MODEL="kimi-k2.5"
+  export ANTHROPIC_DEFAULT_HAIKU_MODEL="kimi-k2.5"
+  export CLAUDE_CODE_SUBAGENT_MODEL="kimi-k2.5"
+  export ENABLE_TOOL_SEARCH="false"
+  claude
+  ```
+
+Optional:
+
+- `ANTHROPIC_BASE_URL` - Set to `https://api.kimi.com/coding/v1` for Kimi Code platform
+- `KIMI_API_KEY` - Alternative way, same as `ANTHROPIC_AUTH_TOKEN`
+
+## Getting API Key
+
+1. Visit [Kimi Code](https://kimi.com)
+2. Go to Settings
+3. Find API Key management and create a new API Key
+4. Set it as environment variable: `export ANTHROPIC_AUTH_TOKEN="your-api-key"`
+
+## Notes
+
+- Displays a single line by default, suitable for bottom status bar
+- Shows `Kimi | auth expired` when authentication fails
+- Shows `Kimi | quota unavailable` when API is unavailable
+- `install` won't overwrite existing non-tool `statusLine` by default
+- `install --force` overwrites and backs up original config, `uninstall` can restore it
+- Supports Kimi Code platform API (`https://api.kimi.com/coding/v1`)

package/README.zh-CN.md

@@ -0,0 +1,130 @@
+# kimi-quota-line
+
+[English](README.md) | 中文文档
+
+`kimi-quota-line` 是一个给 Claude Code 底部状态栏使用的轻量 CLI，用来显示 Moonshot Kimi Code 的使用配额状态。
+
+本项目借鉴自 [glm-quota-line](https://github.com/deluo/glm-quota-line) 并修改以支持 Kimi。
+
+它会读取配额接口、缓存成功结果，并输出一行适合状态栏展示的短文本。
+
+## 功能
+
+- 适配 Claude Code `statusLine.command`
+- 通过 API Key 进行 Kimi 身份验证（使用 `ANTHROPIC_AUTH_TOKEN`）
+- 新会话首次强制刷新，之后 5 分钟内走缓存
+- 支持 `text`、`compact`、`bar` 三种样式
+- 支持自动安装和卸载 Claude Code 的状态栏配置
+
+## 展示效果
+
+### `bar`（默认）
+
+```text
+Kimi ■□□□□□□□□□ 91% | 14:47
+```
+
+### `text`
+
+```text
+Kimi | 91% left | reset 14:47
+```
+
+### `compact`
+
+```text
+Kimi 91% | 14:47
+```
+
+说明：
+
+- `■` 表示已用
+- `□` 表示未用
+
+## 安装
+
+本地仓库安装：
+
+```bash
+npm install -g .
+```
+
+npm 发布后安装：
+
+```bash
+npm install -g kimi-quota-line
+```
+
+## 使用
+
+安装 Claude Code 状态栏：
+
+```bash
+kimi-quota-line install
+```
+
+切换样式（默认为 `bar`）：
+
+```bash
+kimi-quota-line config set style text
+kimi-quota-line config set style compact
+kimi-quota-line config set style bar
+```
+
+切换显示模式：
+
+```bash
+kimi-quota-line config set display left    # 显示剩余百分比
+kimi-quota-line config set display used    # 显示已用百分比
+kimi-quota-line config set display both    # 两者都显示
+```
+
+查看当前配置：
+
+```bash
+kimi-quota-line config show
+```
+
+卸载状态栏：
+
+```bash
+kimi-quota-line uninstall
+```
+
+## 环境变量
+
+必需：
+
+- `ANTHROPIC_AUTH_TOKEN` - Claude Code 官方环境变量，设置为你的 Kimi Code API Key。如果你配置 Claude Code 时已经使用了此变量，则无需重复设置：
+  ```bash
+  export ANTHROPIC_BASE_URL=https://api.kimi.com/coding/
+  export ANTHROPIC_AUTH_TOKEN=sk-your-kimi-api-key
+  export ANTHROPIC_MODEL="kimi-k2.5"
+  export ANTHROPIC_DEFAULT_OPUS_MODEL="kimi-k2.5"
+  export ANTHROPIC_DEFAULT_SONNET_MODEL="kimi-k2.5"
+  export ANTHROPIC_DEFAULT_HAIKU_MODEL="kimi-k2.5"
+  export CLAUDE_CODE_SUBAGENT_MODEL="kimi-k2.5"
+  export ENABLE_TOOL_SEARCH="false"
+  claude
+  ```
+
+可选：
+
+- `ANTHROPIC_BASE_URL` - 设置为 `https://api.kimi.com/coding/v1` (Kimi Code 平台)
+- `KIMI_API_KEY` - 备选方式，与 `ANTHROPIC_AUTH_TOKEN` 作用相同
+
+## 获取 API Key
+
+1. 访问 [Kimi Code](https://kimi.com)
+2. 进入设置页面
+3. 找到 API Key 管理，创建新的 API Key
+4. 将 API Key 设置为环境变量：`export ANTHROPIC_AUTH_TOKEN="your-api-key"`
+
+## 说明
+
+- 默认只显示一行文本，适合底部状态栏
+- 鉴权失效时显示 `Kimi | auth expired`
+- 接口异常时显示 `Kimi | quota unavailable`
+- `install` 默认不会覆盖已有的非本工具 `statusLine`
+- `install --force` 会覆盖并备份原配置，`uninstall` 时可恢复
+- 支持 Kimi Code 平台 API (`https://api.kimi.com/coding/v1`)

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "kimi-quota-line",
+  "version": "0.1.0",
+  "description": "Claude Code status line helper for Kimi Code usage quota.",
+  "type": "module",
+  "license": "MIT",
+  "author": "MaBing",
+  "preferGlobal": true,
+  "keywords": [
+    "claude-code",
+    "statusline",
+    "kimi",
+    "moonshot",
+    "quota",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/usernameisnull/kimi-quote-line.git"
+  },
+  "homepage": "https://github.com/usernameisnull/kimi-quote-line#readme",
+  "bugs": {
+    "url": "https://github.com/usernameisnull/kimi-quote-line/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "scripts",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "bin": {
+    "kimi-quota-line": "src/cli.js"
+  },
+  "scripts": {
+    "start": "node ./src/cli.js",
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/status-line.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "../src/cli.js";

package/src/cache.js

@@ -0,0 +1,81 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+function isSuccessCacheShape(value) {
+  if (!value || value.kind !== "success" || typeof value.level !== "string") {
+    return false;
+  }
+
+  if (!Number.isFinite(value.nextResetTime)) {
+    return false;
+  }
+
+  if (value.display === "percent") {
+    return Number.isFinite(value.leftPercent);
+  }
+
+  if (value.display === "absolute") {
+    return Number.isFinite(value.remaining) && Number.isFinite(value.total);
+  }
+
+  return false;
+}
+
+function isValidThreadId(value) {
+  return value === undefined || typeof value === "string";
+}
+
+export async function readCache(cacheFilePath) {
+  try {
+    const raw = await fs.readFile(cacheFilePath, "utf8");
+    const parsed = JSON.parse(raw);
+
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+
+    if (
+      !Number.isFinite(parsed.savedAt) ||
+      !isValidThreadId(parsed.threadId) ||
+      !isSuccessCacheShape(parsed.result)
+    ) {
+      return null;
+    }
+
+    return parsed;
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return null;
+    }
+
+    return null;
+  }
+}
+
+export async function readFreshCache(cacheFilePath, ttlMs, threadId = "", now = Date.now()) {
+  const cached = await readCache(cacheFilePath);
+  if (!cached) {
+    return null;
+  }
+
+  if (threadId && cached.threadId !== threadId) {
+    return null;
+  }
+
+  return now - cached.savedAt <= ttlMs ? cached : null;
+}
+
+export async function writeSuccessCache(cacheFilePath, result, threadId = "", now = Date.now()) {
+  const payload = JSON.stringify(
+    {
+      savedAt: now,
+      threadId,
+      result
+    },
+    null,
+    2
+  );
+
+  await fs.mkdir(path.dirname(cacheFilePath), { recursive: true });
+  await fs.writeFile(cacheFilePath, payload, "utf8");
+}

package/src/cli.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+import { loadConfig } from "./config.js";
+import { formatStatus } from "./formatStatus.js";
+import { parseArgs } from "./parseArgs.js";
+import { getSessionId, readStatusLineInput } from "./readStatusLineInput.js";
+import { runQuotaLine } from "./runQuotaLine.js";
+import {
+  getToolConfigPath,
+  installClaudeStatusLine,
+  readToolConfig,
+  setToolConfigValue,
+  uninstallClaudeStatusLine
+} from "./userConfig.js";
+
+function printHelp() {
+  process.stdout.write(`kimi-quota-line
+
+Usage:
+  kimi-quota-line [--style text|compact|bar] [--display left|used|both]
+  kimi-quota-line install [--force]
+  kimi-quota-line uninstall
+  kimi-quota-line config set style <text|compact|bar>
+  kimi-quota-line config set display <left|used|both>
+  kimi-quota-line config show
+
+Environment:
+  KIMI_AUTHORIZATION   # Kimi 的 Authorization token (必需)
+  ANTHROPIC_BASE_URL
+  KIMI_DISPLAY_MODE
+  KIMI_STYLE
+  KIMI_BAR_WIDTH
+  KIMI_TIMEOUT_MS
+  KIMI_CACHE_TTL_MS
+`);
+}
+
+function validateStyle(value) {
+  return value === "text" || value === "compact" || value === "bar";
+}
+
+function validateDisplay(value) {
+  return value === "left" || value === "used" || value === "both";
+}
+
+async function handleCommand(args) {
+  const [command, subcommand, key, value] = args.positionals;
+
+  if (command === "install") {
+    const result = await installClaudeStatusLine(undefined, undefined, undefined, {
+      force: Boolean(args.force)
+    });
+    if (!result.installed && result.reason === "unmanaged_exists") {
+      process.stdout.write(
+        `Skipped install because Claude Code already has an unmanaged statusLine.\nsettings: ${result.settingsPath}\nRun 'kimi-quota-line install --force' to replace it and back it up.\n`
+      );
+      return true;
+    }
+
+    process.stdout.write(
+      `Installed Claude Code status line.\nsettings: ${result.settingsPath}\ncommand: ${result.command}\n`
+    );
+    return true;
+  }
+
+  if (command === "uninstall") {
+    const result = await uninstallClaudeStatusLine();
+    if (result.removed) {
+      process.stdout.write(`Removed Claude Code status line.\nsettings: ${result.settingsPath}\n`);
+      return true;
+    }
+
+    if (result.reason === "unmanaged") {
+      process.stdout.write(
+        `Skipped uninstall because current statusLine is not managed by kimi-quota-line.\nsettings: ${result.settingsPath}\n`
+      );
+      return true;
+    }
+
+    process.stdout.write(`No Claude Code status line was configured.\nsettings: ${result.settingsPath}\n`);
+    return true;
+  }
+  
+  if (command === "config" && subcommand === "show") {
+    const config = await readToolConfig();
+    process.stdout.write(`${JSON.stringify(config, null, 2)}\n`);
+    return true;
+  }
+
+  if (command === "config" && subcommand === "set") {
+    if (key === "style") {
+      if (!validateStyle(value)) {
+        process.stdout.write("Invalid style. Use: text, compact, or bar.\n");
+        return true;
+      }
+
+      const config = await setToolConfigValue("style", value);
+      process.stdout.write(`Saved style=${config.style}\nconfig: ${getToolConfigPath()}\n`);
+      return true;
+    }
+
+    if (key === "display") {
+      if (!validateDisplay(value)) {
+        process.stdout.write("Invalid display. Use: left, used, or both.\n");
+        return true;
+      }
+
+      const config = await setToolConfigValue("displayMode", value);
+      process.stdout.write(`Saved display=${config.displayMode}\nconfig: ${getToolConfigPath()}\n`);
+      return true;
+    }
+
+    process.stdout.write("Supported config keys: style, display\n");
+    return true;
+  }
+
+  return false;
+}
+
+async function main() {
+  try {
+    const args = parseArgs();
+    if (args.help) {
+      printHelp();
+      return;
+    }
+
+    if (await handleCommand(args)) {
+      return;
+    }
+
+    const statusLineInput = await readStatusLineInput();
+    const userConfig = await readToolConfig();
+    
+    // Claude Code passes env vars via statusLineInput.env
+    const envVars = statusLineInput?.env || process.env;
+    const config = {
+      ...loadConfig(envVars),
+      ...(validateStyle(userConfig.style) ? { style: userConfig.style } : {}),
+      ...(validateDisplay(userConfig.displayMode) ? { displayMode: userConfig.displayMode } : {}),
+      ...args,
+      threadId: getSessionId(statusLineInput)
+    };
+    const finalResult = await runQuotaLine(config);
+
+    process.stdout.write(
+      `${formatStatus(finalResult, {
+        displayMode: config.displayMode,
+        style: config.style,
+        barWidth: config.barWidth
+      })}\n`
+    );
+  } catch {
+    process.stdout.write("Kimi | quota unavailable\n");
+  }
+}
+
+await main();

package/src/config.js

@@ -0,0 +1,71 @@
+import os from "node:os";
+import path from "node:path";
+
+const DEFAULT_QUOTA_URL = "https://api.kimi.com/coding/v1/usages";
+const DEFAULT_TIMEOUT_MS = 5000;
+const DEFAULT_CACHE_TTL_MS = 300_000;
+const DEFAULT_DISPLAY_MODE = "left";
+const DEFAULT_STYLE = "bar";
+const DEFAULT_BAR_WIDTH = 10;
+
+function parsePositiveInt(value, fallback) {
+  if (value === undefined || value === null || value === "") {
+    return fallback;
+  }
+
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function getCacheRoot() {
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Caches");
+  }
+
+  if (process.platform === "win32") {
+    return process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+  }
+
+  return process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+}
+
+function deriveQuotaUrl(baseUrl) {
+  if (!baseUrl) {
+    return "";
+  }
+
+  try {
+    const parsedBaseUrl = new URL(baseUrl);
+
+    // Kimi Code platform
+    if (parsedBaseUrl.host.includes("api.kimi.com")) {
+      return `${baseUrl.replace(/\/$/, "")}/usages`;
+    }
+  } catch {
+    return "";
+  }
+
+  return "";
+}
+
+export function loadConfig(env = process.env) {
+  const cacheRoot = getCacheRoot();
+  const anthropicBaseUrl = env.ANTHROPIC_BASE_URL || "";
+  const derivedQuotaUrl = deriveQuotaUrl(anthropicBaseUrl);
+  
+  // Use ANTHROPIC_AUTH_TOKEN (Claude Code official) as Kimi API Key
+  const apiKey = env.ANTHROPIC_AUTH_TOKEN || env.KIMI_API_KEY || env.KIMI_AUTHORIZATION || "";
+
+  return {
+    quotaUrl: derivedQuotaUrl || DEFAULT_QUOTA_URL,
+    apiKey,
+    anthropicBaseUrl,
+    timeoutMs: parsePositiveInt(env.KIMI_TIMEOUT_MS, DEFAULT_TIMEOUT_MS),
+    cacheTtlMs: parsePositiveInt(env.KIMI_CACHE_TTL_MS, DEFAULT_CACHE_TTL_MS),
+    displayMode: env.KIMI_DISPLAY_MODE || DEFAULT_DISPLAY_MODE,
+    style: env.KIMI_STYLE || DEFAULT_STYLE,
+    barWidth: parsePositiveInt(env.KIMI_BAR_WIDTH, DEFAULT_BAR_WIDTH),
+    cacheFilePath: path.join(cacheRoot, "kimi-quota-line", "cache.json"),
+    threadId: env.CODEX_THREAD_ID || ""
+  };
+}

package/src/fetchQuota.js

@@ -0,0 +1,29 @@
+export async function fetchQuota(config, fetchImpl = globalThis.fetch) {
+  if (typeof fetchImpl !== "function") {
+    return { kind: "unavailable" };
+  }
+
+  try {
+    const response = await fetchImpl(config.quotaUrl, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${config.apiKey}`
+      },
+      signal: AbortSignal.timeout(config.timeoutMs)
+    });
+
+    const text = await response.text();
+    let json;
+
+    try {
+      json = JSON.parse(text);
+    } catch {
+      return { kind: "unavailable" };
+    }
+
+    return { kind: "json", status: response.status, json };
+  } catch {
+    return { kind: "unavailable" };
+  }
+}

package/src/formatStatus.js

@@ -0,0 +1,156 @@
+function padTwoDigits(value) {
+  return String(value).padStart(2, "0");
+}
+
+function formatLevel(level) {
+  if (!level) {
+    return "Kimi";
+  }
+
+  return `Kimi ${level.charAt(0).toUpperCase()}${level.slice(1)}`;
+}
+
+function formatCompactLabel() {
+  return "Kimi";
+}
+
+function formatResetTime(timestampMs) {
+  const date = new Date(timestampMs);
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+
+  return `${padTwoDigits(date.getHours())}:${padTwoDigits(date.getMinutes())}`;
+}
+
+function normalizeDisplayMode(displayMode) {
+  return displayMode === "used" || displayMode === "both" ? displayMode : "left";
+}
+
+function normalizeStyle(style) {
+  return style === "compact" || style === "bar" ? style : "text";
+}
+
+function normalizeBarWidth(barWidth) {
+  if (!Number.isFinite(barWidth)) {
+    return 10;
+  }
+
+  return Math.min(20, Math.max(5, Math.round(barWidth)));
+}
+
+function buildBar(usedPercent, barWidth) {
+  const safePercent = Math.min(100, Math.max(0, usedPercent));
+  const width = normalizeBarWidth(barWidth);
+  let filled;
+  if (safePercent <= 0) {
+    filled = 0;
+  } else if (safePercent >= 100) {
+    filled = width;
+  } else {
+    filled = Math.min(width - 1, Math.max(1, Math.floor((safePercent / 100) * width)));
+  }
+  return `${"■".repeat(filled)}${"□".repeat(width - filled)}`;
+}
+
+function formatPercentStatus(result, resetTime, displayMode) {
+  const mode = normalizeDisplayMode(displayMode);
+
+  if (mode === "used" && Number.isFinite(result.usedPercent)) {
+    return `${formatLevel(result.level)} | ${result.usedPercent}% used | reset ${resetTime}`;
+  }
+
+  if (
+    mode === "both" &&
+    Number.isFinite(result.leftPercent) &&
+    Number.isFinite(result.usedPercent)
+  ) {
+    return `${formatLevel(result.level)} | ${result.leftPercent}% left ${result.usedPercent}% used | reset ${resetTime}`;
+  }
+
+  if (Number.isFinite(result.leftPercent)) {
+    return `${formatLevel(result.level)} | ${result.leftPercent}% left | reset ${resetTime}`;
+  }
+
+  return "Kimi | quota unavailable";
+}
+
+function formatAbsoluteStatus(result, resetTime, displayMode, style, barWidth) {
+  const mode = normalizeDisplayMode(displayMode);
+  const usedValue =
+    Number.isFinite(result.total) && Number.isFinite(result.remaining)
+      ? result.total - result.remaining
+      : null;
+  const leftPercent =
+    Number.isFinite(result.total) && result.total > 0 && Number.isFinite(result.remaining)
+      ? Math.round((result.remaining / result.total) * 100)
+      : null;
+  const usedPercent =
+    Number.isFinite(leftPercent) ? Math.max(0, Math.min(100, 100 - leftPercent)) : null;
+
+  if (style === "compact" && Number.isFinite(leftPercent)) {
+    return `${formatCompactLabel()} ${leftPercent}% | ${resetTime}`;
+  }
+
+  if (style === "bar" && Number.isFinite(leftPercent) && Number.isFinite(usedPercent)) {
+    return `${formatLevel(result.level)} ${buildBar(usedPercent, barWidth)} ${leftPercent}% | ${resetTime}`;
+  }
+
+  if (mode === "used" && Number.isFinite(usedValue) && Number.isFinite(result.total)) {
+    return `${formatLevel(result.level)} | used ${usedValue}/${result.total} | reset ${resetTime}`;
+  }
+
+  if (
+    mode === "both" &&
+    Number.isFinite(result.remaining) &&
+    Number.isFinite(result.total) &&
+    Number.isFinite(usedValue)
+  ) {
+    return `${formatLevel(result.level)} | left ${result.remaining}/${result.total} used ${usedValue}/${result.total} | reset ${resetTime}`;
+  }
+
+  if (Number.isFinite(result.remaining) && Number.isFinite(result.total)) {
+    return `${formatLevel(result.level)} | left ${result.remaining}/${result.total} | reset ${resetTime}`;
+  }
+
+  return "Kimi | quota unavailable";
+}
+
+export function formatStatus(result, options = {}) {
+  if (!result || typeof result !== "object") {
+    return "Kimi | quota unavailable";
+  }
+
+  if (result.kind === "auth_error") {
+    return "Kimi | auth expired";
+  }
+
+  if (result.kind !== "success") {
+    return "Kimi | quota unavailable";
+  }
+
+  const resetTime = formatResetTime(result.nextResetTime);
+  if (!resetTime) {
+    return "Kimi | quota unavailable";
+  }
+
+  const style = normalizeStyle(options.style);
+
+  if (result.display === "percent") {
+    if (style === "compact" && Number.isFinite(result.leftPercent)) {
+      return `${formatCompactLabel()} ${result.leftPercent}% | ${resetTime}`;
+    }
+
+    if (style === "bar" && Number.isFinite(result.leftPercent) && Number.isFinite(result.usedPercent)) {
+      return `${formatLevel(result.level)} ${buildBar(result.usedPercent, options.barWidth)} ${result.leftPercent}% | ${resetTime}`;
+    }
+
+    return formatPercentStatus(result, resetTime, options.displayMode);
+  }
+
+  if (result.display === "absolute") {
+    return formatAbsoluteStatus(result, resetTime, options.displayMode, style, options.barWidth);
+  }
+
+  return "Kimi | quota unavailable";
+}

package/src/parseArgs.js

@@ -0,0 +1,54 @@
+function takeValue(args, index) {
+  const current = args[index];
+  const next = args[index + 1];
+
+  if (current.includes("=")) {
+    return current.split(/=(.*)/s)[1] ?? "";
+  }
+
+  return next ?? "";
+}
+
+export function parseArgs(argv = process.argv.slice(2)) {
+  const options = {};
+  const positionals = [];
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (!arg.startsWith("-")) {
+      positionals.push(arg);
+      continue;
+    }
+
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+
+    if (arg === "--force") {
+      options.force = true;
+      continue;
+    }
+
+    if (arg === "--style" || arg.startsWith("--style=")) {
+      options.style = takeValue(argv, index);
+      if (!arg.includes("=")) {
+        index += 1;
+      }
+      continue;
+    }
+
+    if (arg === "--display" || arg.startsWith("--display=")) {
+      options.displayMode = takeValue(argv, index);
+      if (!arg.includes("=")) {
+        index += 1;
+      }
+      continue;
+    }
+
+  }
+
+  options.positionals = positionals;
+  return options;
+}

package/src/parseQuota.js

@@ -0,0 +1,143 @@
+function asFiniteNumber(value) {
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return Number.isFinite(value) ? value : null;
+}
+
+function isAuthFailureMessage(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+
+  return /authorization|身份验证|鉴权|auth|令牌|token|过期|验证不正确|invalid|unauthorized/i.test(value);
+}
+
+function parseResetTime(resetTimeValue) {
+  if (typeof resetTimeValue === "string") {
+    const date = new Date(resetTimeValue);
+    if (!Number.isNaN(date.getTime())) {
+      return date.getTime();
+    }
+  }
+  return asFiniteNumber(resetTimeValue);
+}
+
+export function parseQuotaResponse(response) {
+  if (!response || response.kind !== "json") {
+    return { kind: "unavailable" };
+  }
+
+  const payload = response.json;
+  if (!payload || typeof payload !== "object") {
+    return { kind: "unavailable" };
+  }
+
+  // Handle error response
+  if (payload.error) {
+    if (payload.error.code === "invalid_auth" ||
+        payload.error.code === "unauthorized" ||
+        isAuthFailureMessage(payload.error.message)) {
+      return { kind: "auth_error" };
+    }
+    return { kind: "unavailable" };
+  }
+
+  // Handle Kimi error format: { code: "unauthenticated", details: [...] }
+  if (payload.code === "unauthenticated" ||
+      payload.code === "unauthorized" ||
+      isAuthFailureMessage(payload.code)) {
+    return { kind: "auth_error" };
+  }
+
+  // Kimi Code platform format: { "usage": {...}, "limits": [...] }
+  // Try usage object first (summary)
+  const usage = payload.usage;
+  if (usage && typeof usage === "object") {
+    const result = parseUsageDetail(usage);
+    if (result) {
+      return result;
+    }
+  }
+
+  // Fallback: try limits array
+  const limits = Array.isArray(payload.limits) ? payload.limits : [];
+  if (limits.length > 0) {
+    // Find the first limit with a detail object
+    for (const limit of limits) {
+      if (limit && limit.detail && typeof limit.detail === "object") {
+        const result = parseUsageDetail(limit.detail);
+        if (result) {
+          return result;
+        }
+      }
+    }
+  }
+
+  // Legacy format: { "usages": [{ "scope": "FEATURE_CODING", "detail": {...} }] }
+  const usages = Array.isArray(payload.usages) ? payload.usages : [];
+  const codingUsage = usages.find(u => u?.scope === "FEATURE_CODING");
+
+  if (codingUsage && codingUsage.detail && typeof codingUsage.detail === "object") {
+    const result = parseUsageDetail(codingUsage.detail);
+    if (result) {
+      return result;
+    }
+  }
+
+  // Fallback: try limits array in legacy format
+  if (codingUsage && Array.isArray(codingUsage.limits)) {
+    const windowLimit = codingUsage.limits[0];
+    if (windowLimit && windowLimit.detail && typeof windowLimit.detail === "object") {
+      const result = parseUsageDetail(windowLimit.detail);
+      if (result) {
+        return result;
+      }
+    }
+  }
+
+  return { kind: "unavailable" };
+}
+
+function parseUsageDetail(detail) {
+  // Support both snake_case and camelCase field names
+  const limit = asFiniteNumber(detail.limit);
+  const used = asFiniteNumber(detail.used);
+  const remaining = asFiniteNumber(detail.remaining);
+  
+  // Support multiple reset time field names
+  const nextResetTime = parseResetTime(
+    detail.reset_at || 
+    detail.resetAt || 
+    detail.reset_time || 
+    detail.resetTime
+  );
+
+  if (limit !== null && used !== null && remaining !== null && nextResetTime !== null) {
+    const leftPercent = limit > 0 ? Math.round((remaining / limit) * 100) : null;
+    const usedPercent = limit > 0 ? Math.round((used / limit) * 100) : null;
+
+    if (leftPercent !== null && usedPercent !== null) {
+      return {
+        kind: "success",
+        level: "",
+        display: "percent",
+        leftPercent,
+        usedPercent,
+        nextResetTime
+      };
+    }
+
+    return {
+      kind: "success",
+      level: "",
+      display: "absolute",
+      remaining,
+      total: limit,
+      nextResetTime
+    };
+  }
+
+  return null;
+}

package/src/readStatusLineInput.js

@@ -0,0 +1,39 @@
+async function readStdinText(stream) {
+  let text = "";
+
+  for await (const chunk of stream) {
+    text += chunk;
+  }
+
+  return text;
+}
+
+export async function readStatusLineInput(stdin = process.stdin) {
+  if (!stdin || stdin.isTTY) {
+    return null;
+  }
+
+  try {
+    const raw = await readStdinText(stdin);
+    const trimmed = raw.trim();
+    if (!trimmed) {
+      return null;
+    }
+
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+
+export function getSessionId(statusLineInput, env = process.env) {
+  if (statusLineInput && typeof statusLineInput.session_id === "string" && statusLineInput.session_id) {
+    return statusLineInput.session_id;
+  }
+
+  if (typeof env.CODEX_THREAD_ID === "string" && env.CODEX_THREAD_ID) {
+    return env.CODEX_THREAD_ID;
+  }
+
+  return "";
+}

package/src/runQuotaLine.js

@@ -0,0 +1,41 @@
+import { readCache, readFreshCache, writeSuccessCache } from "./cache.js";
+import { fetchQuota } from "./fetchQuota.js";
+import { parseQuotaResponse } from "./parseQuota.js";
+
+export async function runQuotaLine(config, options = {}) {
+  const now = options.now ?? Date.now();
+  const fetchImpl = options.fetchImpl;
+
+  if (!config.apiKey) {
+    return { kind: "auth_error" };
+  }
+
+  const freshCache = await readFreshCache(
+    config.cacheFilePath,
+    config.cacheTtlMs,
+    config.threadId,
+    now
+  );
+  if (freshCache) {
+    return freshCache.result;
+  }
+
+  const staleCache = await readCache(config.cacheFilePath);
+  const response = await fetchQuota(config, fetchImpl);
+  const parsed = parseQuotaResponse(response);
+
+  if (parsed.kind === "success") {
+    await writeSuccessCache(config.cacheFilePath, parsed, config.threadId, now);
+    return parsed;
+  }
+
+  if (parsed.kind === "auth_error") {
+    return parsed;
+  }
+
+  if (staleCache) {
+    return staleCache.result;
+  }
+
+  return parsed;
+}

package/src/userConfig.js

@@ -0,0 +1,161 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TOOL_CONFIG_SCHEMA_VERSION = 1;
+const TOOL_CONFIG_MANAGED_BY = "glm-quota-line";
+
+function normalizePathForShell(value) {
+  return value.replace(/\\/g, "/");
+}
+
+async function readJsonFile(filePath, fallback = {}) {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return fallback;
+    }
+
+    throw error;
+  }
+}
+
+async function writeJsonFile(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.tmp-${process.pid}`;
+  await fs.writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  await fs.rename(tempPath, filePath);
+}
+
+export function getClaudeDir() {
+  return path.join(os.homedir(), ".claude");
+}
+
+export function getClaudeSettingsPath() {
+  return path.join(getClaudeDir(), "settings.json");
+}
+
+export function getToolConfigPath() {
+  return path.join(getClaudeDir(), "glm-quota-line.json");
+}
+
+export function getStatusLineScriptPath() {
+  return path.resolve(__dirname, "..", "scripts", "status-line.js");
+}
+
+export function buildInstalledStatusLineCommand(nodePath = process.execPath) {
+  return `"${normalizePathForShell(nodePath)}" "${normalizePathForShell(getStatusLineScriptPath())}"`;
+}
+
+function isManagedStatusLine(statusLine) {
+  const command = statusLine?.command;
+  if (typeof command !== "string") {
+    return false;
+  }
+
+  return command.includes("glm-quota-line") || command.includes("status-line.js");
+}
+
+function normalizeToolConfig(config) {
+  const base = config && typeof config === "object" ? config : {};
+
+  return {
+    schemaVersion: TOOL_CONFIG_SCHEMA_VERSION,
+    managedBy: TOOL_CONFIG_MANAGED_BY,
+    style: typeof base.style === "string" ? base.style : undefined,
+    displayMode: typeof base.displayMode === "string" ? base.displayMode : undefined,
+    install: base.install && typeof base.install === "object" ? base.install : {}
+  };
+}
+
+export async function readToolConfig(configPath = getToolConfigPath()) {
+  const parsed = await readJsonFile(configPath, {});
+  return normalizeToolConfig(parsed);
+}
+
+export async function writeToolConfig(config, configPath = getToolConfigPath()) {
+  await writeJsonFile(configPath, normalizeToolConfig(config));
+}
+
+export async function setToolConfigValue(key, value, configPath = getToolConfigPath()) {
+  const current = await readToolConfig(configPath);
+  current[key] = value;
+  await writeToolConfig(current, configPath);
+  return current;
+}
+
+export async function installClaudeStatusLine(
+  command = buildInstalledStatusLineCommand(),
+  settingsPath = getClaudeSettingsPath(),
+  configPath = getToolConfigPath(),
+  options = {}
+) {
+  const settings = await readJsonFile(settingsPath, {});
+  const toolConfig = await readToolConfig(configPath);
+  const existingStatusLine = settings.statusLine;
+
+  if (existingStatusLine && !isManagedStatusLine(existingStatusLine) && !options.force) {
+    return {
+      installed: false,
+      reason: "unmanaged_exists",
+      settingsPath,
+      command
+    };
+  }
+
+  if (existingStatusLine && !isManagedStatusLine(existingStatusLine) && options.force) {
+    toolConfig.install.previousStatusLine = existingStatusLine;
+  }
+
+  const nextStatusLine = {
+    ...(existingStatusLine && typeof existingStatusLine === "object" ? existingStatusLine : {}),
+    type: "command",
+    command
+  };
+
+  settings.statusLine = nextStatusLine;
+  await writeJsonFile(settingsPath, settings);
+  toolConfig.install.settingsPath = settingsPath;
+  toolConfig.install.command = command;
+  toolConfig.install.installed = true;
+  await writeToolConfig(toolConfig, configPath);
+
+  return {
+    installed: true,
+    command,
+    settingsPath
+  };
+}
+
+export async function uninstallClaudeStatusLine(
+  settingsPath = getClaudeSettingsPath(),
+  configPath = getToolConfigPath()
+) {
+  const settings = await readJsonFile(settingsPath, {});
+  const toolConfig = await readToolConfig(configPath);
+  const statusLine = settings.statusLine;
+
+  if (!statusLine) {
+    return { removed: false, reason: "missing", settingsPath };
+  }
+
+  if (!isManagedStatusLine(statusLine)) {
+    return { removed: false, reason: "unmanaged", settingsPath };
+  }
+
+  if (toolConfig.install.previousStatusLine) {
+    settings.statusLine = toolConfig.install.previousStatusLine;
+  } else {
+    delete settings.statusLine;
+  }
+
+  await writeJsonFile(settingsPath, settings);
+  toolConfig.install = {};
+  await writeToolConfig(toolConfig, configPath);
+  return { removed: true, reason: "removed", settingsPath };
+}