@bacnh85/pi-sub 0.1.0

package/README.md

@@ -0,0 +1,90 @@
+# pi-sub
+
+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`.
+
+## Install
+
+From npm after the package is published:
+
+```bash
+pi install npm:@bacnh85/pi-sub
+```
+
+From this repository checkout:
+
+```bash
+cd extensions/pi-sub
+npm install
+cd ../..
+
+pi install ./extensions/pi-sub
+# or test directly
+pi -e ./extensions/pi-sub
+```
+
+## What it shows
+
+The footer status 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.
+
+Example compact footer text:
+
+```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.
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `/sub` | Show detailed subscription usage for the current supported provider. |
+| `/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`:
+
+```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
+
+`pi-sub` refreshes usage data:
+
+- when a session starts on a supported provider;
+- when switching into a supported provider;
+- after provider responses, debounced;
+- periodically while a supported provider remains active;
+- when `/sub refresh` is run.
+
+Refreshes are cached briefly to avoid excessive `codex-auth` calls.
+
+## 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.
+
+If usage is unavailable, run:
+
+```bash
+npx @loongphy/codex-auth list
+```
+
+outside Pi to verify the underlying Codex account state.
+
+## 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.

package/index.ts

@@ -0,0 +1,349 @@
+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";
+
+const require = createRequire(import.meta.url);
+const STATUS_KEY = "pi-sub";
+const MESSAGE_TYPE = "pi-sub-status";
+const REFRESH_INTERVAL_MS = 60_000;
+const REFRESH_TTL_MS = 30_000;
+const REFRESH_DEBOUNCE_MS = 2_000;
+
+type ModelLike = { provider?: string; id?: string } | undefined;
+
+interface UsageWindow {
+	used?: number;
+	limit?: number;
+	percent?: number;
+	resetLabel?: string;
+	resetsAt?: string | number | Date;
+	label?: string;
+}
+
+interface SubscriptionAccountSnapshot {
+	id?: string;
+	isActive?: boolean;
+	accountLabel?: string;
+	plan?: string;
+	fiveHour?: UsageWindow;
+	weekly?: UsageWindow;
+	lastActivity?: string;
+}
+
+interface SubscriptionUsageSnapshot {
+	providerId: string;
+	providerDisplayName: string;
+	accounts: SubscriptionAccountSnapshot[];
+	activeAccount?: SubscriptionAccountSnapshot;
+	fetchedAt: number;
+	error?: string;
+}
+
+interface SubscriptionProviderAdapter {
+	id: string;
+	displayName: string;
+	isModelSupported(model: ModelLike): boolean;
+	fetchUsage(signal?: AbortSignal): Promise<SubscriptionUsageSnapshot>;
+}
+
+interface State {
+	model?: ModelLike;
+	adapter?: SubscriptionProviderAdapter;
+	snapshot?: SubscriptionUsageSnapshot;
+	lastRefreshAt: number;
+	inFlight?: Promise<SubscriptionUsageSnapshot>;
+	refreshTimer?: NodeJS.Timeout;
+	debounceTimer?: NodeJS.Timeout;
+}
+
+function isCodexModel(model: ModelLike): boolean {
+	const provider = model?.provider?.toLowerCase() ?? "";
+	return provider === "openai-codex" || provider.includes("openai-codex");
+}
+
+function parsePercent(value: string): number | undefined {
+	const match = value.match(/(\d+(?:\.\d+)?)\s*%/);
+	return match ? Number(match[1]) : 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(/\(([^)]+)\)/);
+	return {
+		percent,
+		resetLabel: resetMatch?.[1]?.trim(),
+		label: trimmed,
+	};
+}
+
+function stripAnsi(value: string): string {
+	return value.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+
+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()));
+
+	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,
+		});
+	}
+
+	return {
+		providerId: "openai-codex",
+		providerDisplayName: "Codex",
+		accounts,
+		activeAccount: accounts.find((account) => account.isActive) ?? accounts[0],
+		fetchedAt: Date.now(),
+	};
+}
+
+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";
+	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"));
+		};
+		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}`));
+		});
+	});
+}
+
+const codexAdapter: SubscriptionProviderAdapter = {
+	id: "openai-codex",
+	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),
+			};
+		}
+	},
+};
+
+const adapters = [codexAdapter];
+
+function supportedAdapter(model: ModelLike): SubscriptionProviderAdapter | undefined {
+	return adapters.find((adapter) => adapter.isModelSupported(model));
+}
+
+function formatWindow(window: UsageWindow | undefined, compact = true): string {
+	if (!window) return "?";
+	if (window.percent !== undefined && window.resetLabel) return compact ? `${window.percent}%→${compactResetLabel(window.resetLabel)}` : `${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 compactResetLabel(label: string): string {
+	return label.replace(/^0?(\d+:\d+) on (\d+ \w+)$/i, "$2 $1");
+}
+
+function maxPercent(account: SubscriptionAccountSnapshot | undefined): number {
+	return Math.max(account?.fiveHour?.percent ?? 0, account?.weekly?.percent ?? 0);
+}
+
+function renderStatus(ctx: ExtensionContext, state: State): void {
+	if (!state.adapter) {
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+		return;
+	}
+	const theme = ctx.ui.theme;
+	const snapshot = state.snapshot;
+	const modelId = state.model?.id ?? "unknown-model";
+	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;
+	}
+	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(" ")));
+}
+
+function startTimer(ctx: ExtensionContext, state: State): void {
+	if (state.refreshTimer || !state.adapter) return;
+	state.refreshTimer = setInterval(() => {
+		void refreshUsage(ctx, state, false);
+	}, REFRESH_INTERVAL_MS);
+}
+
+function stopTimer(state: State): void {
+	if (state.refreshTimer) clearInterval(state.refreshTimer);
+	if (state.debounceTimer) clearTimeout(state.debounceTimer);
+	state.refreshTimer = undefined;
+	state.debounceTimer = undefined;
+}
+
+function updateActiveAdapter(ctx: ExtensionContext, state: State, model: ModelLike): void {
+	state.model = model;
+	state.adapter = supportedAdapter(model);
+	if (!state.adapter) {
+		state.snapshot = undefined;
+		state.lastRefreshAt = 0;
+		stopTimer(state);
+	}
+	renderStatus(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);
+		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);
+	state.inFlight = adapter.fetchUsage(ctx.signal).then((snapshot) => {
+		state.snapshot = snapshot;
+		state.lastRefreshAt = Date.now();
+		renderStatus(ctx, state);
+		return snapshot;
+	}).finally(() => {
+		state.inFlight = undefined;
+	});
+	return state.inFlight;
+}
+
+function scheduleRefresh(ctx: ExtensionContext, state: State): void {
+	if (!state.adapter) return;
+	if (state.debounceTimer) clearTimeout(state.debounceTimer);
+	state.debounceTimer = setTimeout(() => {
+		state.debounceTimer = undefined;
+		void refreshUsage(ctx, state, true);
+	}, REFRESH_DEBOUNCE_MS);
+}
+
+function pad(value: string, width: number): string {
+	return value.length >= width ? value : value + " ".repeat(width - value.length);
+}
+
+function buildDetails(snapshot: SubscriptionUsageSnapshot | undefined, state: State): string {
+	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.`;
+	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 ?? "",
+	}));
+	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 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");
+}
+
+export default function (pi: ExtensionAPI) {
+	const state: State = { lastRefreshAt: 0 };
+
+	pi.registerMessageRenderer(MESSAGE_TYPE, (message, _options, theme) => {
+		const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+		box.addChild(new Text(String(message.content ?? ""), 0, 0));
+		return box;
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		updateActiveAdapter(ctx, state, ctx.model);
+		if (state.adapter) void refreshUsage(ctx, state, true);
+	});
+
+	pi.on("model_select", async (event, ctx) => {
+		updateActiveAdapter(ctx, state, event.model);
+		if (state.adapter) void refreshUsage(ctx, state, true);
+	});
+
+	pi.on("after_provider_response", async (_event, ctx) => {
+		if (state.adapter) scheduleRefresh(ctx, state);
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		stopTimer(state);
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+	});
+
+	pi.registerCommand("sub", {
+		description: "Show subscription usage for the current supported model provider (use /sub refresh to force refresh).",
+		handler: async (args, ctx) => {
+			updateActiveAdapter(ctx, state, ctx.model);
+			const command = args.trim().toLowerCase();
+			const force = command === "refresh";
+			const snapshot = state.adapter ? await refreshUsage(ctx, state, force || !state.snapshot) : undefined;
+			const details = buildDetails(snapshot ?? state.snapshot, state);
+			pi.sendMessage({ customType: MESSAGE_TYPE, content: details, display: true });
+			if (force) ctx.ui.notify("Subscription usage refreshed", "info");
+		},
+	});
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@bacnh85/pi-sub",
+  "version": "0.1.0",
+  "description": "Pi extension showing subscription usage for supported model providers.",
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://github.com/bacnh85/skills#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bacnh85/skills.git",
+    "directory": "extensions/pi-sub"
+  },
+  "bugs": {
+    "url": "https://github.com/bacnh85/skills/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "subscription",
+    "usage",
+    "codex",
+    "openai"
+  ],
+  "files": [
+    "README.md",
+    "index.ts"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "dependencies": {
+    "@loongphy/codex-auth": "^0.2.10"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  }
+}