@bacnh85/pi-sub 0.1.2 → 0.1.4

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 separate subscription line below the editor only while the active Pi model provider is `openai-codex`.
+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`.
 
 ## Install
 
@@ -26,7 +26,7 @@ pi -e ./extensions/pi-sub
 
 ## What it shows
 
-The footer status includes:
+The footer status appears after Pi's built-in status/token usage line and includes:
 
 - active account email;
 - subscription plan, such as `Plus`;
@@ -54,7 +54,7 @@ When Pi OpenAI Codex auth is available, `/sub` shows the active account usage:
 
 ```text
 ACCOUNT                 PLAN  5H USAGE     WEEKLY USAGE           LAST ACTIVITY
-* hangdanchi@gmail.com  Plus  85% (18:12)  80% (08:00 on 2 Jul)   Now
+* user@example.com     Plus  85% (18:12)  80% (08:00 on 2 Jul)   Now
 ```
 
 ## Refresh behavior

package/index.ts

@@ -10,7 +10,8 @@ const USAGE_ENDPOINT = "https://chatgpt.com/backend-api/wham/usage";
 const REFRESH_INTERVAL_MS = 60_000;
 const REFRESH_TTL_MS = 30_000;
 const REFRESH_DEBOUNCE_MS = 2_000;
-const PI_SUB_PROVIDER = "openai-codex";
+const CODEX_PROVIDER = "openai-codex";
+const OPC_PROVIDER = "opencode-go";
 
 type ModelLike = { provider?: string; id?: string } | undefined;
 
@@ -34,12 +35,15 @@ type PiAuthEntry = {
 	refresh?: string;
 	expires?: number;
 	accountId?: string;
+	key?: string;
 };
 
 interface UsageWindow {
 	used?: number;
 	limit?: number;
 	percent?: number;
+	remaining?: number;
+	remainingLabel?: string;
 	resetLabel?: string;
 	resetsAt?: string | number | Date;
 	label?: string;
@@ -52,6 +56,7 @@ interface SubscriptionAccountSnapshot {
 	plan?: string;
 	fiveHour?: UsageWindow;
 	weekly?: UsageWindow;
+	monthly?: UsageWindow;
 	lastActivity?: string;
 }
 
@@ -62,6 +67,7 @@ interface SubscriptionUsageSnapshot {
 	activeAccount?: SubscriptionAccountSnapshot;
 	fetchedAt: number;
 	error?: string;
+	cost?: number;
 }
 
 interface SubscriptionProviderAdapter {
@@ -83,7 +89,11 @@ interface State {
 
 function isCodexModel(model: ModelLike): boolean {
 	const provider = model?.provider?.toLowerCase() ?? "";
-	return provider === PI_SUB_PROVIDER || provider.includes(PI_SUB_PROVIDER);
+	return provider === CODEX_PROVIDER || provider.includes(CODEX_PROVIDER);
+}
+
+function isOpenCodeGoModel(model: ModelLike): boolean {
+	return (model?.provider?.toLowerCase() ?? "") === OPC_PROVIDER;
 }
 
 function piAuthPath(): string {
@@ -140,6 +150,19 @@ function planLabel(plan: string | undefined): string | undefined {
 	return labels[normalized] ?? plan;
 }
 
+function formatRemainingTime(resetAtSec: number | undefined): string | undefined {
+	if (!resetAtSec) return undefined;
+	const nowSec = Date.now() / 1000;
+	const remainingSec = resetAtSec - nowSec;
+	if (remainingSec <= 0) return "0M";
+	const remainingMin = Math.ceil(remainingSec / 60);
+	if (remainingMin < 60) return `${remainingMin}M`;
+	const remainingH = Math.ceil(remainingMin / 60);
+	if (remainingH < 24) return `${remainingH}H`;
+	const remainingD = Math.ceil(remainingH / 24);
+	return `${remainingD}D`;
+}
+
 function formatReset(timestampSeconds: number | undefined): string | undefined {
 	if (!timestampSeconds) return undefined;
 	const date = new Date(timestampSeconds * 1000);
@@ -154,12 +177,16 @@ function formatReset(timestampSeconds: number | undefined): string | undefined {
 function usageWindowFromApi(window: UsageApiWindow | undefined): UsageWindow | undefined {
 	if (!window || typeof window.used_percent !== "number") return undefined;
 	const percent = Math.round(window.used_percent);
+	const remaining = Math.max(0, 100 - percent);
 	const resetLabel = formatReset(window.reset_at);
+	const remainingLabel = formatRemainingTime(window.reset_at);
 	return {
 		percent,
+		remaining,
+		remainingLabel,
 		resetLabel,
 		resetsAt: window.reset_at,
-		label: resetLabel ? `${percent}% (${resetLabel})` : `${percent}%`,
+		label: remainingLabel ? `${remaining}% (${remainingLabel})` : `${remaining}%`,
 	};
 }
 
@@ -193,13 +220,39 @@ 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> {
 	const auth = await readJsonFile<PiAuthFile>(piAuthPath());
-	const entry = auth[PI_SUB_PROVIDER];
+	const entry = auth[CODEX_PROVIDER];
 	if (!entry?.access || !entry.accountId) throw new Error("Missing openai-codex OAuth entry in Pi auth");
 	return entry;
 }
 
+async function readOpenCodeGoAuth(): Promise<{ key: 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 };
+}
+
 async function fetchUsageFromPiAuth(entry: PiAuthEntry, signal?: AbortSignal): Promise<UsageApiSnapshot | undefined> {
 	const timeoutSignal = AbortSignal.timeout(7_000);
 	const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
@@ -216,13 +269,14 @@ async function fetchUsageFromPiAuth(entry: PiAuthEntry, signal?: AbortSignal): P
 	return parseUsageResponse(await response.json());
 }
 
-function redactedError(error: unknown): string {
+function redactedError(error: unknown, provider = "Codex"): string {
 	const message = error instanceof Error ? error.message : String(error || "Unknown error");
 	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 (/timed out|timeout|aborted/i.test(message)) return "Codex usage refresh timed out";
-	if (/401|403|auth|token|unauthorized|forbidden/i.test(message)) return "Codex auth unavailable";
-	return "Codex usage unavailable";
+	if (/missing opencode-go/i.test(message)) return "opencode-go 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`;
 }
 
 async function fetchCodexUsage(signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
@@ -232,7 +286,7 @@ async function fetchCodexUsage(signal?: AbortSignal): Promise<SubscriptionUsageS
 		const usage = await fetchUsageFromPiAuth(entry, signal);
 		activeAccount = mergeUsageIntoAccount(activeAccount, usage);
 		return {
-			providerId: PI_SUB_PROVIDER,
+			providerId: CODEX_PROVIDER,
 			providerDisplayName: "Codex",
 			accounts: [activeAccount],
 			activeAccount,
@@ -240,7 +294,7 @@ async function fetchCodexUsage(signal?: AbortSignal): Promise<SubscriptionUsageS
 		};
 	} catch (error) {
 		return {
-			providerId: PI_SUB_PROVIDER,
+			providerId: CODEX_PROVIDER,
 			providerDisplayName: "Codex",
 			accounts: [],
 			fetchedAt: Date.now(),
@@ -249,19 +303,75 @@ async function fetchCodexUsage(signal?: AbortSignal): Promise<SubscriptionUsageS
 	}
 }
 
+async function fetchOpenCodeGoUsage(signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
+	try {
+		const auth = await readOpenCodeGoAuth();
+		const timeoutSignal = AbortSignal.timeout(7_000);
+		const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+		const response = await fetch("https://opencode.ai/zen/go/v1/usage", {
+			headers: {
+				Accept: "application/json",
+				Authorization: `Bearer ${auth.key}`,
+				"User-Agent": "pi-sub/0.1.4",
+			},
+			signal: combinedSignal,
+		});
+		if (!response.ok) throw new Error(`usage request failed with HTTP ${response.status}`);
+		const usage = parseOpcodeUsageResponse(await response.json());
+		const account: SubscriptionAccountSnapshot = {
+			isActive: true,
+			accountLabel: "OpenCode Go",
+			plan: planLabel(usage?.plan_type),
+			fiveHour: usageWindowFromApi(usage?.primary),
+			weekly: usageWindowFromApi(usage?.secondary),
+			lastActivity: "Now",
+		};
+		return {
+			providerId: OPC_PROVIDER,
+			providerDisplayName: "OpenCode Go",
+			accounts: [account],
+			activeAccount: account,
+			fetchedAt: Date.now(),
+		};
+	} catch (error) {
+		return {
+			providerId: OPC_PROVIDER,
+			providerDisplayName: "OpenCode Go",
+			accounts: [],
+			fetchedAt: Date.now(),
+			error: redactedError(error, "OpenCode Go"),
+		};
+	}
+}
+
 const codexAdapter: SubscriptionProviderAdapter = {
-	id: PI_SUB_PROVIDER,
+	id: CODEX_PROVIDER,
 	displayName: "Codex",
 	isModelSupported: isCodexModel,
 	fetchUsage: fetchCodexUsage,
 };
 
-const adapters = [codexAdapter];
+const openCodeGoAdapter: SubscriptionProviderAdapter = {
+	id: OPC_PROVIDER,
+	displayName: "OpenCode Go",
+	isModelSupported: isOpenCodeGoModel,
+	fetchUsage: fetchOpenCodeGoUsage,
+};
+
+const adapters = [codexAdapter, openCodeGoAdapter];
 
 function supportedAdapter(model: ModelLike): SubscriptionProviderAdapter | undefined {
 	return adapters.find((adapter) => adapter.isModelSupported(model));
 }
 
+function formatRemaining(window: UsageWindow | undefined): string {
+	if (!window) return "?";
+	if (window.remaining !== undefined && window.remainingLabel) return `${window.remaining}%/${window.remainingLabel}`;
+	if (window.remaining !== undefined) return `${window.remaining}%`;
+	if (window.percent !== undefined && window.remainingLabel) return `${Math.max(0, 100 - window.percent)}%/${window.remainingLabel}`;
+	return "?";
+}
+
 function formatWindow(window: UsageWindow | undefined, _compact = true): string {
 	if (!window) return "?";
 	if (window.percent !== undefined && window.resetLabel) return `${window.percent}% (${window.resetLabel})`;
@@ -271,37 +381,62 @@ function formatWindow(window: UsageWindow | undefined, _compact = true): string
 	return "?";
 }
 
-function maxPercent(account: SubscriptionAccountSnapshot | undefined): number {
-	return Math.max(account?.fiveHour?.percent ?? 0, account?.weekly?.percent ?? 0);
+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);
+}
+
+function windowSegments(account: SubscriptionAccountSnapshot | undefined): string[] {
+	if (!account) return [];
+	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;
+}
+
+function aggregateSessionCost(ctx: ExtensionContext): number {
+	let total = 0;
+	for (const entry of ctx.sessionManager.getBranch()) {
+		if (entry.type === "message" && entry.message.role === "assistant") {
+			total += (entry.message.usage as any)?.cost?.total ?? 0;
+		}
+	}
+	return total;
 }
 
 function renderSubscriptionLine(ctx: ExtensionContext, state: State): void {
 	if (!state.adapter) {
-		ctx.ui.setWidget(STATUS_KEY, undefined);
+		ctx.ui.setStatus(STATUS_KEY, undefined);
 		return;
 	}
 	const theme = ctx.ui.theme;
 	const snapshot = state.snapshot;
-	const modelId = state.model?.id ?? "unknown-model";
 	let line: string;
 	let color: "dim" | "warning" | "error" = "dim";
 	if (!snapshot) {
-		line = `Sub ${state.adapter.displayName} loading · ${modelId}`;
+		line = `Sub ${state.adapter.displayName} loading`;
 	} else if (snapshot.error) {
-		line = `Sub ${snapshot.error} · ${modelId}`;
+		line = `Sub ${snapshot.error}`;
 		color = "warning";
 	} else {
 		const account = snapshot.activeAccount;
-		const pieces = ["Sub"];
-		if (account?.plan) pieces.push(account.plan);
-		pieces.push(account?.accountLabel ?? "unknown account");
-		pieces.push(`5H ${formatWindow(account?.fiveHour)}`);
-		pieces.push(`W ${formatWindow(account?.weekly)}`);
-		pieces.push(modelId);
-		line = pieces.join(" · ");
-		color = maxPercent(account) >= 90 ? "error" : maxPercent(account) >= 80 ? "warning" : "dim";
+		const segments = windowSegments(account);
+		const cost = snapshot.cost;
+		if (cost !== undefined && cost > 0) segments.push(`$${cost.toFixed(2)}`);
+		if (segments.length === 0) {
+			line = `Sub ${state.adapter.displayName}`;
+		} else {
+			line = segments.join(" ");
+		}
+		const remaining = minRemaining(account);
+		color = remaining <= 10 ? "error" : remaining <= 20 ? "warning" : "dim";
 	}
-	ctx.ui.setWidget(STATUS_KEY, [theme.fg(color, line)], { placement: "belowEditor" });
+	ctx.ui.setStatus(STATUS_KEY, theme.fg(color, line));
 }
 
 function startTimer(ctx: ExtensionContext, state: State): void {
@@ -340,6 +475,7 @@ async function refreshUsage(ctx: ExtensionContext, state: State, force: boolean)
 	if (state.inFlight) return state.inFlight;
 	renderSubscriptionLine(ctx, state);
 	state.inFlight = adapter.fetchUsage(ctx.signal).then((snapshot) => {
+		snapshot.cost = aggregateSessionCost(ctx);
 		state.snapshot = snapshot;
 		state.lastRefreshAt = Date.now();
 		renderSubscriptionLine(ctx, state);
@@ -368,24 +504,40 @@ function buildDetails(snapshot: SubscriptionUsageSnapshot | undefined, state: St
 	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.`;
+
+	const columns: { key: string; label: string; get: (a: SubscriptionAccountSnapshot) => string }[] = [
+		{ key: "account", label: "ACCOUNT", get: (a) => a.accountLabel ?? "unknown" },
+		{ key: "plan", label: "PLAN", get: (a) => a.plan ?? "?" },
+	];
+
+	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 ? "*" : " ",
-		account: account.accountLabel ?? "unknown",
-		plan: account.plan ?? "?",
-		five: formatWindow(account.fiveHour, false),
-		weekly: formatWindow(account.weekly, false),
-		activity: account.lastActivity ?? "",
+		snapshot: account,
 	}));
-	const widths = {
-		account: Math.max("ACCOUNT".length, ...rows.map((row) => row.account.length)),
-		plan: Math.max("PLAN".length, ...rows.map((row) => row.plan.length)),
-		five: Math.max("5H USAGE".length, ...rows.map((row) => row.five.length)),
-		weekly: Math.max("WEEKLY USAGE".length, ...rows.map((row) => row.weekly.length)),
-	};
-	const header = `  ${pad("ACCOUNT", widths.account)}  ${pad("PLAN", widths.plan)}  ${pad("5H USAGE", widths.five)}  ${pad("WEEKLY USAGE", widths.weekly)}  LAST ACTIVITY`;
+
+	const widths: Record<string, number> = {};
+	for (const col of columns) {
+		widths[col.key] = Math.max(col.label.length, ...snapshot.accounts.map((a) => col.get(a).length));
+	}
+
+	const headerCols = columns.map((c) => pad(c.label, widths[c.key]));
+	const header = `  ${headerCols.join("  ")}  LAST ACTIVITY`;
 	const sep = "-".repeat(header.length);
-	const body = rows.map((row) => `${row.active} ${pad(row.account, widths.account)}  ${pad(row.plan, widths.plan)}  ${pad(row.five, widths.five)}  ${pad(row.weekly, widths.weekly)}  ${row.activity}`);
-	return [`Provider: ${snapshot.providerDisplayName} · Model: ${state.model?.id ?? "unknown-model"} · Fetched: ${new Date(snapshot.fetchedAt).toLocaleTimeString()}`, "", header, sep, ...body].join("\n");
+	const body = rows.map((row) => {
+		const cols = columns.map((c) => pad(c.get(row.snapshot), widths[c.key]));
+		return `${row.active} ${cols.join("  ")}  ${row.snapshot.lastActivity ?? ""}`;
+	});
+
+	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");
 }
 
 export default function (pi: ExtensionAPI) {
@@ -413,7 +565,7 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_shutdown", async (_event, ctx) => {
 		stopTimer(state);
-		ctx.ui.setWidget(STATUS_KEY, undefined);
+		ctx.ui.setStatus(STATUS_KEY, undefined);
 	});
 
 	pi.registerCommand("sub", {

package/package.json

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