glm-coding-router 0.4.0 → 0.5.0

package/README.md

@@ -233,6 +233,26 @@ Notes:
   orchestration isn't drivable today); the harness is stack-shaped so it can
   be added later.
 
+## usage
+
+Provider usage snapshots (spec §54 v0.5) — what is reliably retrievable:
+
+```powershell
+glm-router usage
+```
+
+- **Z.ai Coding Plan quota** (network): queries the Z.ai monitor endpoint
+  (`/api/monitor/usage/quota/limit`) with your key and shows each credit
+  window — consumed/total, percentage, reset time — plus the plan level.
+  Unreachable endpoint or a rejected request renders `✗ <reason>` and exits 1.
+- **Local totals** (offline): aggregates saved benchmark reports — run count
+  and summed input/output tokens (`glm-router benchmark` writes them).
+- **Claude quota / Codex usage**: always shown as "not available" — neither
+  exposes a headless usage API today (and claude.ai quota is irrelevant while
+  traffic is routed to GLM).
+
+`--json` emits the same data machine-readably. No key configured → `ERROR [10]`.
+
 ## CLI reference
 
 ```text
@@ -245,6 +265,7 @@ glm-router config show
 glm-router config set models.main glm-5.3
 glm-router delegate <name>   run a GLM worker in an isolated git worktree
 glm-router benchmark         measure the Claude+GLM stack on built-in tasks
+glm-router usage             Z.ai quota snapshot + local benchmark totals
 glm-router project init      CLAUDE.md / AGENTS.md managed blocks (--dry-run supported)
 glm-router project remove
 glm-router skill install     optional Codex delegation skill

package/dist/cli.js

@@ -15,6 +15,7 @@ import { skillInstallCommand, skillRemoveCommand } from "./commands/skill.js";
 import { uninstallCommand } from "./commands/uninstall.js";
 import { delegateCommand } from "./commands/delegate.js";
 import { benchmarkCommand } from "./commands/benchmark.js";
+import { usageCommand } from "./commands/usage.js";
 const program = new Command();
 program
     .name("glm-router")
@@ -103,6 +104,10 @@ program
     .option("--max-turns <n>", "worker --max-turns override", (value) => Number(value))
     .option("--repeat <n>", "run each task N times", (value) => Number(value))
     .action((commandOptions) => execute(() => benchmarkCommand({ ...globalOptions(), ...commandOptions })));
+program
+    .command("usage")
+    .description("provider usage snapshots: Z.ai Coding Plan quota + local benchmark totals")
+    .action(() => execute(() => usageCommand(globalOptions())));
 program
     .command("uninstall")
     .description("guided removal (keeps ZAI_API_KEY by default)")

package/dist/commands/usage.js

@@ -0,0 +1,162 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Errors } from "../core/errors.js";
+import { configDir } from "../core/paths.js";
+import { version } from "../core/version.js";
+import { resolveZaiApiKey } from "../core/zai-key.js";
+import { emitJson } from "./context.js";
+/** Z.ai monitor API used by their own dashboard (specs/usage.md). */
+const ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
+/** Window labels for the observed enum values (specs/usage.md); unknown values stay generic. */
+function describeWindow(limit) {
+    if (limit.unit === 3 && typeof limit.number === "number") {
+        return `${limit.number}-hour window`;
+    }
+    if (limit.unit === 6 && limit.number === 1) {
+        return "weekly";
+    }
+    return `window unit=${String(limit.unit)} x ${String(limit.number)}`;
+}
+/** Fetch and validate the Z.ai quota snapshot. Never logs the Authorization header. */
+async function fetchZaiQuota(key, fetchImpl) {
+    let response;
+    try {
+        response = await fetchImpl(ZAI_QUOTA_URL, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    catch (error) {
+        throw new Error(`Z.ai monitor endpoint unreachable (${error instanceof Error ? error.message : "network error"})`);
+    }
+    if (!response.ok) {
+        throw new Error(`Z.ai monitor endpoint returned HTTP ${response.status}`);
+    }
+    let body;
+    try {
+        body = (await response.json());
+    }
+    catch {
+        throw new Error("Z.ai monitor endpoint returned a non-JSON body");
+    }
+    if (body.code !== 200 || typeof body.data !== "object" || body.data === null) {
+        throw new Error(`Z.ai monitor endpoint rejected the request (${body.msg ?? `code ${String(body.code)}`})`);
+    }
+    return body.data;
+}
+/** Aggregate saved benchmark reports (specs/benchmark.md) into one local summary. */
+export function aggregateLocalUsage(home) {
+    const dir = path.join(configDir(home), "benchmarks");
+    let runs = 0;
+    let tokensIn = 0;
+    let tokensOut = 0;
+    let lastFinishedAt = null;
+    if (!fs.existsSync(dir)) {
+        return { runs, tokensIn, tokensOut, lastFinishedAt };
+    }
+    for (const name of fs.readdirSync(dir)) {
+        if (!name.endsWith(".json"))
+            continue;
+        try {
+            const report = JSON.parse(fs.readFileSync(path.join(dir, name), "utf8"));
+            for (const run of report.tasks ?? []) {
+                runs += 1;
+                tokensIn += run.inputTokens ?? 0;
+                tokensOut += run.outputTokens ?? 0;
+            }
+            if (typeof report.finishedAt === "string" && (!lastFinishedAt || report.finishedAt > lastFinishedAt)) {
+                lastFinishedAt = report.finishedAt;
+            }
+        }
+        catch {
+            // Malformed report files are skipped — usage must never crash on bad data.
+        }
+    }
+    return { runs, tokensIn, tokensOut, lastFinishedAt };
+}
+/**
+ * glm-router usage (spec §54 v0.5, specs/usage.md): provider usage snapshots
+ * where APIs allow reliable retrieval. Z.ai quota via the monitor endpoint;
+ * Claude/Codex have no headless usage surface and say so; local totals come
+ * from saved benchmark reports.
+ */
+export async function usageCommand(options, deps = {}) {
+    const home = deps.home ?? os.homedir();
+    const env = deps.env ?? process.env;
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const resolved = resolveZaiApiKey({ env, readUserEnv: deps.readUserEnv });
+    if (!resolved) {
+        throw Errors.zaiKeyMissing();
+    }
+    let quota;
+    let quotaError;
+    try {
+        quota = await fetchZaiQuota(resolved.key, fetchImpl);
+    }
+    catch (error) {
+        quotaError = error instanceof Error ? error.message : String(error);
+    }
+    const local = aggregateLocalUsage(home);
+    const limits = quota?.limits ?? [];
+    const json = {
+        version,
+        zai: quotaError
+            ? { ok: false, error: quotaError }
+            : {
+                ok: true,
+                level: quota?.level ?? null,
+                limits: limits.map((limit) => ({
+                    window: describeWindow(limit),
+                    consumed: limit.currentValue ?? null,
+                    total: limit.usage ?? null,
+                    remaining: limit.remaining ?? null,
+                    percentage: limit.percentage ?? null,
+                    resetsAt: typeof limit.nextResetTime === "number" ? new Date(limit.nextResetTime).toISOString() : null,
+                })),
+            },
+        local,
+        claude: "not available — Claude Code exposes no headless usage API",
+        codex: "not available — Codex exposes no plan-usage API",
+    };
+    if (options.json) {
+        emitJson(json);
+        return quotaError ? 1 : 0;
+    }
+    const lines = [`GLM Coding Router v${version} — usage snapshot`, ""];
+    if (quotaError) {
+        lines.push(`Z.ai Coding Plan`);
+        lines.push(`  ✗ ${quotaError}`);
+    }
+    else {
+        lines.push(`Z.ai Coding Plan${quota?.level ? ` (level: ${quota.level})` : ""}`);
+        if (limits.length === 0) {
+            lines.push("  (no quota windows reported)");
+        }
+        for (const limit of limits) {
+            const consumed = limit.currentValue ?? "?";
+            const total = limit.usage ?? "?";
+            const percentage = typeof limit.percentage === "number"
+                ? limit.percentage
+                : typeof limit.currentValue === "number" && typeof limit.usage === "number" && limit.usage > 0
+                    ? Math.round((limit.currentValue / limit.usage) * 100)
+                    : "?";
+            const resets = typeof limit.nextResetTime === "number" ? ` — resets ${new Date(limit.nextResetTime).toISOString()}` : "";
+            lines.push(`  ${describeWindow(limit).padEnd(15)} ${consumed} / ${total} credits (${percentage}%)${resets}`);
+        }
+    }
+    lines.push("");
+    lines.push("Local (benchmark reports)");
+    if (local.runs === 0) {
+        lines.push("  (none yet — run glm-router benchmark)");
+    }
+    else {
+        lines.push(`  runs ${local.runs} · tokens ${local.tokensIn} in / ${local.tokensOut} out · last ${local.lastFinishedAt}`);
+    }
+    lines.push("");
+    lines.push(`Claude quota   ${json.claude}`);
+    lines.push(`Codex usage    ${json.codex}`);
+    process.stdout.write(lines.join("\n") + "\n");
+    return quotaError ? 1 : 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glm-coding-router",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "GLM Coding Plan workers for Claude Code and Codex",
   "type": "module",
   "license": "MIT",