glm-quota-line 0.4.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.6.0
+
+- Added official international GLM quota endpoint support for `api.z.ai` while preserving domestic `open.bigmodel.cn` detection
+- Added dual-token status rendering for the new package shape, showing both the 5h quota and weekly quota in `text`, `compact`, and `bar` styles
+- Kept old packages compatible by continuing to read the legacy `TOKENS_LIMIT(number=5)` quota and ignoring `TIME_LIMIT` / MCP usage
+- Updated cache compatibility so existing cached percent-based results still render after upgrading
+- Refreshed English and Chinese README examples to document international setup and the new token-only display behavior
+
+## 0.5.0
+
+- Changed bar characters from `■□` (discrete squares) to `█░` (continuous blocks) to match Claude Code official statusline style
+
 ## 0.4.0
 
 - Added managed Claude Code `SessionStart` hooks to pre-refresh quota on `startup`, `resume`, `clear`, and `compact`

package/README.md

@@ -73,18 +73,20 @@ glm-quota-line --style compact
 ## Output
 
 ```text
-GLM Lite | 5h left 91% | reset 14:47
-GLM 91% | 14:47
-GLM Lite ■□□□□□□□□□ 91% | 14:47
+GLM Lite | 5h left 91% | week 47% | reset 14:47
+
+GLM 5h 91% W 47% | 14:47
+
+GLM Lite █░░░░░░░░░ 91% | W 47% | 14:47
 ```
 
 ## Recommended Setups
 
-| Use case | Config |
-| --- | --- |
-| Dark terminal | `style=bar`, `theme=ansi`, `palette=dark` |
+| Use case       | Config                                        |
+| -------------- | --------------------------------------------- |
+| Dark terminal  | `style=bar`, `theme=ansi`, `palette=dark`     |
 | Light terminal | `style=compact`, `theme=ansi`, `palette=mono` |
-| Plain fallback | any `style`, `theme=plain` |
+| Plain fallback | any `style`, `theme=plain`                    |
 
 ## Color Presets
 
@@ -117,6 +119,8 @@ If Claude Code is running behind a gateway or proxy and the injected `ANTHROPIC_
 ```bash
 glm-quota-line config set auth-token <your-real-token>
 glm-quota-line config set base-url https://open.bigmodel.cn/api/anthropic
+# or
+glm-quota-line config set base-url https://api.z.ai/api/anthropic
 ```
 
 Clear them later with:
@@ -153,6 +157,7 @@ Run `glm-quota-line --help` for the full command descriptions and examples.
 - Default output is plain text
 - Missing or expired auth returns `GLM | auth expired`
 - API or parsing failures return `GLM | quota unavailable`
+- Only `TOKENS_LIMIT` quotas are shown; `TIME_LIMIT` / MCP usage is ignored
 - `install` wires both the status line command and managed `SessionStart` hooks
 - `install` does not replace an unmanaged Claude status line unless `--force` is used
 - `install --force` backs up the previous entry and `uninstall` restores it when possible

package/README.zh-CN.md

@@ -73,18 +73,20 @@ glm-quota-line --style compact
 ## 输出示例
 
 ```text
-GLM Lite | 5h left 91% | reset 14:47
-GLM 91% | 14:47
-GLM Lite ■□□□□□□□□□ 91% | 14:47
+GLM Lite | 5h 91% | week 47% | reset 14:47
+
+GLM 5h 91% W 47% | 14:47
+
+GLM Lite █░░░░░░░░░ 91% | W 47% | 14:47
 ```
 
 ## 推荐搭配
 
-| 使用场景 | 配置 |
-| --- | --- |
-| 深色终端 | `style=bar`, `theme=ansi`, `palette=dark` |
-| 浅色终端 | `style=compact`, `theme=ansi`, `palette=mono` |
-| 纯文本回退 | 任意 `style`，`theme=plain` |
+| 使用场景   | 配置                                          |
+| ---------- | --------------------------------------------- |
+| 深色终端   | `style=bar`, `theme=ansi`, `palette=dark`     |
+| 浅色终端   | `style=compact`, `theme=ansi`, `palette=mono` |
+| 纯文本回退 | 任意 `style`，`theme=plain`                   |
 
 ## 颜色搭配
 
@@ -117,6 +119,8 @@ glm-quota-line config set theme plain
 ```bash
 glm-quota-line config set auth-token <your-real-token>
 glm-quota-line config set base-url https://open.bigmodel.cn/api/anthropic
+# 或
+glm-quota-line config set base-url https://api.z.ai/api/anthropic
 ```
 
 清除覆盖值：
@@ -157,6 +161,7 @@ glm-quota-line --help
 - 默认输出为纯文本
 - 鉴权缺失或失效时返回 `GLM | auth expired`
 - 接口异常或解析失败时返回 `GLM | quota unavailable`
+- 只展示 `TOKENS_LIMIT` 配额，忽略 `TIME_LIMIT` / MCP 使用量
 - `install` 会同时接入状态栏命令和受工具管理的 `SessionStart` hooks
 - `install` 默认不会覆盖非本工具管理的 Claude 状态栏，除非显式使用 `--force`
 - `install --force` 会备份旧配置，`uninstall` 会在可能时恢复

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glm-quota-line",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Claude Code status line helper for GLM Coding Plan quota.",
   "type": "module",
   "license": "MIT",

package/src/core/quota/cache.js

@@ -1,24 +1,72 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 
-function isSuccessCacheShape(value) {
+function isValidQuotaShape(value) {
+  if (!value || typeof value.key !== "string") {
+    return false;
+  }
+
+  if (!Number.isFinite(value.leftPercent)) {
+    return false;
+  }
+
+  if (!Number.isFinite(value.usedPercent)) {
+    return false;
+  }
+
+  if ("nextResetTime" in value && !Number.isFinite(value.nextResetTime)) {
+    return false;
+  }
+
+  return true;
+}
+
+function isLegacyPercentSuccessCacheShape(value) {
+  if (!value || value.kind !== "success" || typeof value.level !== "string") {
+    return false;
+  }
+
+  if (value.display !== "percent") {
+    return false;
+  }
+
+  if (!Number.isFinite(value.leftPercent)) {
+    return false;
+  }
+
+  if ("usedPercent" in value && !Number.isFinite(value.usedPercent)) {
+    return false;
+  }
+
+  if ("nextResetTime" in value && !Number.isFinite(value.nextResetTime)) {
+    return false;
+  }
+
+  return true;
+}
+
+function isMultiQuotaSuccessCacheShape(value) {
   if (!value || value.kind !== "success" || typeof value.level !== "string") {
     return false;
   }
 
-  if (!Number.isFinite(value.nextResetTime)) {
+  if (!Array.isArray(value.quotas) || value.quotas.length === 0) {
     return false;
   }
 
-  if (value.display === "percent") {
-    return Number.isFinite(value.leftPercent);
+  if (!value.quotas.every(isValidQuotaShape)) {
+    return false;
   }
 
-  if (value.display === "absolute") {
-    return Number.isFinite(value.remaining) && Number.isFinite(value.total);
+  if ("primaryQuotaKey" in value && typeof value.primaryQuotaKey !== "string") {
+    return false;
   }
 
-  return false;
+  return true;
+}
+
+function isSuccessCacheShape(value) {
+  return isMultiQuotaSuccessCacheShape(value) || isLegacyPercentSuccessCacheShape(value);
 }
 
 function asFiniteNumber(value) {

package/src/core/quota/parse.js

@@ -18,28 +18,145 @@ function isRateLimitedMessage(value) {
   return /rate\s*limit|too many requests|too frequent|frequency|\u9650\u6d41|\u9891\u7387|\u8fc7\u4e8e\u9891\u7e41|\u7a0d\u540e\u518d\u8bd5/i.test(value);
 }
 
-function computeTotal(limit) {
-  const usage = asFiniteNumber(limit.usage);
-  if (usage !== null && usage >= 0) {
-    return usage;
+function clampPercent(value) {
+  const percent = asFiniteNumber(value);
+  if (percent === null) {
+    return null;
   }
 
-  const remaining = asFiniteNumber(limit.remaining);
-  const currentValue = asFiniteNumber(limit.currentValue);
-  if (remaining !== null && currentValue !== null) {
-    return remaining + currentValue;
+  return Math.min(100, Math.max(0, percent));
+}
+
+function computePercentages(limit) {
+  const usage = asFiniteNumber(limit?.usage);
+  const remaining = asFiniteNumber(limit?.remaining);
+  const currentValue = asFiniteNumber(limit?.currentValue);
+  const totalFromParts =
+    remaining !== null && currentValue !== null ? remaining + currentValue : null;
+  const total = totalFromParts !== null && totalFromParts > 0 ? totalFromParts : usage;
+
+  if (total !== null && total > 0) {
+    if (remaining !== null && remaining >= 0 && remaining <= total) {
+      const leftPercent = clampPercent(Math.round((remaining / total) * 100));
+      if (leftPercent !== null) {
+        return {
+          leftPercent,
+          usedPercent: 100 - leftPercent
+        };
+      }
+    }
+
+    if (currentValue !== null && currentValue >= 0 && currentValue <= total) {
+      const usedPercent = clampPercent(Math.round((currentValue / total) * 100));
+      if (usedPercent !== null) {
+        return {
+          leftPercent: 100 - usedPercent,
+          usedPercent
+        };
+      }
+    }
   }
 
-  return null;
+  // Legacy token payloads only expose `percentage`; historically this has
+  // represented used percent for GLM quota responses.
+  const usedPercent = clampPercent(limit?.percentage);
+  if (usedPercent === null) {
+    return null;
+  }
+
+  return {
+    leftPercent: 100 - usedPercent,
+    usedPercent
+  };
 }
 
-function clampPercent(value) {
-  const percent = asFiniteNumber(value);
-  if (percent === null) {
+function normalizeTokenQuota(key, limit) {
+  const percentages = computePercentages(limit);
+  if (!percentages) {
     return null;
   }
 
-  return Math.min(100, Math.max(0, percent));
+  const nextResetTime = asFiniteNumber(limit?.nextResetTime);
+
+  return {
+    key,
+    leftPercent: percentages.leftPercent,
+    usedPercent: percentages.usedPercent,
+    ...(nextResetTime !== null ? { nextResetTime } : {})
+  };
+}
+
+function sortTokenLimitsByResetTime(limits) {
+  return [...limits].sort((left, right) => {
+    const leftReset = asFiniteNumber(left?.nextResetTime);
+    const rightReset = asFiniteNumber(right?.nextResetTime);
+
+    if (leftReset !== null && rightReset !== null && leftReset !== rightReset) {
+      return leftReset - rightReset;
+    }
+
+    if (leftReset !== null && rightReset === null) {
+      return -1;
+    }
+
+    if (leftReset === null && rightReset !== null) {
+      return 1;
+    }
+
+    return (left?._index ?? 0) - (right?._index ?? 0);
+  });
+}
+
+function pickSecondaryTokenLimit(tokenLimits, primaryLimit) {
+  const candidates = tokenLimits.filter((limit) => limit?._index !== primaryLimit?._index);
+  if (candidates.length === 0) {
+    return null;
+  }
+
+  return sortTokenLimitsByResetTime(candidates)[0] ?? null;
+}
+
+function pickPrimaryAndSecondaryTokenLimits(limits) {
+  const tokenLimits = limits
+    .filter((limit) => limit?.type === "TOKENS_LIMIT")
+    .map((limit, index) => ({ ...limit, _index: index }));
+
+  if (tokenLimits.length === 0) {
+    return [];
+  }
+
+  const explicitFiveHour = tokenLimits.find((limit) => limit?.number === 5) ?? null;
+  if (explicitFiveHour) {
+    const weekCandidate = pickSecondaryTokenLimit(tokenLimits, explicitFiveHour);
+    return [explicitFiveHour, weekCandidate].filter(Boolean);
+  }
+
+  if (tokenLimits.length === 1) {
+    return tokenLimits;
+  }
+
+  return sortTokenLimitsByResetTime(tokenLimits).slice(0, 2);
+}
+
+function buildTokenQuotas(limits) {
+  const selectedLimits = pickPrimaryAndSecondaryTokenLimits(limits);
+  if (selectedLimits.length === 0) {
+    return [];
+  }
+
+  const quotas = [];
+  const [fiveHourLimit, weekLimit] = selectedLimits;
+  const fiveHourQuota = normalizeTokenQuota("token_5h", fiveHourLimit);
+  if (fiveHourQuota) {
+    quotas.push(fiveHourQuota);
+  }
+
+  const weekQuota = normalizeTokenQuota("token_week", weekLimit);
+  if (weekQuota) {
+    quotas.push(weekQuota);
+  }
+
+  return quotas;
 }
 
 export function parseQuotaResponse(response) {
@@ -70,45 +187,23 @@ export function parseQuotaResponse(response) {
 
   const level = typeof payload.data?.level === "string" ? payload.data.level : "";
   const limits = Array.isArray(payload.data?.limits) ? payload.data.limits : [];
-  const rollingWindowLimit = limits.find(
-    (limit) => limit?.type === "TOKENS_LIMIT" && limit?.number === 5
-  );
-
-  if (rollingWindowLimit) {
-    const usedPercent = clampPercent(rollingWindowLimit.percentage);
-    const nextResetTime = asFiniteNumber(rollingWindowLimit.nextResetTime);
-
-    if (usedPercent !== null && nextResetTime !== null) {
-      return {
-        kind: "success",
-        level,
-        display: "percent",
-        leftPercent: 100 - usedPercent,
-        usedPercent,
-        nextResetTime
-      };
-    }
-  }
-
-  const timeLimit = limits.find((limit) => limit?.type === "TIME_LIMIT" && limit?.unit === 5);
-  if (!timeLimit) {
+  const quotas = buildTokenQuotas(limits);
+  if (quotas.length === 0) {
     return { kind: "unavailable" };
   }
 
-  const remaining = asFiniteNumber(timeLimit.remaining);
-  const total = computeTotal(timeLimit);
-  const nextResetTime = asFiniteNumber(timeLimit.nextResetTime);
-
-  if (remaining === null || total === null || nextResetTime === null) {
-    return { kind: "unavailable" };
-  }
+  const primaryQuota = quotas[0];
 
   return {
     kind: "success",
     level,
-    display: "absolute",
-    remaining,
-    total,
-    nextResetTime
+    display: "percent",
+    leftPercent: primaryQuota.leftPercent,
+    usedPercent: primaryQuota.usedPercent,
+    ...(Number.isFinite(primaryQuota.nextResetTime)
+      ? { nextResetTime: primaryQuota.nextResetTime }
+      : {}),
+    primaryQuotaKey: primaryQuota.key,
+    quotas
   };
 }

package/src/core/status/format.js

@@ -1,6 +1,4 @@
 import {
-  AUTH_EXPIRED_TEXT,
-  QUOTA_UNAVAILABLE_TEXT,
   normalizeDisplayMode,
   normalizePalette,
   normalizeStatusStyle,
@@ -26,76 +24,131 @@ function createErrorSegments(model) {
   ];
 }
 
-function createTextSegments(model, displayMode) {
+function createQuotaTextSegments(quota, displayMode, tone) {
   const mode = normalizeDisplayMode(displayMode);
-  const severityTone = getSeverityTone(model);
 
-  if (mode === "used" && model.usedText) {
+  if (mode === "used") {
     return [
-      { text: model.levelLabel, tone: "label" },
-      { text: " | 5h used ", tone: "muted" },
-      { text: model.usedText, tone: severityTone },
-      { text: " | reset ", tone: "muted" },
-      { text: model.resetText, tone: "reset" }
+      { text: `${quota.label} used `, tone: "muted" },
+      { text: quota.usedText, tone }
     ];
   }
 
-  if (mode === "both" && model.leftText && model.usedText) {
+  if (mode === "both") {
     return [
-      { text: model.levelLabel, tone: "label" },
-      { text: " | 5h left ", tone: "muted" },
-      { text: model.leftText, tone: severityTone },
+      { text: `${quota.label} left `, tone: "muted" },
+      { text: quota.leftText, tone },
       { text: " used ", tone: "muted" },
-      { text: model.usedText, tone: severityTone },
-      { text: " | reset ", tone: "muted" },
-      { text: model.resetText, tone: "reset" }
+      { text: quota.usedText, tone }
     ];
   }
 
-  if (model.leftText) {
-    return [
-      { text: model.levelLabel, tone: "label" },
-      { text: " | 5h left ", tone: "muted" },
-      { text: model.leftText, tone: severityTone },
-      { text: " | reset ", tone: "muted" },
-      { text: model.resetText, tone: "reset" }
-    ];
+  return [
+    { text: `${quota.label} `, tone: "muted" },
+    { text: quota.leftText, tone }
+  ];
+}
+
+function appendSecondarySegments(segments, model) {
+  if (!model.secondaryQuota) {
+    return segments;
   }
 
-  return createErrorSegments({ kind: "unavailable" });
+  return [
+    ...segments,
+    { text: " | ", tone: "muted" },
+    { text: `${model.secondaryQuota.label} `, tone: "muted" },
+    { text: model.secondaryQuota.leftText, tone: "plain" }
+  ];
 }
 
-function createCompactSegments(model) {
-  if (!Number.isFinite(model.leftPercent)) {
-    return createErrorSegments({ kind: "unavailable" });
+function appendResetSegments(segments, model) {
+  if (!model.resetText) {
+    return segments;
   }
 
   return [
-    { text: `${model.compactLabel} `, tone: "label" },
-    { text: `${model.leftPercent}%`, tone: getSeverityTone(model) },
-    { text: " | ", tone: "muted" },
+    ...segments,
+    { text: " | reset ", tone: "muted" },
     { text: model.resetText, tone: "reset" }
   ];
 }
 
+function createTextSegments(model, displayMode) {
+  const severityTone = getSeverityTone(model);
+
+  return appendResetSegments(
+    appendSecondarySegments(
+      [
+        { text: model.levelLabel, tone: "label" },
+        { text: " | ", tone: "muted" },
+        ...createQuotaTextSegments(model.primaryQuota, displayMode, severityTone)
+      ],
+      model
+    ),
+    model
+  );
+}
+
+function createCompactSegments(model) {
+  const severityTone = getSeverityTone(model);
+  let segments;
+
+  if (model.secondaryQuota) {
+    segments = [
+      { text: `${model.compactLabel} `, tone: "label" },
+      { text: `${model.primaryQuota.compactLabel} `, tone: "muted" },
+      { text: model.primaryQuota.leftText, tone: severityTone },
+      { text: " ", tone: "plain" },
+      { text: `${model.secondaryQuota.compactLabel} `, tone: "muted" },
+      { text: model.secondaryQuota.leftText, tone: "plain" }
+    ];
+  } else {
+    segments = [
+      { text: `${model.compactLabel} `, tone: "label" },
+      { text: model.primaryQuota.leftText, tone: severityTone }
+    ];
+  }
+
+  if (model.resetText) {
+    segments.push({ text: " | ", tone: "muted" }, { text: model.resetText, tone: "reset" });
+  }
+
+  return segments;
+}
+
 function createBarSegments(model, barWidth) {
-  if (!Number.isFinite(model.leftPercent) || !Number.isFinite(model.usedPercent)) {
+  if (
+    !Number.isFinite(model.primaryQuota?.leftPercent) ||
+    !Number.isFinite(model.primaryQuota?.usedPercent)
+  ) {
     return createErrorSegments({ kind: "unavailable" });
   }
 
-  const bar = buildBar(model.usedPercent, barWidth);
+  const bar = buildBar(model.primaryQuota.usedPercent, barWidth);
   const severityTone = getSeverityTone(model);
-
-  return [
+  const segments = [
     { text: model.levelLabel, tone: "label" },
     { text: " ", tone: "plain" },
     { text: bar.filledText, tone: severityTone },
     { text: bar.emptyText, tone: "barEmpty" },
     { text: " ", tone: "plain" },
-    { text: `${model.leftPercent}%`, tone: severityTone },
-    { text: " | ", tone: "muted" },
-    { text: model.resetText, tone: "reset" }
+    { text: model.primaryQuota.leftText, tone: severityTone }
   ];
+
+  if (model.secondaryQuota) {
+    segments.push(
+      { text: " | ", tone: "muted" },
+      { text: `${model.secondaryQuota.compactLabel} `, tone: "muted" },
+      { text: model.secondaryQuota.leftText, tone: "plain" }
+    );
+  }
+
+  if (model.resetText) {
+    segments.push({ text: " | ", tone: "muted" }, { text: model.resetText, tone: "reset" });
+  }
+
+  return segments;
 }
 
 export function formatStatus(result, options = {}) {

package/src/core/status/viewModel.js

@@ -2,6 +2,11 @@ function padTwoDigits(value) {
   return String(value).padStart(2, "0");
 }
 
+const QUOTA_LABELS = {
+  token_5h: { text: "5h", compact: "5h" },
+  token_week: { text: "week", compact: "W" }
+};
+
 function formatLevel(level) {
   if (!level) {
     return "GLM";
@@ -11,6 +16,10 @@ function formatLevel(level) {
 }
 
 function formatResetTime(timestampMs) {
+  if (!Number.isFinite(timestampMs)) {
+    return null;
+  }
+
   const date = new Date(timestampMs);
   if (Number.isNaN(date.getTime())) {
     return null;
@@ -35,6 +44,51 @@ function getSeverity(leftPercent) {
   return "danger";
 }
 
+function getQuotaLabels(key) {
+  return QUOTA_LABELS[key] || { text: key || "quota", compact: key || "Q" };
+}
+
+function normalizeQuota(quota) {
+  if (!quota || typeof quota !== "object" || !Number.isFinite(quota.leftPercent)) {
+    return null;
+  }
+
+  const usedPercent = Number.isFinite(quota.usedPercent)
+    ? quota.usedPercent
+    : Math.max(0, Math.min(100, 100 - quota.leftPercent));
+  const labels = getQuotaLabels(quota.key);
+
+  return {
+    key: quota.key || "token_5h",
+    label: labels.text,
+    compactLabel: labels.compact,
+    leftPercent: quota.leftPercent,
+    usedPercent,
+    leftText: `${quota.leftPercent}%`,
+    usedText: `${usedPercent}%`,
+    nextResetTime: Number.isFinite(quota.nextResetTime) ? quota.nextResetTime : null
+  };
+}
+
+function normalizeQuotasFromResult(result) {
+  if (Array.isArray(result.quotas) && result.quotas.length > 0) {
+    return result.quotas.map(normalizeQuota).filter(Boolean);
+  }
+
+  if (result.display === "percent" && Number.isFinite(result.leftPercent)) {
+    return [
+      normalizeQuota({
+        key: "token_5h",
+        leftPercent: result.leftPercent,
+        usedPercent: result.usedPercent,
+        nextResetTime: result.nextResetTime
+      })
+    ].filter(Boolean);
+  }
+
+  return [];
+}
+
 export function buildStatusViewModel(result) {
   if (!result || typeof result !== "object") {
     return { kind: "unavailable" };
@@ -48,59 +102,26 @@ export function buildStatusViewModel(result) {
     return { kind: "unavailable" };
   }
 
-  const resetText = formatResetTime(result.nextResetTime);
-  if (!resetText) {
+  const quotas = normalizeQuotasFromResult(result);
+  if (quotas.length === 0) {
     return { kind: "unavailable" };
   }
 
-  if (result.display === "percent") {
-    return {
-      kind: "success",
-      display: "percent",
-      levelLabel: formatLevel(result.level),
-      compactLabel: "GLM",
-      resetText,
-      leftPercent: result.leftPercent,
-      usedPercent: result.usedPercent,
-      leftText: Number.isFinite(result.leftPercent) ? `${result.leftPercent}%` : null,
-      usedText: Number.isFinite(result.usedPercent) ? `${result.usedPercent}%` : null,
-      severity: getSeverity(result.leftPercent)
-    };
-  }
-
-  if (result.display === "absolute") {
-    // Absolute quota responses are normalized into the same percent-oriented
-    // view model so the renderer can stay display-format-focused.
-    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;
-
-    return {
-      kind: "success",
-      display: "absolute",
-      levelLabel: formatLevel(result.level),
-      compactLabel: "GLM",
-      resetText,
-      leftPercent,
-      usedPercent,
-      leftText:
-        Number.isFinite(result.remaining) && Number.isFinite(result.total)
-          ? `${result.remaining}/${result.total}`
-          : null,
-      usedText:
-        Number.isFinite(usedValue) && Number.isFinite(result.total)
-          ? `${usedValue}/${result.total}`
-          : null,
-      severity: getSeverity(leftPercent)
-    };
-  }
-
-  return { kind: "unavailable" };
+  const primaryQuota =
+    quotas.find((quota) => quota.key === result.primaryQuotaKey) ||
+    quotas.find((quota) => quota.key === "token_5h") ||
+    quotas[0];
+  const secondaryQuota = quotas.find((quota) => quota !== primaryQuota) || null;
+
+  return {
+    kind: "success",
+    levelLabel: formatLevel(result.level),
+    compactLabel: "GLM",
+    primaryQuota,
+    secondaryQuota,
+    leftPercent: primaryQuota.leftPercent,
+    usedPercent: primaryQuota.usedPercent,
+    resetText: formatResetTime(primaryQuota.nextResetTime),
+    severity: getSeverity(primaryQuota.leftPercent)
+  };
 }

package/src/shared/config.js

@@ -5,6 +5,8 @@ import path from "node:path";
 import {
   DEFAULT_BAR_WIDTH,
   DEFAULT_CACHE_TTL_MS,
+  DEFAULT_CN_BASE_URL,
+  DEFAULT_INTL_BASE_URL,
   DEFAULT_DISPLAY_MODE,
   DEFAULT_PALETTE,
   DEFAULT_QUOTA_URL,
@@ -45,14 +47,19 @@ function deriveQuotaUrl(baseUrl) {
 
   try {
     const parsedBaseUrl = new URL(baseUrl);
-    const baseDomain = `${parsedBaseUrl.protocol}//${parsedBaseUrl.host}`;
+    const host = parsedBaseUrl.host;
+
+    if (host.includes("api.z.ai")) {
+      return `${DEFAULT_INTL_BASE_URL}/api/monitor/usage/quota/limit`;
+    }
 
     if (
-      parsedBaseUrl.host.includes("api.z.ai") ||
-      parsedBaseUrl.host.includes("open.bigmodel.cn") ||
-      parsedBaseUrl.host.includes("dev.bigmodel.cn")
+      host.includes("open.bigmodel.cn") ||
+      host.includes("dev.bigmodel.cn") ||
+      host === "bigmodel.cn" ||
+      host.endsWith(".bigmodel.cn")
     ) {
-      return `${baseDomain}/api/monitor/usage/quota/limit`;
+      return `${DEFAULT_CN_BASE_URL}/api/monitor/usage/quota/limit`;
     }
   } catch {
     return "";

package/src/shared/constants.js

@@ -1,4 +1,6 @@
 export const DEFAULT_QUOTA_URL = "https://bigmodel.cn/api/monitor/usage/quota/limit";
+export const DEFAULT_CN_BASE_URL = "https://open.bigmodel.cn";
+export const DEFAULT_INTL_BASE_URL = "https://api.z.ai";
 export const DEFAULT_TIMEOUT_MS = 5000;
 export const DEFAULT_CACHE_TTL_MS = 300_000;
 export const DEFAULT_DISPLAY_MODE = "left";
@@ -13,8 +15,8 @@ export const THEMES = ["plain", "ansi"];
 export const PALETTES = ["dark", "mono"];
 
 export const STATUS_BAR_CHARACTERS = {
-  filled: "■",
-  empty: "□"
+  filled: "█",
+  empty: "░"
 };
 
 export const TOOL_CONFIG_SCHEMA_VERSION = 1;