@bacnh85/pi-sub 0.1.0 → 0.1.1

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 via `@loongphy/codex-auth` and displays a compact footer status 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 separate subscription line below the editor only while the active Pi model provider is `openai-codex`.
 
 ## Install
 
@@ -34,13 +34,13 @@ The footer status includes:
 - weekly usage percentage and reset time/date;
 - active Codex model id.
 
-Example compact footer text:
+Example subscription line:
 
 ```text
 Sub Plus user@example.com 5H 85%→18:12 W 80%→2 Jul 08:00 · gpt-5-codex
 ```
 
-When the current model provider is not supported, `pi-sub` clears its footer status and does not refresh subscription data.
+When the current model provider is not supported, `pi-sub` clears its subscription line and does not refresh subscription data.
 
 ## Commands
 
@@ -50,12 +50,11 @@ When the current model provider is not supported, `pi-sub` clears its footer sta
 | `/sub status` | Same as `/sub`. |
 | `/sub refresh` | Force a usage refresh, then show details. |
 
-When Codex account data is available, `/sub` shows a table similar to `codex-auth list`:
+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
-  mail@bacnh.com        Plus  75% (14:21)  20% (14:23 on 29 Jun)  Now
 ```
 
 ## Refresh behavior
@@ -68,23 +67,18 @@ ACCOUNT                 PLAN  5H USAGE     WEEKLY USAGE           LAST ACTIVITY
 - periodically while a supported provider remains active;
 - when `/sub refresh` is run.
 
-Refreshes are cached briefly to avoid excessive `codex-auth` calls.
+`pi-sub` reads the `openai-codex` OAuth entry from Pi's auth file and refreshes live usage directly against ChatGPT's usage endpoint. It does not execute the `codex-auth` CLI and does not assume a separate Codex CLI installation exists.
 
-## Requirements and troubleshooting
-
-- `@loongphy/codex-auth` is installed as a runtime dependency of this package.
-- Codex account data must already be configured for `codex-auth list` to return usage.
-- Node.js 22+ is required by `@loongphy/codex-auth`.
-- `pi-sub` redacts auth/token-related errors in the footer and never prints Codex tokens.
+Refreshes are cached briefly to avoid excessive usage endpoint calls.
 
-If usage is unavailable, run:
+## Requirements and troubleshooting
 
-```bash
-npx @loongphy/codex-auth list
-```
+- 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.
 
-outside Pi to verify the underlying Codex account state.
+If usage is unavailable, verify that Pi can use the `openai-codex` provider and that the auth file exists.
 
 ## 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.
+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.

package/index.ts

@@ -1,17 +1,41 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
-import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 
-const require = createRequire(import.meta.url);
 const STATUS_KEY = "pi-sub";
 const MESSAGE_TYPE = "pi-sub-status";
+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";
 
 type ModelLike = { provider?: string; id?: string } | undefined;
 
+type UsageApiWindow = {
+	used_percent?: number;
+	limit_window_seconds?: number;
+	reset_at?: number;
+};
+
+type UsageApiSnapshot = {
+	primary?: UsageApiWindow;
+	secondary?: UsageApiWindow;
+	plan_type?: string;
+};
+
+type PiAuthFile = Record<string, PiAuthEntry | undefined>;
+
+type PiAuthEntry = {
+	type?: string;
+	access?: string;
+	refresh?: string;
+	expires?: number;
+	accountId?: string;
+};
+
 interface UsageWindow {
 	used?: number;
 	limit?: number;
@@ -59,117 +83,175 @@ interface State {
 
 function isCodexModel(model: ModelLike): boolean {
 	const provider = model?.provider?.toLowerCase() ?? "";
-	return provider === "openai-codex" || provider.includes("openai-codex");
+	return provider === PI_SUB_PROVIDER || provider.includes(PI_SUB_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");
+}
+
+async function readJsonFile<T>(file: string): Promise<T> {
+	return JSON.parse(await fs.readFile(file, "utf8")) as T;
 }
 
-function parsePercent(value: string): number | undefined {
-	const match = value.match(/(\d+(?:\.\d+)?)\s*%/);
-	return match ? Number(match[1]) : undefined;
+function decodeJwtPayload(token: string | undefined): Record<string, any> | undefined {
+	if (!token) return undefined;
+	const parts = token.split(".");
+	if (parts.length < 2) return undefined;
+	try {
+		return JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8")) as Record<string, any>;
+	} catch {
+		return undefined;
+	}
 }
 
-function parseUsageWindow(value: string | undefined): UsageWindow | undefined {
-	if (!value) return undefined;
-	const trimmed = value.trim();
-	if (!trimmed || trimmed === "-" || trimmed === "—") return undefined;
-	const percent = parsePercent(trimmed);
-	const resetMatch = trimmed.match(/\(([^)]+)\)/);
+function accountFromPiAuth(entry: PiAuthEntry): SubscriptionAccountSnapshot {
+	const claims = decodeJwtPayload(entry.access);
+	const profile = claims?.["https://api.openai.com/profile"];
+	const auth = claims?.["https://api.openai.com/auth"];
+	const email = typeof profile?.email === "string" ? profile.email : undefined;
+	const plan = typeof auth?.chatgpt_plan_type === "string" ? planLabel(auth.chatgpt_plan_type) : undefined;
+	const accountId = typeof entry.accountId === "string" ? entry.accountId : typeof auth?.chatgpt_account_id === "string" ? auth.chatgpt_account_id : undefined;
 	return {
-		percent,
-		resetLabel: resetMatch?.[1]?.trim(),
-		label: trimmed,
+		id: accountId,
+		isActive: true,
+		accountLabel: email ?? accountId ?? "openai-codex account",
+		plan,
+		lastActivity: "Now",
 	};
 }
 
-function stripAnsi(value: string): string {
-	return value.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+function planLabel(plan: string | undefined): string | undefined {
+	if (!plan) return undefined;
+	const normalized = plan.toLowerCase().replace(/[_-]+/g, " ");
+	const labels: Record<string, string> = {
+		free: "Free",
+		plus: "Plus",
+		prolite: "Pro Lite",
+		"pro lite": "Pro Lite",
+		pro: "Pro",
+		team: "Business",
+		business: "Business",
+		enterprise: "Enterprise",
+		edu: "Edu",
+		unknown: "Unknown",
+	};
+	return labels[normalized] ?? plan;
 }
 
-function parseCodexAuthList(output: string): SubscriptionUsageSnapshot {
-	const accounts: SubscriptionAccountSnapshot[] = [];
-	const lines = stripAnsi(output).split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean);
-	const dataLines = lines.filter((line) => !/^ACCOUNT\s+PLAN\s+5H USAGE/i.test(line) && !/^-{5,}$/.test(line.trim()));
+function formatReset(timestampSeconds: number | undefined): string | undefined {
+	if (!timestampSeconds) return undefined;
+	const date = new Date(timestampSeconds * 1000);
+	const now = new Date();
+	const time = date.toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit", hour12: false });
+	if (date.toDateString() === now.toDateString()) return time;
+	return `${time} on ${date.toLocaleDateString(undefined, { day: "numeric", month: "short" })}`;
+}
 
-	for (const line of dataLines) {
-		const match = line.match(/^(\*)?\s*(?:(\d+)\s+)?(\S+@\S+)\s+(\S+)\s+(\d+(?:\.\d+)?%\s*\([^)]*\)|[-—?])\s+(\d+(?:\.\d+)?%\s*\([^)]*\)|[-—?])\s*(.*)$/);
-		if (!match) continue;
-		accounts.push({
-			isActive: Boolean(match[1]),
-			id: match[2],
-			accountLabel: match[3],
-			plan: match[4],
-			fiveHour: parseUsageWindow(match[5]),
-			weekly: parseUsageWindow(match[6]),
-			lastActivity: match[7]?.trim() || 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 resetLabel = formatReset(window.reset_at);
+	return {
+		percent,
+		resetLabel,
+		resetsAt: window.reset_at,
+		label: resetLabel ? `${percent}% (${resetLabel})` : `${percent}%`,
+	};
+}
+
+function mergeUsageIntoAccount(account: SubscriptionAccountSnapshot, usage: UsageApiSnapshot | undefined): SubscriptionAccountSnapshot {
+	if (!usage) return account;
+	return {
+		...account,
+		plan: planLabel(usage.plan_type) ?? account.plan,
+		fiveHour: usageWindowFromApi(usage.primary) ?? account.fiveHour,
+		weekly: usageWindowFromApi(usage.secondary) ?? account.weekly,
+	};
+}
 
+function parseUsageResponse(body: unknown): UsageApiSnapshot | undefined {
+	if (!body || typeof body !== "object") return undefined;
+	const root = body as any;
+	const rateLimit = root.rate_limit;
+	if (!rateLimit || typeof rateLimit !== "object") return undefined;
+	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 : undefined,
+		};
+	};
 	return {
-		providerId: "openai-codex",
-		providerDisplayName: "Codex",
-		accounts,
-		activeAccount: accounts.find((account) => account.isActive) ?? accounts[0],
-		fetchedAt: Date.now(),
+		primary: parseWindow(rateLimit.primary_window),
+		secondary: parseWindow(rateLimit.secondary_window),
+		plan_type: typeof root.plan_type === "string" ? root.plan_type : undefined,
 	};
 }
 
+async function readPiCodexAuth(): Promise<PiAuthEntry> {
+	const auth = await readJsonFile<PiAuthFile>(piAuthPath());
+	const entry = auth[PI_SUB_PROVIDER];
+	if (!entry?.access || !entry.accountId) throw new Error("Missing openai-codex OAuth entry in Pi auth");
+	return entry;
+}
+
+async function fetchUsageFromPiAuth(entry: PiAuthEntry, signal?: AbortSignal): Promise<UsageApiSnapshot | undefined> {
+	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": entry.accountId!,
+			"User-Agent": "pi-sub/0.1.0",
+		},
+		signal: combinedSignal,
+	});
+	if (!response.ok) throw new Error(`usage request failed with HTTP ${response.status}`);
+	return parseUsageResponse(await response.json());
+}
+
 function redactedError(error: unknown): string {
 	const message = error instanceof Error ? error.message : String(error || "Unknown error");
-	if (/missing platform package|cannot find module|ENOENT/i.test(message)) return "codex-auth is not installed correctly";
-	if (/timed out|timeout/i.test(message)) return "codex-auth timed out";
-	if (/not logged in|auth|token|unauthorized|forbidden/i.test(message)) return "Codex auth unavailable";
+	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";
 }
 
-function resolveCodexAuthBin(): string {
-	return require.resolve("@loongphy/codex-auth/bin/codex-auth.js");
-}
-
-function runCodexAuthList(signal?: AbortSignal): Promise<string> {
-	return new Promise((resolve, reject) => {
-		const child = spawn(process.execPath, [resolveCodexAuthBin(), "list"], {
-			stdio: ["ignore", "pipe", "pipe"],
-			env: { ...process.env, NO_COLOR: "1" },
-		});
-		let stdout = "";
-		let stderr = "";
-		const timeout = setTimeout(() => {
-			child.kill("SIGTERM");
-			reject(new Error("codex-auth list timed out"));
-		}, 20_000);
-		const onAbort = () => {
-			child.kill("SIGTERM");
-			reject(signal?.reason ?? new Error("Operation aborted"));
+async function fetchCodexUsage(signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
+	try {
+		const entry = await readPiCodexAuth();
+		let activeAccount = accountFromPiAuth(entry);
+		const usage = await fetchUsageFromPiAuth(entry, signal);
+		activeAccount = mergeUsageIntoAccount(activeAccount, usage);
+		return {
+			providerId: PI_SUB_PROVIDER,
+			providerDisplayName: "Codex",
+			accounts: [activeAccount],
+			activeAccount,
+			fetchedAt: Date.now(),
 		};
-		signal?.addEventListener("abort", onAbort, { once: true });
-		child.stdout?.on("data", (chunk) => { stdout += String(chunk); });
-		child.stderr?.on("data", (chunk) => { stderr += String(chunk); });
-		child.on("error", reject);
-		child.on("close", (code) => {
-			clearTimeout(timeout);
-			signal?.removeEventListener("abort", onAbort);
-			if (code === 0) resolve(stdout);
-			else reject(new Error(stderr.trim() || `codex-auth list exited with code ${code}`));
-		});
-	});
+	} catch (error) {
+		return {
+			providerId: PI_SUB_PROVIDER,
+			providerDisplayName: "Codex",
+			accounts: [],
+			fetchedAt: Date.now(),
+			error: redactedError(error),
+		};
+	}
 }
 
 const codexAdapter: SubscriptionProviderAdapter = {
-	id: "openai-codex",
+	id: PI_SUB_PROVIDER,
 	displayName: "Codex",
 	isModelSupported: isCodexModel,
-	async fetchUsage(signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
-		try {
-			return parseCodexAuthList(await runCodexAuthList(signal));
-		} catch (error) {
-			return {
-				providerId: "openai-codex",
-				providerDisplayName: "Codex",
-				accounts: [],
-				fetchedAt: Date.now(),
-				error: redactedError(error),
-			};
-		}
-	},
+	fetchUsage: fetchCodexUsage,
 };
 
 const adapters = [codexAdapter];
@@ -195,31 +277,33 @@ function maxPercent(account: SubscriptionAccountSnapshot | undefined): number {
 	return Math.max(account?.fiveHour?.percent ?? 0, account?.weekly?.percent ?? 0);
 }
 
-function renderStatus(ctx: ExtensionContext, state: State): void {
+function renderSubscriptionLine(ctx: ExtensionContext, state: State): void {
 	if (!state.adapter) {
-		ctx.ui.setStatus(STATUS_KEY, undefined);
+		ctx.ui.setWidget(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) {
-		ctx.ui.setStatus(STATUS_KEY, theme.fg("dim", `Sub ${state.adapter.displayName} loading · ${modelId}`));
-		return;
-	}
-	if (snapshot.error) {
-		ctx.ui.setStatus(STATUS_KEY, theme.fg("warning", `Sub ${snapshot.error} · ${modelId}`));
-		return;
+		line = `Sub ${state.adapter.displayName} loading · ${modelId}`;
+	} else if (snapshot.error) {
+		line = `Sub ${snapshot.error} · ${modelId}`;
+		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 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);
-	const color = maxPercent(account) >= 90 ? "error" : maxPercent(account) >= 80 ? "warning" : "dim";
-	ctx.ui.setStatus(STATUS_KEY, theme.fg(color, pieces.join(" ")));
+	ctx.ui.setWidget(STATUS_KEY, [theme.fg(color, line)], { placement: "belowEditor" });
 }
 
 function startTimer(ctx: ExtensionContext, state: State): void {
@@ -244,23 +328,23 @@ function updateActiveAdapter(ctx: ExtensionContext, state: State, model: ModelLi
 		state.lastRefreshAt = 0;
 		stopTimer(state);
 	}
-	renderStatus(ctx, state);
+	renderSubscriptionLine(ctx, state);
 	if (state.adapter) startTimer(ctx, state);
 }
 
 async function refreshUsage(ctx: ExtensionContext, state: State, force: boolean): Promise<SubscriptionUsageSnapshot | undefined> {
 	const adapter = state.adapter;
 	if (!adapter) {
-		renderStatus(ctx, state);
+		renderSubscriptionLine(ctx, state);
 		return undefined;
 	}
 	if (!force && state.snapshot && Date.now() - state.lastRefreshAt < REFRESH_TTL_MS) return state.snapshot;
 	if (state.inFlight) return state.inFlight;
-	renderStatus(ctx, state);
+	renderSubscriptionLine(ctx, state);
 	state.inFlight = adapter.fetchUsage(ctx.signal).then((snapshot) => {
 		state.snapshot = snapshot;
 		state.lastRefreshAt = Date.now();
-		renderStatus(ctx, state);
+		renderSubscriptionLine(ctx, state);
 		return snapshot;
 	}).finally(() => {
 		state.inFlight = undefined;
@@ -331,7 +415,7 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_shutdown", async (_event, ctx) => {
 		stopTimer(state);
-		ctx.ui.setStatus(STATUS_KEY, undefined);
+		ctx.ui.setWidget(STATUS_KEY, undefined);
 	});
 
 	pi.registerCommand("sub", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-sub",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Pi extension showing subscription usage for supported model providers.",
   "type": "module",
   "license": "MIT",
@@ -33,9 +33,6 @@
       "./index.ts"
     ]
   },
-  "dependencies": {
-    "@loongphy/codex-auth": "^0.2.10"
-  },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"