@bacnh85/pi-sub 0.1.8 → 0.1.10

package/README.md

@@ -15,13 +15,9 @@ pi install npm:@bacnh85/pi-sub
 From this repository checkout:
 
 ```bash
-cd extensions/pi-sub
-npm install
-cd ../..
-
-pi install ./extensions/pi-sub
+pi install ./pi-sub
 # or test directly
-pi -e ./extensions/pi-sub
+pi -e ./pi-sub
 ```
 
 ## What it shows
@@ -30,32 +26,31 @@ pi -e ./extensions/pi-sub
 
 The footer status appears after Pi's built-in status/token usage line and includes:
 
-- active account email;
-- subscription plan, such as `Plus`;
-- 5-hour usage percentage and reset time;
-- weekly usage percentage and reset time/date;
-- active Codex model id.
+- active account email/account label;
+- subscription plan, such as `Plus` in `/sub` details;
+- 5-hour remaining quota and reset countdown;
+- weekly remaining quota and reset countdown.
 
 Example subscription line:
 
 ```text
-Sub · Plus · user@example.com · 5H 85% (18:12) · W 80% (08:00 on 2 Jul) · gpt-5-codex
+(user@example.com) R:15%/2H W:20%/3D
 ```
 
 ### OpenCode Go
 
-OpenCode Go does not expose usage windows, so the footer shows only the accumulated session cost:
+OpenCode Go does not expose a public usage-window API, so the footer shows the active account/key label and accumulated session cost:
 
 ```text
-OpenCode Go $0.23
+OpenCode Go (OpenCode Go key#1a2b3c4d) $0.23
 ```
 
 ### Z.ai
 
-Z.ai (GLM Coding Plan) shows 5-hour rolling and weekly quota percentages with reset times:
+Z.ai (GLM Coding Plan) shows the active account/key label plus 5-hour rolling and weekly remaining quota with reset countdowns:
 
 ```text
-R:55%(18:12) W:80%(08:00 on 2 Jul)
+(Z.ai key#1a2b3c4d) R:55%/2H W:80%/3D
 ```
 
 When the current model provider is not supported, `pi-sub` clears its subscription line and does not refresh subscription data.
@@ -71,16 +66,21 @@ When the current model provider is not supported, `pi-sub` clears its subscripti
 When Pi OpenAI Codex auth is available, `/sub` shows the active account usage:
 
 ```text
-ACCOUNT                 PLAN  5H USAGE     WEEKLY USAGE           LAST ACTIVITY
-* user@example.com     Plus  85% (18:12)  80% (08:00 on 2 Jul)   Now
+ACCOUNT                 PLAN  ROLLING  WEEKLY  LAST ACTIVITY
+* user@example.com     Plus  15%/2H   20%/3D  Now
 ```
 
-For OpenCode Go, `/sub` shows the provider/model and session cost:
+For OpenCode Go, `/sub` shows the provider/model, active account/key label, 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
+
+  ACCOUNT                         PLAN  LAST ACTIVITY
+------------------------------------------------------
+* OpenCode Go key#1a2b3c4d        Go    Now
+
+OpenCode Go does not expose usage windows.
 ```
 
 For Z.ai, `/sub` shows the rolling and weekly quota windows:
@@ -90,7 +90,7 @@ 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
+* Z.ai key#1a2b3c4d  Pro   55%/2H        80%/3D            Now
 ```
 
 ## Refresh behavior
@@ -110,8 +110,9 @@ Refreshes are cached briefly to avoid excessive usage endpoint calls.
 ## Requirements and troubleshooting
 
 - **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.
+- **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. OpenCode Go/Zen usage windows and Zen balance are not shown because no public API is currently documented for those values.
 - **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`).
+- For API-key-only providers, account labels come from stored auth metadata (`email`, `label`, `name`, or `accountId`) when available; otherwise `pi-sub` displays a non-secret SHA-256 key fingerprint such as `Z.ai key#1a2b3c4d`.
 - `pi-sub` redacts auth/token-related errors and never prints credentials.
 
 ## Design notes

package/{index.ts → extensions/index.ts}

@@ -1,5 +1,6 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
+import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -19,7 +20,6 @@ type ModelLike = { provider?: string; id?: string } | undefined;
 
 type UsageApiWindow = {
 	used_percent?: number;
-	limit_window_seconds?: number;
 	reset_at?: number;
 };
 
@@ -38,17 +38,17 @@ type PiAuthEntry = {
 	expires?: number;
 	accountId?: string;
 	key?: string;
+	email?: string;
+	label?: string;
+	name?: string;
+	env?: Record<string, string>;
 };
 
 interface UsageWindow {
-	used?: number;
-	limit?: number;
 	percent?: number;
 	remaining?: number;
 	remainingLabel?: string;
 	resetLabel?: string;
-	resetsAt?: string | number | Date;
-	label?: string;
 }
 
 interface SubscriptionAccountSnapshot {
@@ -58,12 +58,10 @@ interface SubscriptionAccountSnapshot {
 	plan?: string;
 	fiveHour?: UsageWindow;
 	weekly?: UsageWindow;
-	monthly?: UsageWindow;
 	lastActivity?: string;
 }
 
 interface SubscriptionUsageSnapshot {
-	providerId: string;
 	providerDisplayName: string;
 	accounts: SubscriptionAccountSnapshot[];
 	activeAccount?: SubscriptionAccountSnapshot;
@@ -72,12 +70,11 @@ interface SubscriptionUsageSnapshot {
 	cost?: number;
 }
 
-interface SubscriptionProviderAdapter {
+type SubscriptionProviderAdapter = {
 	id: string;
 	displayName: string;
-	isModelSupported(model: ModelLike): boolean;
 	fetchUsage(signal?: AbortSignal): Promise<SubscriptionUsageSnapshot>;
-}
+};
 
 interface State {
 	model?: ModelLike;
@@ -140,6 +137,46 @@ function accountFromPiAuth(entry: PiAuthEntry): SubscriptionAccountSnapshot {
 	};
 }
 
+function firstString(...values: unknown[]): string | undefined {
+	for (const value of values) {
+		if (typeof value !== "string") continue;
+		const trimmed = value.trim();
+		if (trimmed.length > 0) return trimmed;
+	}
+	return undefined;
+}
+
+function authEntryLabel(entry: PiAuthEntry | undefined): string | undefined {
+	return firstString(entry?.email, entry?.label, entry?.name, entry?.accountId);
+}
+
+function keyFingerprint(key: string | undefined): string | undefined {
+	if (!key) return undefined;
+	return createHash("sha256").update(key).digest("hex").slice(0, 8);
+}
+
+function authAccountLabel(providerLabel: string, entry: PiAuthEntry | undefined): string {
+	const label = authEntryLabel(entry);
+	if (label) return label;
+	const fingerprint = keyFingerprint(entry?.key);
+	return fingerprint ? `${providerLabel} key#${fingerprint}` : `${providerLabel} account`;
+}
+
+function authAccountSnapshot(providerLabel: string, entry: PiAuthEntry | undefined, defaults: Partial<SubscriptionAccountSnapshot> = {}): SubscriptionAccountSnapshot {
+	return {
+		id: firstString(entry?.accountId),
+		isActive: true,
+		accountLabel: authAccountLabel(providerLabel, entry),
+		lastActivity: "Now",
+		...defaults,
+	};
+}
+
+function formatFooterAccount(account: SubscriptionAccountSnapshot | undefined): string | undefined {
+	const label = firstString(account?.accountLabel);
+	return label ? `(${label})` : undefined;
+}
+
 function getCodexAccountId(entry: PiAuthEntry | undefined): string | undefined {
 	if (!entry) return undefined;
 	if (typeof entry.accountId === "string" && entry.accountId.length > 0) return entry.accountId;
@@ -201,8 +238,6 @@ function usageWindowFromApi(window: UsageApiWindow | undefined): UsageWindow | u
 		remaining,
 		remainingLabel,
 		resetLabel,
-		resetsAt: window.reset_at,
-		label: remainingLabel ? `${remaining}% (${remainingLabel})` : `${remaining}%`,
 	};
 }
 
@@ -225,7 +260,6 @@ function parseUsageResponse(body: unknown): UsageApiSnapshot | 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 : undefined,
 		};
 	};
@@ -244,29 +278,30 @@ async function readPiCodexAuth(): Promise<PiAuthEntry & { accountId: string }> {
 	return { ...entry, accountId };
 }
 
-async function readOpenCodeGoAuth(): Promise<{ key?: string; accountId?: string }> {
+async function readOpenCodeGoAuth(): Promise<SubscriptionAccountSnapshot> {
 	const auth = await readJsonFile<PiAuthFile>(piAuthPath());
 	const entry = auth[OPC_PROVIDER];
 	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 };
+	return authAccountSnapshot("OpenCode Go", entry, { plan: "Go" });
 }
 
-async function readZaiAuth(): Promise<string> {
+async function readZaiAuth(): Promise<{ key: string; account: SubscriptionAccountSnapshot }> {
 	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;
+	return { key: entry.key, account: authAccountSnapshot("Z.ai", entry) };
 }
 
 async function fetchUsageFromPiAuth(entry: PiAuthEntry, signal?: AbortSignal): Promise<UsageApiSnapshot | undefined> {
+	const accountId = getCodexAccountId(entry) ?? entry.accountId;
+	if (!accountId) throw new Error("Missing openai-codex OAuth entry in Pi auth");
 	const timeoutSignal = AbortSignal.timeout(7_000);
 	const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 	const response = await fetch(USAGE_ENDPOINT, {
 		headers: {
 			Accept: "application/json",
 			Authorization: `Bearer ${entry.access}`,
-			"ChatGPT-Account-Id": getCodexAccountId(entry) ?? entry.accountId,
+			"ChatGPT-Account-Id": accountId,
 			"User-Agent": "pi-sub/0.1.0",
 		},
 		signal: combinedSignal,
@@ -293,7 +328,6 @@ async function fetchCodexUsage(signal?: AbortSignal): Promise<SubscriptionUsageS
 		const usage = await fetchUsageFromPiAuth(entry, signal);
 		activeAccount = mergeUsageIntoAccount(activeAccount, usage);
 		return {
-			providerId: CODEX_PROVIDER,
 			providerDisplayName: "Codex",
 			accounts: [activeAccount],
 			activeAccount,
@@ -301,7 +335,6 @@ async function fetchCodexUsage(signal?: AbortSignal): Promise<SubscriptionUsageS
 		};
 	} catch (error) {
 		return {
-			providerId: CODEX_PROVIDER,
 			providerDisplayName: "Codex",
 			accounts: [],
 			fetchedAt: Date.now(),
@@ -312,16 +345,15 @@ async function fetchCodexUsage(signal?: AbortSignal): Promise<SubscriptionUsageS
 
 async function fetchOpenCodeGoUsage(_signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
 	try {
-		await readOpenCodeGoAuth();
+		const account = await readOpenCodeGoAuth();
 		return {
-			providerId: OPC_PROVIDER,
 			providerDisplayName: "OpenCode Go",
-			accounts: [],
+			accounts: [account],
+			activeAccount: account,
 			fetchedAt: Date.now(),
 		};
 	} catch (error) {
 		return {
-			providerId: OPC_PROVIDER,
 			providerDisplayName: "OpenCode Go",
 			accounts: [],
 			fetchedAt: Date.now(),
@@ -343,6 +375,10 @@ interface ZaiLimitEntry {
 interface ZaiUsageApiResponse {
 	data?: {
 		limits?: ZaiLimitEntry[];
+		planName?: string;
+		plan?: string;
+		plan_type?: string;
+		packageName?: string;
 	};
 }
 
@@ -365,14 +401,17 @@ function zaiLimitToUsageWindow(limit: ZaiLimitEntry): UsageWindow | undefined {
 		remaining,
 		remainingLabel,
 		resetLabel,
-		resetsAt: limit.nextResetTime,
-		label: remainingLabel ? `${remaining}% (${remainingLabel})` : `${remaining}%`,
 	};
 }
 
+function zaiPlanLabel(response: ZaiUsageApiResponse): string | undefined {
+	const data = response.data;
+	return planLabel(firstString(data?.planName, data?.plan, data?.plan_type, data?.packageName));
+}
+
 async function fetchZaiUsage(signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
 	try {
-		const apiKey = await readZaiAuth();
+		const { key: apiKey, account: authAccount } = await readZaiAuth();
 		const timeoutSignal = AbortSignal.timeout(7_000);
 		const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 
@@ -408,15 +447,13 @@ async function fetchZaiUsage(signal?: AbortSignal): Promise<SubscriptionUsageSna
 		const weekly = tokenLimits.length >= 2 ? zaiLimitToUsageWindow(tokenLimits[1]) : undefined;
 
 		const account: SubscriptionAccountSnapshot = {
-			isActive: true,
-			accountLabel: "Z.ai subscription",
+			...authAccount,
+			plan: zaiPlanLabel(parsed) ?? authAccount.plan,
 			fiveHour,
 			weekly,
-			lastActivity: "Now",
 		};
 
 		return {
-			providerId: ZAI_PROVIDER,
 			providerDisplayName: "Z.ai",
 			accounts: [account],
 			activeAccount: account,
@@ -424,7 +461,6 @@ async function fetchZaiUsage(signal?: AbortSignal): Promise<SubscriptionUsageSna
 		};
 	} catch (error) {
 		return {
-			providerId: ZAI_PROVIDER,
 			providerDisplayName: "Z.ai",
 			accounts: [],
 			fetchedAt: Date.now(),
@@ -433,31 +469,11 @@ async function fetchZaiUsage(signal?: AbortSignal): Promise<SubscriptionUsageSna
 	}
 }
 
-const codexAdapter: SubscriptionProviderAdapter = {
-	id: CODEX_PROVIDER,
-	displayName: "Codex",
-	isModelSupported: isCodexModel,
-	fetchUsage: fetchCodexUsage,
-};
-
-const openCodeGoAdapter: SubscriptionProviderAdapter = {
-	id: OPC_PROVIDER,
-	displayName: "OpenCode Go",
-	isModelSupported: isOpenCodeGoModel,
-	fetchUsage: fetchOpenCodeGoUsage,
-};
-
-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));
+	if (isCodexModel(model)) return { id: CODEX_PROVIDER, displayName: "Codex", fetchUsage: fetchCodexUsage };
+	if (isOpenCodeGoModel(model)) return { id: OPC_PROVIDER, displayName: "OpenCode Go", fetchUsage: fetchOpenCodeGoUsage };
+	if (isZaiModel(model)) return { id: ZAI_PROVIDER, displayName: "Z.ai", fetchUsage: fetchZaiUsage };
+	return undefined;
 }
 
 function formatRemaining(window: UsageWindow | undefined): string {
@@ -468,20 +484,10 @@ function formatRemaining(window: UsageWindow | undefined): string {
 	return "?";
 }
 
-function formatWindow(window: UsageWindow | undefined, _compact = true): string {
-	if (!window) return "?";
-	if (window.percent !== undefined && window.resetLabel) return `${window.percent}% (${window.resetLabel})`;
-	if (window.label) return window.label;
-	if (window.percent !== undefined) return `${window.percent}%`;
-	if (window.used !== undefined && window.limit !== undefined) return `${window.used}/${window.limit}`;
-	return "?";
-}
-
 function minRemaining(account: SubscriptionAccountSnapshot | undefined): number {
 	const values: number[] = [];
 	if (account?.fiveHour?.remaining !== undefined) values.push(account.fiveHour.remaining);
 	if (account?.weekly?.remaining !== undefined) values.push(account.weekly.remaining);
-	if (account?.monthly?.remaining !== undefined) values.push(account.monthly.remaining);
 	if (values.length === 0) return 100;
 	return Math.min(...values);
 }
@@ -491,7 +497,6 @@ function windowSegments(account: SubscriptionAccountSnapshot | undefined): strin
 	const segments: string[] = [];
 	if (account.fiveHour) segments.push(`R:${formatRemaining(account.fiveHour)}`);
 	if (account.weekly) segments.push(`W:${formatRemaining(account.weekly)}`);
-	if (account.monthly) segments.push(`M:${formatRemaining(account.monthly)}`);
 	return segments;
 }
 
@@ -521,9 +526,11 @@ function renderSubscriptionLine(ctx: ExtensionContext, state: State): void {
 		color = "warning";
 	} else {
 		const account = snapshot.activeAccount;
-		const segments = windowSegments(account);
+		const windowParts = windowSegments(account);
+		const accountPart = formatFooterAccount(account);
+		const segments = accountPart ? [accountPart, ...windowParts] : [...windowParts];
 		const cost = snapshot.cost;
-		const hasWindows = segments.length > 0;
+		const hasWindows = windowParts.length > 0;
 		if (cost !== undefined && cost > 0) segments.push(`$${cost.toFixed(2)}`);
 		if (segments.length === 0) {
 			line = `Sub ${state.adapter.displayName}`;
@@ -629,12 +636,8 @@ function buildDetails(snapshot: SubscriptionUsageSnapshot | undefined, state: St
 
 	const hasFiveHour = snapshot.accounts.some((a) => a.fiveHour);
 	const hasWeekly = snapshot.accounts.some((a) => a.weekly);
-	const hasMonthly = snapshot.accounts.some((a) => a.monthly);
-
 	if (hasFiveHour) columns.push({ key: "five", label: "ROLLING", get: (a) => formatRemaining(a.fiveHour) });
 	if (hasWeekly) columns.push({ key: "weekly", label: "WEEKLY", get: (a) => formatRemaining(a.weekly) });
-	if (hasMonthly) columns.push({ key: "monthly", label: "MONTHLY", get: (a) => formatRemaining(a.monthly) });
-
 	const rows = snapshot.accounts.map((account) => ({
 		active: account.isActive ? "*" : " ",
 		snapshot: account,
@@ -654,7 +657,11 @@ function buildDetails(snapshot: SubscriptionUsageSnapshot | undefined, state: St
 	});
 
 	const costLine = snapshot.cost !== undefined ? `\nSession cost: $${snapshot.cost.toFixed(2)}` : "";
-	return [`Provider: ${snapshot.providerDisplayName} · Model: ${state.model?.id ?? "unknown-model"} · Fetched: ${new Date(snapshot.fetchedAt).toLocaleTimeString()}${costLine}`, "", header, sep, ...body].join("\n");
+	const lines = [`Provider: ${snapshot.providerDisplayName} · Model: ${state.model?.id ?? "unknown-model"} · Fetched: ${new Date(snapshot.fetchedAt).toLocaleTimeString()}${costLine}`, "", header, sep, ...body];
+	if (!hasFiveHour && !hasWeekly) {
+		lines.push("", `${snapshot.providerDisplayName} does not expose usage windows.`);
+	}
+	return lines.join("\n");
 }
 
 export default function (pi: ExtensionAPI) {

package/extensions/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@bacnh85/pi-sub",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Pi extension showing subscription usage for supported model providers.",
   "type": "module",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
-  "homepage": "https://github.com/bacnh85/skills#readme",
+  "homepage": "https://github.com/bacnh85/pi-extensions#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/bacnh85/skills.git",
-    "directory": "extensions/pi-sub"
+    "url": "git+https://github.com/bacnh85/pi-extensions.git",
+    "directory": "pi-sub"
   },
   "bugs": {
-    "url": "https://github.com/bacnh85/skills/issues"
+    "url": "https://github.com/bacnh85/pi-extensions/issues"
   },
   "keywords": [
     "pi-package",
@@ -26,14 +26,16 @@
   ],
   "files": [
     "README.md",
-    "index.ts"
+    "extensions/"
   ],
   "pi": {
     "extensions": [
-      "./index.ts"
+      "./extensions/index.ts"
     ]
   },
-  "engines": { "node": ">=20.3.0" },
+  "engines": {
+    "node": ">=20.3.0"
+  },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"