glm-quota-line 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.9.0
+
+- Replaced progressive tier-based backoff with diamond-shaped refresh strategy: high quota (80–100%) refreshes every 2 min, medium (30–79%) every 5 min, low (0–29%) every 2 min — frequent updates when usage is active or quota is near exhaustion, relaxed in between
+- Added failure-type-aware retry TTLs: rate-limited (429) retries after 3 min, unavailable retries after 2 min, instead of reusing the quota-based TTL
+- Removed `refreshCount`/`tierIndex` cache fields and `advanceTier()` — cache format is now simpler, and TTL is derived purely from quota percentage
+- Aligned severity threshold (danger/warn boundary) from hardcoded 25% to `LOW_QUOTA_THRESHOLD` (30%), consistent with the refresh band boundary
+- Unknown CLI commands and invalid config subcommands now print an error and exit with code 1 instead of silently showing quota status
+
 ## 0.8.0
 
 - Added progressive refresh backoff: new sessions start at 3-minute intervals, advance to 5 minutes after 5 refreshes, and cap at 10 minutes after 5 more — giving new users fast feedback while reducing API pressure in long sessions

package/README.md

@@ -106,7 +106,7 @@ glm-quota-line config set <style|display|theme|palette|auth-token|base-url> <val
 glm-quota-line config unset <key>
 ```
 
-完整说明运行 `glm-quota-line --help`。
+运行 `glm-quota-line --help` 查看完整说明。
 
 `glm-quota-line --version` 可直接查看当前安装版本；`check-update` 只检查并提示升级命令，不会自动修改环境。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glm-quota-line",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Zhipu GLM Coding Plan quota monitor for Claude Code status line.",
   "type": "module",
   "license": "MIT",

package/src/cli/commands.js

@@ -149,11 +149,13 @@ export async function handleCommand(args, output = process.stdout, dependencies
   if (command === "config" && subcommand === "set") {
     const configKey = CONFIG_KEYS[key];
     if (!configKey) {
+      process.exitCode = 1;
       output.write("Supported config keys: style, display, theme, palette, auth-token, base-url\n");
       return true;
     }
 
     if (!configKey.validate(value)) {
+      process.exitCode = 1;
       output.write(`${configKey.invalidMessage}\n`);
       return true;
     }
@@ -168,6 +170,7 @@ export async function handleCommand(args, output = process.stdout, dependencies
   if (command === "config" && subcommand === "unset") {
     const configKey = CONFIG_KEYS[key];
     if (!configKey) {
+      process.exitCode = 1;
       output.write("Supported config keys: style, display, theme, palette, auth-token, base-url\n");
       return true;
     }
@@ -177,5 +180,17 @@ export async function handleCommand(args, output = process.stdout, dependencies
     return true;
   }
 
+  if (command === "config") {
+    process.exitCode = 1;
+    output.write("Supported config subcommands: show, set, unset\n");
+    return true;
+  }
+
+  if (command) {
+    process.exitCode = 1;
+    output.write(`Unknown command: ${command}\nRun 'glm-quota-line -h' for usage.\n`);
+    return true;
+  }
+
   return false;
 }

package/src/core/quota/cache.js

@@ -80,6 +80,10 @@ function normalizeCache(parsed) {
   const savedAt = asFiniteNumber(parsed.savedAt);
   const lastAttemptAt = asFiniteNumber(parsed.lastAttemptAt) ?? savedAt;
   const sessionId = typeof parsed.sessionId === "string" ? parsed.sessionId : "";
+  const lastFailureKind =
+    parsed.lastFailureKind === "rate_limited" || parsed.lastFailureKind === "unavailable"
+      ? parsed.lastFailureKind
+      : null;
 
   if (result && savedAt === null) {
     return null;
@@ -89,21 +93,11 @@ function normalizeCache(parsed) {
     return null;
   }
 
-  const refreshCount =
-    typeof parsed.refreshCount === "number" && Number.isFinite(parsed.refreshCount)
-      ? Math.max(0, Math.floor(parsed.refreshCount))
-      : 0;
-  const tierIndex =
-    typeof parsed.tierIndex === "number" && Number.isFinite(parsed.tierIndex)
-      ? Math.max(0, Math.floor(parsed.tierIndex))
-      : 0;
-
   return {
     savedAt,
     lastAttemptAt,
     sessionId,
-    refreshCount,
-    tierIndex,
+    lastFailureKind,
     result
   };
 }
@@ -114,8 +108,7 @@ async function writeCache(cacheFilePath, cache) {
       ...(Number.isFinite(cache.savedAt) ? { savedAt: cache.savedAt } : {}),
       ...(Number.isFinite(cache.lastAttemptAt) ? { lastAttemptAt: cache.lastAttemptAt } : {}),
       ...(cache.sessionId ? { sessionId: cache.sessionId } : {}),
-      refreshCount: cache.refreshCount ?? 0,
-      tierIndex: cache.tierIndex ?? 0,
+      ...(cache.lastFailureKind ? { lastFailureKind: cache.lastFailureKind } : {}),
       ...(cache.result ? { result: cache.result } : {})
     },
     null,
@@ -142,21 +135,19 @@ export async function writeSuccessCache(cacheFilePath, result, options = {}) {
     savedAt: now,
     lastAttemptAt: now,
     sessionId: options.sessionId || "",
-    refreshCount: options.refreshCount ?? 0,
-    tierIndex: options.tierIndex ?? 0,
+    lastFailureKind: null,
     result
   });
 }
 
-export async function writeRateLimitedCache(cacheFilePath, cached, options = {}) {
+export async function writeFailureCache(cacheFilePath, cached, options = {}) {
   const now = options.now ?? Date.now();
 
   await writeCache(cacheFilePath, {
     savedAt: cached?.savedAt ?? null,
     lastAttemptAt: now,
     sessionId: options.sessionId || cached?.sessionId || "",
-    refreshCount: cached?.refreshCount ?? 0,
-    tierIndex: cached?.tierIndex ?? 0,
+    lastFailureKind: options.failureKind || "unavailable",
     result: cached?.result ?? null
   });
 }

package/src/core/quota/service.js

@@ -1,37 +1,39 @@
 import {
   readCache,
-  writeRateLimitedCache,
+  writeFailureCache,
   writeSuccessCache
 } from "./cache.js";
 import { fetchQuota } from "./fetch.js";
 import { parseQuotaResponse } from "./parse.js";
 import {
-  LOW_QUOTA_THRESHOLD,
-  REFRESH_TIERS
+  RATE_LIMIT_RETRY_TTL_MS,
+  REFRESH_BANDS,
+  UNAVAILABLE_RETRY_TTL_MS
 } from "../../shared/constants.js";
 
 function getCachedStatus(cached) {
   return cached?.result ?? { kind: "unavailable" };
 }
 
-function getEffectiveTtlMs(tierIndex, leftPercent) {
-  if (Number.isFinite(leftPercent) && leftPercent < LOW_QUOTA_THRESHOLD) {
-    return REFRESH_TIERS[0].ttlMs;
+function getRefreshTtlMs(leftPercent) {
+  if (!Number.isFinite(leftPercent)) {
+    return REFRESH_BANDS[1].ttlMs;
   }
 
-  const tier = REFRESH_TIERS[tierIndex];
-  return tier ? tier.ttlMs : REFRESH_TIERS[REFRESH_TIERS.length - 1].ttlMs;
+  const matchedBand = REFRESH_BANDS.find((band) => leftPercent >= band.minLeftPercent);
+  return matchedBand ? matchedBand.ttlMs : REFRESH_BANDS[REFRESH_BANDS.length - 1].ttlMs;
 }
 
-function advanceTier(refreshCount, tierIndex) {
-  const nextCount = refreshCount + 1;
-  const tier = REFRESH_TIERS[tierIndex] ?? REFRESH_TIERS[REFRESH_TIERS.length - 1];
+function getEffectiveTtlMs(cached) {
+  if (cached?.lastFailureKind === "rate_limited") {
+    return RATE_LIMIT_RETRY_TTL_MS;
+  }
 
-  if (nextCount >= tier.maxRefreshes && tierIndex < REFRESH_TIERS.length - 1) {
-    return { refreshCount: 1, tierIndex: tierIndex + 1 };
+  if (cached?.lastFailureKind === "unavailable") {
+    return UNAVAILABLE_RETRY_TTL_MS;
   }
 
-  return { refreshCount: nextCount, tierIndex };
+  return getRefreshTtlMs(cached?.result?.leftPercent);
 }
 
 function shouldRefreshQuota(cached, cacheTtlMs, now, sessionId) {
@@ -60,9 +62,7 @@ export async function resolveQuotaStatus(config, options = {}) {
   }
 
   const cached = await readCache(config.cacheFilePath);
-  const tierIndex = cached?.tierIndex ?? 0;
-  const leftPercent = cached?.result?.leftPercent;
-  const effectiveTtlMs = getEffectiveTtlMs(tierIndex, leftPercent);
+  const effectiveTtlMs = getEffectiveTtlMs(cached);
 
   const shouldRefresh = options.forceRefresh
     ? true
@@ -76,23 +76,9 @@ export async function resolveQuotaStatus(config, options = {}) {
   const parsed = parseQuotaResponse(response);
 
   if (parsed.kind === "success") {
-    const isNewSession = Boolean(sessionId) && cached?.sessionId !== sessionId;
-    const isLowQuota = Number.isFinite(parsed.leftPercent) && parsed.leftPercent < LOW_QUOTA_THRESHOLD;
-
-    let nextTier;
-    if (isNewSession) {
-      nextTier = { refreshCount: 1, tierIndex: 0 };
-    } else if (isLowQuota) {
-      nextTier = { refreshCount: cached?.refreshCount ?? 0, tierIndex };
-    } else {
-      nextTier = advanceTier(cached?.refreshCount ?? 0, tierIndex);
-    }
-
     await writeSuccessCache(config.cacheFilePath, parsed, {
       now,
-      sessionId,
-      refreshCount: nextTier.refreshCount,
-      tierIndex: nextTier.tierIndex
+      sessionId
     });
     return parsed;
   }
@@ -102,16 +88,27 @@ export async function resolveQuotaStatus(config, options = {}) {
   }
 
   if (parsed.kind === "rate_limited") {
-    await writeRateLimitedCache(config.cacheFilePath, cached, {
+    await writeFailureCache(config.cacheFilePath, cached, {
       now,
-      sessionId
+      sessionId,
+      failureKind: "rate_limited"
     });
     return getCachedStatus(cached);
   }
 
   if (cached?.result) {
+    await writeFailureCache(config.cacheFilePath, cached, {
+      now,
+      sessionId,
+      failureKind: "unavailable"
+    });
     return cached.result;
   }
 
+  await writeFailureCache(config.cacheFilePath, cached, {
+    now,
+    sessionId,
+    failureKind: "unavailable"
+  });
   return parsed;
 }

package/src/core/status/viewModel.js

@@ -1,3 +1,5 @@
+import { LOW_QUOTA_THRESHOLD } from "../../shared/constants.js";
+
 function padTwoDigits(value) {
   return String(value).padStart(2, "0");
 }
@@ -37,7 +39,7 @@ function getSeverity(leftPercent) {
     return "good";
   }
 
-  if (leftPercent >= 25) {
+  if (leftPercent >= LOW_QUOTA_THRESHOLD) {
     return "warn";
   }
 

package/src/shared/constants.js

@@ -4,13 +4,15 @@ export const DEFAULT_INTL_BASE_URL = "https://api.z.ai";
 export const DEFAULT_TIMEOUT_MS = 5000;
 export const DEFAULT_CACHE_TTL_MS = 600_000;
 
-export const REFRESH_TIERS = [
-  { ttlMs: 180_000, maxRefreshes: 5 },   // 3 min × 5
-  { ttlMs: 300_000, maxRefreshes: 5 },   // 5 min × 5
-  { ttlMs: 600_000, maxRefreshes: Infinity } // 10 min (cap)
+export const REFRESH_BANDS = [
+  { minLeftPercent: 80, ttlMs: 120_000 }, // 2 min
+  { minLeftPercent: 30, ttlMs: 300_000 }, // 5 min
+  { minLeftPercent: 0, ttlMs: 120_000 } // 2 min
 ];
 
 export const LOW_QUOTA_THRESHOLD = 30;
+export const RATE_LIMIT_RETRY_TTL_MS = 180_000;
+export const UNAVAILABLE_RETRY_TTL_MS = 120_000;
 export const DEFAULT_DISPLAY_MODE = "left";
 export const DEFAULT_STYLE = "text";
 export const DEFAULT_BAR_WIDTH = 10;