@bacnh85/pi-sub 0.1.6 → 0.1.8

package/README.md

@@ -2,7 +2,7 @@
 
 Pi extension that shows subscription usage for the currently selected supported model provider.
 
-V1 supports OpenAI Codex models by reading Pi's auth state from `~/.pi/agent/auth.json` (or `$PI_CODING_AGENT_DIR/auth.json`) and displays a subscription footer status after Pi's built-in status/token usage line only while the active Pi model provider is `openai-codex`.
+Supports OpenAI Codex (`openai-codex`) with live usage windows from ChatGPT's usage endpoint, OpenCode Go (`opencode-go`) with session cost tracking, and Z.ai (`zai`) with GLM Coding Plan quota monitoring. Displays a subscription footer status after Pi's built-in status/token usage line.
 
 ## Install
 
@@ -26,6 +26,8 @@ pi -e ./extensions/pi-sub
 
 ## What it shows
 
+### OpenAI Codex
+
 The footer status appears after Pi's built-in status/token usage line and includes:
 
 - active account email;
@@ -40,6 +42,22 @@ Example subscription line:
 Sub · Plus · user@example.com · 5H 85% (18:12) · W 80% (08:00 on 2 Jul) · gpt-5-codex
 ```
 
+### OpenCode Go
+
+OpenCode Go does not expose usage windows, so the footer shows only the accumulated session cost:
+
+```text
+OpenCode Go $0.23
+```
+
+### Z.ai
+
+Z.ai (GLM Coding Plan) shows 5-hour rolling and weekly quota percentages with reset times:
+
+```text
+R:55%(18:12) W:80%(08:00 on 2 Jul)
+```
+
 When the current model provider is not supported, `pi-sub` clears its subscription line and does not refresh subscription data.
 
 ## Commands
@@ -57,6 +75,24 @@ ACCOUNT                 PLAN  5H USAGE     WEEKLY USAGE           LAST ACTIVITY
 * user@example.com     Plus  85% (18:12)  80% (08:00 on 2 Jul)   Now
 ```
 
+For OpenCode Go, `/sub` shows the provider/model and session cost:
+
+```text
+Provider: OpenCode Go · Model: kimi-k2.6 · Fetched: 14:23
+OpenCode Go does not expose usage windows.
+Session cost: $0.23
+```
+
+For Z.ai, `/sub` shows the rolling and weekly quota windows:
+
+```text
+Provider: Z.ai · Model: glm-5.2 · Fetched: 14:23
+
+  ACCOUNT             PLAN  ROLLING        WEEKLY             LAST ACTIVITY
+  ------------------------------------------------------------------------
+* Z.ai subscription  ?     55%/18:12      80%/08:00 on 2 Jul  Now
+```
+
 ## Refresh behavior
 
 `pi-sub` refreshes usage data:
@@ -73,12 +109,11 @@ Refreshes are cached briefly to avoid excessive usage endpoint calls.
 
 ## Requirements and troubleshooting
 
-- Pi auth must contain an `openai-codex` OAuth entry in `~/.pi/agent/auth.json` or `$PI_CODING_AGENT_DIR/auth.json`.
-- The entry must include `access` and `accountId` fields.
-- `pi-sub` redacts auth/token-related errors and never prints Codex tokens.
-
-If usage is unavailable, verify that Pi can use the `openai-codex` provider and that the auth file exists.
+- **OpenAI Codex**: Pi auth must contain an `openai-codex` OAuth entry in `~/.pi/agent/auth.json` or `$PI_CODING_AGENT_DIR/auth.json`. The entry must include `access` and `accountId` fields.
+- **OpenCode Go**: Pi auth must contain an `opencode-go` API key entry (via `/login` or env var). The entry must have a `key` field or an `accountId` field.
+- **Z.ai**: Pi auth must contain a `zai` entry in `auth.json` with a `key` field (the same API key used for Z.ai model access via `@czottmann/pi-zai-api`). The Z.ai provider must be registered (e.g., `pi install npm:@czottmann/pi-zai-api`).
+- `pi-sub` redacts auth/token-related errors and never prints credentials.
 
 ## Design notes
 
-The extension is named `pi-sub` rather than `pi-codex-usage` so future subscription providers can be added as separate adapters. V1 intentionally supports only OpenAI Codex and vendors only the small amount of behavior needed for this extension instead of invoking `codex-auth` directly.
+The extension is named `pi-sub` rather than `pi-codex-usage` so future subscription providers can be added as separate adapters. Supports OpenAI Codex (live usage API) and OpenCode Go (session cost only).

package/index.ts

@@ -12,6 +12,8 @@ const REFRESH_TTL_MS = 30_000;
 const REFRESH_DEBOUNCE_MS = 2_000;
 const CODEX_PROVIDER = "openai-codex";
 const OPC_PROVIDER = "opencode-go";
+const ZAI_PROVIDER = "zai";
+const ZAI_USAGE_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
 
 type ModelLike = { provider?: string; id?: string } | undefined;
 
@@ -98,6 +100,10 @@ function isOpenCodeGoModel(model: ModelLike): boolean {
 	return (model?.provider?.toLowerCase() ?? "") === OPC_PROVIDER;
 }
 
+function isZaiModel(model: ModelLike): boolean {
+	return (model?.provider?.toLowerCase() ?? "") === ZAI_PROVIDER;
+}
+
 function piAuthPath(): string {
 	const configDir = process.env.PI_CODING_AGENT_DIR?.trim() || path.join(os.homedir(), ".pi", "agent");
 	return path.join(configDir, "auth.json");
@@ -230,25 +236,6 @@ function parseUsageResponse(body: unknown): UsageApiSnapshot | undefined {
 	};
 }
 
-function parseOpcodeUsageResponse(body: unknown): UsageApiSnapshot | undefined {
-	if (!body || typeof body !== "object") return undefined;
-	const root = body as any;
-	const usage = root.usage ?? root;
-	const parseWindow = (window: any): UsageApiWindow | undefined => {
-		if (!window || typeof window !== "object" || typeof window.used_percent !== "number") return undefined;
-		return {
-			used_percent: window.used_percent,
-			limit_window_seconds: typeof window.limit_window_seconds === "number" ? window.limit_window_seconds : undefined,
-			reset_at: typeof window.reset_at === "number" ? window.reset_at : typeof window.reset_ts === "number" ? window.reset_ts : undefined,
-		};
-	};
-	return {
-		primary: parseWindow(usage.rolling ?? usage.primary_window),
-		secondary: parseWindow(usage.weekly ?? usage.secondary_window),
-		plan_type: typeof root.plan_type === "string" ? root.plan_type : typeof usage.plan_type === "string" ? usage.plan_type : undefined,
-	};
-}
-
 async function readPiCodexAuth(): Promise<PiAuthEntry & { accountId: string }> {
 	const auth = await readJsonFile<PiAuthFile>(piAuthPath());
 	const entry = auth[CODEX_PROVIDER];
@@ -257,11 +244,19 @@ async function readPiCodexAuth(): Promise<PiAuthEntry & { accountId: string }> {
 	return { ...entry, accountId };
 }
 
-async function readOpenCodeGoAuth(): Promise<{ key: string }> {
+async function readOpenCodeGoAuth(): Promise<{ key?: string; accountId?: string }> {
 	const auth = await readJsonFile<PiAuthFile>(piAuthPath());
 	const entry = auth[OPC_PROVIDER];
-	if (!entry?.key || typeof entry.key !== "string") throw new Error("Missing opencode-go API key in Pi auth");
-	return { key: entry.key };
+	if (!entry?.key && !entry?.accountId) throw new Error("Missing opencode-go API key or accountId in Pi auth");
+	if (typeof entry.key === "string") return { key: entry.key };
+	return { accountId: typeof entry.accountId === "string" ? entry.accountId : undefined };
+}
+
+async function readZaiAuth(): Promise<string> {
+	const auth = await readJsonFile<PiAuthFile>(piAuthPath());
+	const entry = auth[ZAI_PROVIDER];
+	if (!entry?.key) throw new Error("Missing zai API key in Pi auth");
+	return entry.key;
 }
 
 async function fetchUsageFromPiAuth(entry: PiAuthEntry, signal?: AbortSignal): Promise<UsageApiSnapshot | undefined> {
@@ -285,6 +280,7 @@ function redactedError(error: unknown, provider = "Codex"): string {
 	if (/ENOENT|no such file/i.test(message)) return "Pi auth not found";
 	if (/missing openai-codex/i.test(message)) return "openai-codex auth not found";
 	if (/missing opencode-go/i.test(message)) return "opencode-go auth not found";
+	if (/missing zai/i.test(message)) return "zai auth not found";
 	if (/timed out|timeout|aborted/i.test(message)) return `${provider} usage refresh timed out`;
 	if (/401|403|auth|token|unauthorized|forbidden/i.test(message)) return `${provider} auth unavailable`;
 	return `${provider} usage unavailable`;
@@ -314,7 +310,7 @@ async function fetchCodexUsage(signal?: AbortSignal): Promise<SubscriptionUsageS
 	}
 }
 
-async function fetchOpenCodeGoUsage(signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
+async function fetchOpenCodeGoUsage(_signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
 	try {
 		await readOpenCodeGoAuth();
 		return {
@@ -322,7 +318,6 @@ async function fetchOpenCodeGoUsage(signal?: AbortSignal): Promise<SubscriptionU
 			providerDisplayName: "OpenCode Go",
 			accounts: [],
 			fetchedAt: Date.now(),
-			error: "OpenCode Go usage tracking not yet implemented",
 		};
 	} catch (error) {
 		return {
@@ -335,6 +330,109 @@ async function fetchOpenCodeGoUsage(signal?: AbortSignal): Promise<SubscriptionU
 	}
 }
 
+// ---------------------------------------------------------------------------
+// Z.ai adapter
+// ---------------------------------------------------------------------------
+
+interface ZaiLimitEntry {
+	type: string;
+	percentage: number;
+	nextResetTime?: number;
+}
+
+interface ZaiUsageApiResponse {
+	data?: {
+		limits?: ZaiLimitEntry[];
+	};
+}
+
+interface ZaiUsageApiError {
+	code: number;
+	msg: string;
+	success: boolean;
+}
+
+function zaiLimitToUsageWindow(limit: ZaiLimitEntry): UsageWindow | undefined {
+	if (typeof limit.percentage !== "number") return undefined;
+	const percent = Math.round(limit.percentage);
+	const remaining = Math.max(0, 100 - percent);
+	// Z.ai returns nextResetTime in epoch milliseconds; format helpers expect seconds.
+	const resetAtSec = limit.nextResetTime ? limit.nextResetTime / 1000 : undefined;
+	const resetLabel = formatReset(resetAtSec);
+	const remainingLabel = formatRemainingTime(resetAtSec);
+	return {
+		percent,
+		remaining,
+		remainingLabel,
+		resetLabel,
+		resetsAt: limit.nextResetTime,
+		label: remainingLabel ? `${remaining}% (${remainingLabel})` : `${remaining}%`,
+	};
+}
+
+async function fetchZaiUsage(signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
+	try {
+		const apiKey = await readZaiAuth();
+		const timeoutSignal = AbortSignal.timeout(7_000);
+		const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+
+		const response = await fetch(ZAI_USAGE_URL, {
+			headers: {
+				Accept: "application/json",
+				Authorization: `Bearer ${apiKey}`,
+				"User-Agent": "pi-sub/0.1.0",
+			},
+			signal: combinedSignal,
+		});
+
+		const body = await response.json();
+
+		// Z.ai returns HTTP 200 even on auth errors: {"code":401,"msg":"...","success":false}
+		const apiError = body as ZaiUsageApiError;
+		if (typeof apiError.success === "boolean" && !apiError.success && apiError.msg) {
+			throw new Error(`Z.ai API error: ${apiError.msg}`);
+		}
+
+		const parsed = body as ZaiUsageApiResponse;
+		const tokenLimits = (parsed.data?.limits ?? [])
+			.filter((l) => l.type === "TOKENS_LIMIT")
+			.sort((a, b) => (a.nextResetTime ?? 0) - (b.nextResetTime ?? 0));
+
+		if (tokenLimits.length === 0) {
+			throw new Error("No TOKENS_LIMIT entries in Z.ai usage response");
+		}
+
+		// The limit with the nearest reset is the 5-hour rolling window;
+		// the next one (if present) is the weekly window.
+		const fiveHour = zaiLimitToUsageWindow(tokenLimits[0]);
+		const weekly = tokenLimits.length >= 2 ? zaiLimitToUsageWindow(tokenLimits[1]) : undefined;
+
+		const account: SubscriptionAccountSnapshot = {
+			isActive: true,
+			accountLabel: "Z.ai subscription",
+			fiveHour,
+			weekly,
+			lastActivity: "Now",
+		};
+
+		return {
+			providerId: ZAI_PROVIDER,
+			providerDisplayName: "Z.ai",
+			accounts: [account],
+			activeAccount: account,
+			fetchedAt: Date.now(),
+		};
+	} catch (error) {
+		return {
+			providerId: ZAI_PROVIDER,
+			providerDisplayName: "Z.ai",
+			accounts: [],
+			fetchedAt: Date.now(),
+			error: redactedError(error, "Z.ai"),
+		};
+	}
+}
+
 const codexAdapter: SubscriptionProviderAdapter = {
 	id: CODEX_PROVIDER,
 	displayName: "Codex",
@@ -349,7 +447,14 @@ const openCodeGoAdapter: SubscriptionProviderAdapter = {
 	fetchUsage: fetchOpenCodeGoUsage,
 };
 
-const adapters = [codexAdapter, openCodeGoAdapter];
+const zaiAdapter: SubscriptionProviderAdapter = {
+	id: ZAI_PROVIDER,
+	displayName: "Z.ai",
+	isModelSupported: isZaiModel,
+	fetchUsage: fetchZaiUsage,
+};
+
+const adapters = [codexAdapter, openCodeGoAdapter, zaiAdapter];
 
 function supportedAdapter(model: ModelLike): SubscriptionProviderAdapter | undefined {
 	return adapters.find((adapter) => adapter.isModelSupported(model));
@@ -511,7 +616,11 @@ function buildDetails(snapshot: SubscriptionUsageSnapshot | undefined, state: St
 	if (!state.adapter) return `Subscription tracking inactive for current model provider (${state.model?.provider ?? "unknown"}).`;
 	if (!snapshot) return "Subscription usage has not been loaded yet.";
 	if (snapshot.error) return `${snapshot.providerDisplayName}: ${snapshot.error}`;
-	if (snapshot.accounts.length === 0) return `${snapshot.providerDisplayName}: no accounts found.`;
+	if (snapshot.accounts.length === 0) {
+		const costLine = snapshot.cost !== undefined && snapshot.cost > 0 ? `\nSession cost: $${snapshot.cost.toFixed(2)}` : "";
+		const modelInfo = state.model?.id ? ` · Model: ${state.model.id}` : "";
+		return `Provider: ${snapshot.providerDisplayName}${modelInfo} · Fetched: ${new Date(snapshot.fetchedAt).toLocaleTimeString()}\n${snapshot.providerDisplayName} does not expose usage windows.${costLine}`;
+	}
 
 	const columns: { key: string; label: string; get: (a: SubscriptionAccountSnapshot) => string }[] = [
 		{ key: "account", label: "ACCOUNT", get: (a) => a.accountLabel ?? "unknown" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-sub",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Pi extension showing subscription usage for supported model providers.",
   "type": "module",
   "license": "MIT",