@getpaseo/server 0.11.0-beta.2 → 0.11.0-beta.3

package/dist/server/builtin-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 [];
 }

package/dist/server/builtin-plugins/zai-usage-source/shared/input.ts

@@ -1,4 +1,8 @@
 import { z } from "zod";
-export const inputSchema = z.object({}).strict();
-
+export const inputSchema = z
+  .object({
+    store: z.literal("env"),
+    locator: z.string().min(1),
+  })
+  .strict();
 export type UsageInput = z.infer<typeof inputSchema>;

package/dist/server/server/plugins/index.d.ts

@@ -17,7 +17,6 @@ interface PluginRuntimePort {
     clearLogs(pluginId: string): void;
     getProviderRegistrations?(pluginId: string): readonly PluginProviderMetadata[];
     getUsageSourceRegistrations(pluginId: string): readonly PluginUsageSourceMetadata[];
-    identifyUsage: PluginRuntime["identifyUsage"];
     fetchUsage: PluginRuntime["fetchUsage"];
     discoverUsage: PluginRuntime["discoverUsage"];
     connectProvider: PluginRuntime["connectProvider"];
@@ -76,7 +75,7 @@ export declare class PluginService {
         sourceId: string;
         sourceLabel: string;
         report: {
-            status: "error" | "unavailable" | "available";
+            status: "available";
             windows: {
                 id: string;
                 label: string;
@@ -106,7 +105,23 @@ export declare class PluginService {
                 value: string;
                 tone?: "default" | "warning" | "danger" | "ok" | undefined;
             }[] | undefined;
-            error?: string | undefined;
+        } | {
+            status: "unavailable";
+            problem: {
+                kind: "expired";
+                expiresAt: string;
+                refreshedBy?: string | undefined;
+            } | {
+                kind: "rejected";
+                status: number;
+                refreshedBy?: string | undefined;
+            } | {
+                kind: "no_quota";
+                detail: string;
+            };
+        } | {
+            status: "error";
+            error: string;
         };
         icon?: string | undefined;
     }[]>;

package/dist/server/server/plugins/index.js

@@ -24,7 +24,6 @@ export class PluginService {
         this.errors = new Map();
         this.listeners = new Set();
         this.providers = new Map();
-        this.usageSources = new UsageSourceRegistry();
         this.usageSourceIdsByPlugin = new Map();
         this.providerIdsByPlugin = new Map();
         this.providerListeners = new Set();
@@ -42,6 +41,7 @@ export class PluginService {
             return request;
         };
         this.logger = logger.child({ module: "plugin-service" });
+        this.usageSources = new UsageSourceRegistry(Date.now, 300000, this.logger);
         this.runtime =
             dependencies.runtime ??
                 new PluginRuntime(logger, daemonVersion, {
@@ -477,7 +477,6 @@ export class PluginService {
                             throw new Error(`Invalid usage discovery from ${source.id}`);
                         return result;
                     },
-                    identify: (input) => this.runtime.identifyUsage(pluginId, source.id, input),
                     fetch: (input) => {
                         return this.runtime.fetchUsage(pluginId, source.id, input);
                     },

package/dist/server/server/plugins/plugin-process-protocol.d.ts

@@ -40,11 +40,6 @@ export type PluginProcessRequest = {
 } | {
     type: "hook.cancel";
     requestId: string;
-} | {
-    type: "usage.identify";
-    requestId: string;
-    sourceId: string;
-    input: unknown;
 } | {
     type: "usage.fetch";
     requestId: string;

package/dist/server/server/plugins/plugin-process-protocol.js

@@ -83,14 +83,6 @@ export const PluginProcessRequestSchema = z.discriminatedUnion("type", [
     })
         .strict(),
     z.object({ type: z.literal("hook.cancel"), requestId: z.string() }).strict(),
-    z
-        .object({
-        type: z.literal("usage.identify"),
-        requestId: z.string(),
-        sourceId: z.string(),
-        input: z.unknown(),
-    })
-        .strict(),
     z
         .object({
         type: z.literal("usage.fetch"),

package/dist/server/server/plugins/plugin-process.js

@@ -296,15 +296,12 @@ export function createPluginWorker(options) {
             if (message.type === "usage.discover")
                 return jsonTransportValue(await source.discover());
             const input = await source.input.parseAsync(message.input);
-            return jsonTransportValue(message.type === "usage.identify"
-                ? await source.identify(input)
-                : await source.fetch(input));
+            return jsonTransportValue(await source.fetch(input));
         })().then((output) => send({ type: "result", requestId: message.requestId, output }), (error) => send({ type: "error", requestId: message.requestId, error: describeError(error) }));
     }
     function rejectWhileStopping(message) {
         if (message.type === "provider.status" ||
             message.type === "provider.catalog_key" ||
-            message.type === "usage.identify" ||
             message.type === "usage.fetch" ||
             message.type === "usage.discover") {
             send({ type: "error", requestId: message.requestId, error: "Plugin is stopping" });
@@ -389,9 +386,7 @@ export function createPluginWorker(options) {
             })().catch((error) => send({ type: "error", requestId: message.requestId, error: describeError(error) }));
             return;
         }
-        if (message.type === "usage.identify" ||
-            message.type === "usage.fetch" ||
-            message.type === "usage.discover") {
+        if (message.type === "usage.fetch" || message.type === "usage.discover") {
             handleUsageRequest(message);
             return;
         }

package/dist/server/server/plugins/runtime.d.ts

@@ -57,7 +57,6 @@ export declare class PluginRuntime {
     }>;
     getProviderRegistrations(pluginId: string): readonly PluginProviderMetadata[];
     getUsageSourceRegistrations(pluginId: string): readonly PluginUsageSourceMetadata[];
-    identifyUsage(pluginId: string, sourceId: string, input: unknown): Promise<unknown>;
     fetchUsage(pluginId: string, sourceId: string, input: unknown): Promise<unknown>;
     discoverUsage(pluginId: string, sourceId: string): Promise<unknown>;
     getProviderStatus(pluginId: string, providerId: string, request: ProviderStatusRequest): Promise<ProviderStatus>;

package/dist/server/server/plugins/runtime.js

@@ -241,17 +241,6 @@ export class PluginRuntime {
     getUsageSourceRegistrations(pluginId) {
         return this.plugins.get(pluginId)?.usageSources ?? [];
     }
-    identifyUsage(pluginId, sourceId, input) {
-        const loaded = this.plugins.get(pluginId);
-        if (!loaded)
-            throw new Error(`Plugin is not available: ${pluginId}`);
-        return this.request(loaded, {
-            type: "usage.identify",
-            requestId: randomUUID(),
-            sourceId,
-            input,
-        });
-    }
     fetchUsage(pluginId, sourceId, input) {
         const loaded = this.plugins.get(pluginId);
         if (!loaded)

package/dist/server/server/plugins/test-fixtures/usage-source/index.server.js

@@ -11,12 +11,21 @@ export default function contribute(server) {
                 { account: "one" },
                 { account: "bad", extra: true },
                 { account: "throws" },
+                { account: "expired" },
             ];
-            return inputs;
+            return inputs.map((input) => ({ key: String(input.account), input }));
         },
-        identify: async (input) => ({ key: input.account }),
         fetch: async (input) => {
             const account = input.account;
+            if (account === "expired")
+                return {
+                    status: "unavailable",
+                    problem: {
+                        kind: "expired",
+                        expiresAt: new Date(Date.now() - 3600000).toISOString(),
+                        refreshedBy: "claude",
+                    },
+                };
             if (account === "throws")
                 throw new Error("fixture failure");
             fetches++;

package/dist/server/server/plugins/test-fixtures/usage-source-directory/index.server.js

@@ -11,12 +11,21 @@ export default function contribute(server) {
                 { account: "one" },
                 { account: "bad", extra: true },
                 { account: "throws" },
+                { account: "expired" },
             ];
-            return inputs;
+            return inputs.map((input) => ({ key: String(input.account), input }));
         },
-        identify: async (input) => ({ key: input.account }),
         fetch: async (input) => {
             const account = input.account;
+            if (account === "expired")
+                return {
+                    status: "unavailable",
+                    problem: {
+                        kind: "expired",
+                        expiresAt: new Date(Date.now() - 3600000).toISOString(),
+                        refreshedBy: "claude",
+                    },
+                };
             if (account === "throws")
                 throw new Error("fixture failure");
             fetches++;

package/dist/server/server/plugins/usage-sources/index.d.ts

@@ -1,27 +1,24 @@
+import type { Logger } from "pino";
 import { type ProviderUsage, type UsageReportEntry } from "@getpaseo/protocol/messages";
 export interface UsageSource {
     id: string;
     label: string;
     icon?: string;
-    discover(): Promise<unknown[]>;
-    identify(input: unknown): Promise<{
-        key: string;
-        label?: string;
-    } | null>;
+    discover(): Promise<unknown>;
     fetch(input: unknown): Promise<unknown>;
 }
 /** Owns account identity, ordered logins for each account, and the five-minute fetch cache. */
 export declare class UsageSourceRegistry {
     private readonly now;
     private readonly ttlMs;
+    private readonly logger;
     private readonly sources;
     private readonly known;
     private readonly cache;
     private readonly pending;
-    constructor(now?: () => number, ttlMs?: number);
+    constructor(now?: () => number, ttlMs?: number, logger?: Pick<Logger, "warn">);
     register(source: UsageSource): void;
     unregister(id: string): void;
-    private identify;
     listReports(options?: {
         forceRefresh?: boolean;
         reportIds?: string[];
@@ -33,6 +30,7 @@ export declare class UsageSourceRegistry {
     }>;
     private fetchId;
     private writeCache;
-    private errorEntry;
+    private fetchWithFallback;
+    private fetchLogin;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/server/server/plugins/usage-sources/index.js

@@ -1,9 +1,11 @@
+import { z } from "zod";
 import { UsageReportSchema, } from "@getpaseo/protocol/messages";
 /** Owns account identity, ordered logins for each account, and the five-minute fetch cache. */
 export class UsageSourceRegistry {
-    constructor(now = Date.now, ttlMs = 300000) {
+    constructor(now = Date.now, ttlMs = 300000, logger = { warn: console.warn }) {
         this.now = now;
         this.ttlMs = ttlMs;
+        this.logger = logger;
         this.sources = new Map();
         this.known = new Map();
         this.cache = new Map();
@@ -23,56 +25,34 @@ export class UsageSourceRegistry {
             if (key.startsWith(`${id}:`))
                 this.cache.delete(key);
     }
-    async identify(source, input) {
-        try {
-            const account = await source.identify(input);
-            if (account === null)
-                return null;
-            if (typeof account !== "object" ||
-                (account.label !== undefined && typeof account.label !== "string"))
-                throw new Error(`Invalid account identity from ${source.id}`);
-            if (typeof account.key !== "string" || !/^[A-Za-z0-9._-]{1,128}$/.test(account.key))
-                throw new Error(`Invalid account key from ${source.id}`);
-            return { id: `${source.id}:${account.key}`, label: account.label };
-        }
-        catch (error) {
-            const id = `${source.id}:!error`;
-            this.writeCache(id, this.errorEntry(source, id, error));
-            return { id, error: true };
-        }
-    }
     async listReports(options = {}) {
         const ids = options.reportIds ?? (await this.discoverReportIds());
-        return Promise.all([...new Set(ids)]
-            .filter((id) => this.known.has(id) || this.cache.has(id))
-            .map((id) => this.fetchId(id, options.forceRefresh)));
+        return Promise.all([...new Set(ids)].flatMap((id) => {
+            const known = this.known.get(id);
+            return known ? [this.fetchId(id, known, options.forceRefresh)] : [];
+        }));
     }
     async discoverReportIds() {
         const discovered = await Promise.all([...this.sources.values()].map(async (source) => {
             try {
-                const inputs = await source.discover();
-                if (!Array.isArray(inputs))
-                    throw new Error("Usage discovery must return an array");
-                const accounts = await Promise.all(inputs.map((input) => this.identify(source, input)));
-                // Group in discovery order so an account's logins keep the source's preference.
+                const accounts = z
+                    .array(z.object({
+                    key: z.string().regex(/^[A-Za-z0-9._-]{1,128}$/),
+                    label: z.string().optional(),
+                    input: z.json(),
+                }))
+                    .parse(await source.discover());
                 const knownReports = new Map();
                 const ids = [];
-                accounts.forEach((account, index) => {
-                    if (account === null)
-                        return;
-                    ids.push(account.id);
-                    if (account.error)
-                        return;
-                    const known = knownReports.get(account.id);
+                for (const account of accounts) {
+                    const id = `${source.id}:${account.key}`;
+                    ids.push(id);
+                    const known = knownReports.get(id);
                     if (known)
-                        known.inputs.push(inputs[index]);
+                        known.inputs.push(account.input);
                     else
-                        knownReports.set(account.id, {
-                            source,
-                            inputs: [inputs[index]],
-                            label: account.label,
-                        });
-                });
+                        knownReports.set(id, { source, inputs: [account.input], label: account.label });
+                }
                 for (const key of this.known.keys()) {
                     if (key.startsWith(`${source.id}:`))
                         this.known.delete(key);
@@ -82,9 +62,12 @@ export class UsageSourceRegistry {
                 return ids;
             }
             catch (error) {
-                const id = `${source.id}:!error`;
-                this.writeCache(id, this.errorEntry(source, id, error));
-                return [id];
+                for (const key of this.known.keys()) {
+                    if (key.startsWith(`${source.id}:`))
+                        this.known.delete(key);
+                }
+                this.logger.warn({ sourceId: source.id, err: error }, "Usage source discovery failed");
+                return [];
             }
         }));
         return discovered.flat();
@@ -102,49 +85,31 @@ export class UsageSourceRegistry {
                     ? `${entry.sourceLabel} (${entry.account.label})`
                     : entry.sourceLabel,
                 status: entry.report.status,
-                planLabel: entry.report.planLabel ?? null,
-                windows: entry.report.windows,
-                balances: entry.report.balances ?? [],
-                details: entry.report.details ?? [],
-                error: entry.report.error ?? null,
+                planLabel: entry.report.status === "available" ? (entry.report.planLabel ?? null) : null,
+                windows: entry.report.status === "available" ? entry.report.windows : [],
+                balances: entry.report.status === "available" ? (entry.report.balances ?? []) : [],
+                details: entry.report.status === "available" ? (entry.report.details ?? []) : [],
+                error: legacyError(entry.report, this.now()),
             })),
         };
     }
-    fetchId(id, forceRefresh = false) {
-        const known = this.known.get(id);
+    fetchId(id, known, forceRefresh = false) {
         const cached = this.cache.get(id);
-        if (!known)
-            return Promise.resolve(cached.entry);
         if (!forceRefresh && cached && this.now() - cached.at < this.ttlMs)
             return Promise.resolve(cached.entry);
         const pending = this.pending.get(id);
         if (pending)
             return pending;
         const request = (async () => {
-            let entry = {
+            const entry = {
                 id,
                 sourceId: known.source.id,
                 sourceLabel: known.source.label,
                 icon: known.source.icon,
                 account: { label: known.label },
                 fetchedAt: new Date(this.now()).toISOString(),
-                report: { status: "unavailable", windows: [] },
+                report: await this.fetchWithFallback(known),
             };
-            for (const input of known.inputs) {
-                try {
-                    // A harness can switch accounts between discovery and a targeted refresh.
-                    const account = await known.source.identify(input);
-                    if (!account || `${known.source.id}:${account.key}` !== id)
-                        continue;
-                    const report = UsageReportSchema.parse(await known.source.fetch(input));
-                    entry.report = report;
-                    if (report.status === "available")
-                        break;
-                }
-                catch (error) {
-                    entry = this.errorEntry(known.source, id, error, known.label);
-                }
-            }
             this.writeCache(id, entry);
             return entry;
         })();
@@ -163,20 +128,50 @@ export class UsageSourceRegistry {
         }
         this.cache.set(id, { at, entry });
     }
-    errorEntry(source, id, error, label, fetchedAt = new Date(this.now()).toISOString()) {
-        return {
-            id,
-            sourceId: source.id,
-            sourceLabel: source.label,
-            icon: source.icon,
-            account: { label },
-            fetchedAt,
-            report: {
-                status: "error",
-                windows: [],
-                error: error instanceof Error ? error.message : String(error),
-            },
-        };
+    async fetchWithFallback(known) {
+        let report = await this.fetchLogin(known.source, known.inputs[0]);
+        for (const input of known.inputs.slice(1)) {
+            if (report.status === "available")
+                break;
+            report = await this.fetchLogin(known.source, input);
+        }
+        return report;
+    }
+    async fetchLogin(source, input) {
+        try {
+            return UsageReportSchema.parse(await source.fetch(input));
+        }
+        catch (error) {
+            return { status: "error", error: error instanceof Error ? error.message : String(error) };
+        }
     }
 }
+// The legacy RPC has only an error string; the current app owns its own presentation.
+// COMPAT(providerUsageList): added in v0.1.98, remove after 2027-03-26.
+function legacyProblem(problem, now) {
+    if (problem.kind === "no_quota")
+        return problem.detail;
+    const remedy = problem.refreshedBy
+        ? `Run ${problem.refreshedBy} to refresh it.`
+        : "Sign in again.";
+    if (problem.kind === "rejected")
+        return `Login rejected (HTTP ${problem.status}). ${remedy}`;
+    const elapsed = Math.max(0, now - Date.parse(problem.expiresAt));
+    let ago = "just now";
+    if (elapsed >= 86400000)
+        ago = `${Math.floor(elapsed / 86400000)}d ago`;
+    else if (elapsed >= 3600000)
+        ago = `${Math.floor(elapsed / 3600000)}h ago`;
+    else if (elapsed >= 60000)
+        ago = `${Math.floor(elapsed / 60000)}m ago`;
+    return `Login expired ${ago}. ${remedy}`;
+}
+// COMPAT(providerUsageList): added in v0.1.98, remove after 2027-03-26.
+function legacyError(report, now) {
+    if (report.status === "error")
+        return report.error;
+    if (report.status === "unavailable")
+        return legacyProblem(report.problem, now);
+    return null;
+}
 //# sourceMappingURL=index.js.map