Keep usage logins visible and explain unavailable quota (#5876)

* fix(usage): keep existing logins visible and explain unavailable quota

Credential discovery must preserve accounts whose login exists even when it has expired. Keep vendor failures on the discovered account and isolate discovery failures without inventing provider cards.

* test(usage): align credential route tests with account discovery

plugins/zai-usage-source/server/usage.test.ts

@@ -2,7 +2,7 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { identify, fetchUsage } from "./usage.js";
+import { discover, fetchUsage } from "./usage.js";
 import type { UsageReport } from "@getpaseo/plugin/server/usage";
 
 function mockFetch(handlers: Map<string, () => Response>): typeof fetch {
@@ -65,14 +65,14 @@ describe("zai usage source", () => {
   ) {
     return {
       listUsage: async () => {
-        const report = await fetchUsage({}, (url, init) => fetchApi(url, init));
+        const report = await fetchFirst((url, init) => fetchApi(url, init));
         return {
           providers: [
             {
               providerId: "zai",
               ...report,
-              error: report.error ?? null,
-              planLabel: report.planLabel ?? null,
+              error: report.status === "error" ? report.error : null,
+              planLabel: report.status === "available" ? (report.planLabel ?? null) : null,
             },
           ],
         };
@@ -118,17 +118,60 @@ describe("zai usage source", () => {
   });
 });
 
-it("identify returns a key when fetch finds zai credentials", async () => {
+it("discovery returns a locator when fetch finds zai credentials", async () => {
   const previous = process.env["ZAI_API_KEY"];
   try {
     process.env["ZAI_API_KEY"] = "fixture-token";
     let requested = false;
-    await fetchUsage({}, async () => {
+    await fetchFirst(async () => {
       requested = true;
       return new Response(null, { status: 401 });
     });
     expect(requested).toBe(true);
-    expect(await identify()).toEqual({ key: "default" });
+    expect(await discover()).toEqual([
+      { key: "default", input: { store: "env", locator: "ZAI_API_KEY" } },
+    ]);
+  } finally {
+    if (previous === undefined) delete process.env["ZAI_API_KEY"];
+    else process.env["ZAI_API_KEY"] = previous;
+  }
+});
+
+describe("account discovery", () => {
+  it.each(["empty home", "unrelated files"])("returns no accounts for %s", async (scenario) => {
+    const { mkdtemp, writeFile, rm } = await import("node:fs/promises");
+    const directory = await mkdtemp(join(tmpdir(), "usage-empty-"));
+    const original = { ...process.env };
+    try {
+      for (const key of Object.keys(process.env)) delete process.env[key];
+      process.env.HOME = directory;
+      process.env.USERPROFILE = directory;
+      if (scenario === "unrelated files") await writeFile(join(directory, "unrelated.json"), "{}");
+      expect(await discover()).toEqual([]);
+    } finally {
+      for (const key of Object.keys(process.env)) delete process.env[key];
+      Object.assign(process.env, original);
+      await rm(directory, { recursive: true, force: true });
+    }
+  });
+});
+
+async function fetchFirst(fetchApi: typeof fetch) {
+  const accounts = await discover();
+  const account = accounts[0];
+  if (!account) throw new Error("No configured account");
+  return fetchUsage(account.input as Parameters<typeof fetchUsage>[0], fetchApi);
+}
+
+it.each([401, 403])("reports an existing login rejected with HTTP %i", async (status) => {
+  const previous = process.env["ZAI_API_KEY"];
+  try {
+    process.env["ZAI_API_KEY"] = "fixture-rejected-login";
+    const report = await fetchUsage(
+      { store: "env", locator: "ZAI_API_KEY" },
+      async () => new Response(null, { status }),
+    );
+    expect(report).toEqual({ status: "unavailable", problem: { kind: "rejected", status } });
   } finally {
     if (previous === undefined) delete process.env["ZAI_API_KEY"];
     else process.env["ZAI_API_KEY"] = previous;

plugins/zai-usage-source/server/usage.ts

@@ -1,7 +1,8 @@
 import type { UsageInput } from "../shared/input.js";
 import { z } from "zod";
 import {
-  unavailableUsage,
+  unavailable,
+  type UsageAccount,
   type UsageReport,
   type UsageDetail,
 } from "@getpaseo/plugin/server/usage";
@@ -28,10 +29,8 @@ export async function fetchUsage(
   input: UsageInput,
   fetchApi: typeof fetch = fetch,
 ): Promise<UsageReport> {
-  void input;
-
-  const token = process.env["ZAI_API_KEY"] || process.env["GLM_API_KEY"];
-  if (!token) return unavailableUsage();
+  const token = process.env[input.locator];
+  if (!token) throw new Error("Z.ai login store no longer exists");
 
   const res = await fetchApi("https://api.z.ai/api/biz/subscription/list", {
     signal: AbortSignal.timeout(15_000),
@@ -41,13 +40,13 @@ export async function fetchUsage(
     },
   });
 
-  if (!res.ok) {
-    return unavailableUsage();
-  }
+  if (res.status === 401 || res.status === 403)
+    return unavailable({ kind: "rejected", status: res.status });
+  if (!res.ok) throw new Error(`Z.ai usage API returned ${res.status}`);
 
   const resp = ZaiUsageResponseSchema.parse(await res.json());
   const sub = resp.data?.[0];
-  if (!sub) return unavailableUsage();
+  if (!sub) return unavailable({ kind: "no_quota", detail: "No active coding plan" });
 
   const details: UsageDetail[] = [];
   if (sub.status) details.push({ id: "status", label: "Status", value: sub.status });
@@ -65,6 +64,9 @@ export async function fetchUsage(
   };
 }
 
-export async function identify() {
-  return process.env["ZAI_API_KEY"] || process.env["GLM_API_KEY"] ? { key: "default" } : null;
+export async function discover(): Promise<UsageAccount[]> {
+  for (const locator of ["ZAI_API_KEY", "GLM_API_KEY"]) {
+    if (process.env[locator]) return [{ key: "default", input: { store: "env", locator } }];
+  }
+  return [];
 }