pi-chatgpt-pool 0.1.0 → 0.2.0

package/README.md

@@ -32,14 +32,33 @@ The pool offers the ChatGPT subscription models: the OpenAI models that pi also
 
 | Command | What it does |
 | --- | --- |
-| `/chatgpt-pool` | Open the pool: each account's usage, reset times, and banked resets. Pick an account to spend a reset, clear its limit, or remove it |
+| `/chatgpt-pool` | Open the pool panel (see below) |
 | `/chatgpt-pool add <label>` | Add an account slot. Sign in to it with `/login` |
 | `/chatgpt-pool remove <label>` | Remove an account. Run `/logout` for it first to delete its token |
 | `/chatgpt-pool spend <label>` | Spend one banked reset on that account, after you confirm |
 | `/chatgpt-pool strategy <name>` | Set the routing strategy: `fill-first`, `round-robin`, `least-used`, or `use-it-or-lose-it` |
 | `/chatgpt-pool reset` | Forget recorded limits, for example after a limit clears early |
 
-The command autocompletes its actions and account labels. The footer shows `chatgpt: <account>` while a pooled model is selected, plus how many accounts are limited and when the next one comes back.
+The command autocompletes its actions and account labels.
+
+## Pool panel
+
+`/chatgpt-pool` opens a panel with every account, its state (ready, limited with a countdown, or not signed in), a usage bar per window with the time until it resets, and its banked resets.
+
+| Key | Action |
+| --- | --- |
+| `↑` `↓` or `j` `k` | Select an account |
+| `s` | Spend a banked reset on the selected account, after you confirm |
+| `c` | Clear the selected account's recorded limit |
+| `d` | Remove the selected account |
+| `a` | Add an account |
+| `t` | Choose the strategy |
+| `r` | Refresh usage |
+| `esc` or `q` | Close |
+
+Over RPC the same actions are offered as a list instead.
+
+While a pooled model is selected, the footer shows the account in use with its usage and reset time, for example `chatgpt: work 42% · resets in 3d 4h`, plus how many accounts are limited. When a conversation moves to another account, pi shows a notice such as `ChatGPT pool: personal is limited (back in 1h 30m), switched to work.`
 
 `/chatgpt-pool` and `spend` need the interactive UI; in `--print` or `--mode json` they stop with an error instead of spending anything. From a shell, use pi's own commands:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-chatgpt-pool",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Pool several Sign in with ChatGPT accounts in pi, with routing strategies, failover, and banked resets",
   "keywords": [
     "pi-package",
@@ -37,11 +37,13 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.99.1",
     "@earendil-works/pi-coding-agent": "^0.99.1",
+    "@earendil-works/pi-tui": "^0.99.1",
     "@types/node": "^24.0.0",
     "typescript": "^5.9.0"
   },

package/src/format.ts

@@ -0,0 +1,30 @@
+export function formatWindow(seconds: number): string {
+	if (seconds % 604800 === 0) return seconds === 604800 ? "weekly" : `${seconds / 604800}-week`;
+	if (seconds % 86400 === 0) return seconds === 86400 ? "daily" : `${seconds / 86400}-day`;
+	if (seconds % 3600 === 0) return `${seconds / 3600}h`;
+	return `${Math.round(seconds / 60)}m`;
+}
+
+export function formatReset(at: number): string {
+	const date = new Date(at);
+	const time = date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+	return date.toDateString() === new Date().toDateString()
+		? `at ${time}`
+		: `${date.toLocaleDateString([], { weekday: "short", month: "short", day: "numeric" })} at ${time}`;
+}
+
+export function formatIn(ms: number): string {
+	const minutes = Math.max(1, Math.ceil(ms / 60_000));
+	const days = Math.floor(minutes / 1440);
+	const hours = Math.floor((minutes % 1440) / 60);
+	const rest = minutes % 60;
+	if (days > 0) return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+	if (hours > 0) return rest > 0 ? `${hours}h ${rest}m` : `${hours}h`;
+	return `${rest}m`;
+}
+
+export function usageBar(percent: number, width: number) {
+	const clamped = Math.min(100, Math.max(0, percent));
+	const filled = Math.round((clamped / 100) * width);
+	return { filled: "█".repeat(filled), empty: "░".repeat(width - filled) };
+}

package/src/index.ts

@@ -6,6 +6,7 @@ import { BorderedLoader, type ExtensionAPI, type ExtensionContext, getAgentDir }
 import {
 	type Account,
 	isStrategy,
+	failoverMessage,
 	limitCooldown,
 	nextAccountId,
 	orderAccounts,
@@ -15,6 +16,8 @@ import {
 	type Strategy,
 	type UsageSnapshot,
 } from "./pool.ts";
+import { formatIn, formatReset, formatWindow } from "./format.ts";
+import { type AccountStatus, type PanelAction, PoolPanel } from "./panel.ts";
 import { fetchUsage, spendReset, type Usage } from "./usage.ts";
 
 const POOL_PROVIDER = "chatgpt";
@@ -96,20 +99,6 @@ function accountProvider(openai: Provider, account: Account, onReset: ResetListe
 	};
 }
 
-function formatWindow(seconds: number): string {
-	if (seconds % 604800 === 0) return seconds === 604800 ? "weekly" : `${seconds / 604800}-week`;
-	if (seconds % 3600 === 0) return `${seconds / 3600}h`;
-	return `${Math.round(seconds / 60)}m`;
-}
-
-function formatReset(at: number): string {
-	const date = new Date(at);
-	const time = date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
-	return date.toDateString() === new Date().toDateString()
-		? `at ${time}`
-		: `${date.toLocaleDateString([], { weekday: "short", month: "short", day: "numeric" })} at ${time}`;
-}
-
 export default function chatgptPool(pi: ExtensionAPI) {
 	const providers = builtinProviders();
 	const openai = providers.find((provider) => provider.id === "openai");
@@ -142,6 +131,14 @@ export default function chatgptPool(pi: ExtensionAPI) {
 		);
 		return new Map([...usageCache].map(([id, entry]) => [id, entry.snapshot]));
 	};
+	const refreshUsage = async (ctx: ExtensionContext, accountId: string) => {
+		const cached = usageCache.get(accountId);
+		if (cached && Date.now() - cached.at < USAGE_TTL_MS) return;
+		const token = await ctx.modelRegistry.getApiKeyForProvider(accountId).catch(() => undefined);
+		if (!token) return;
+		await fetchUsage(token).then((usage) => rememberUsage(accountId, usage), () => undefined);
+	};
+
 	const reportedResets = new Map<string, number>();
 	const onReset: ResetListener = (accountId, resetsAt) => reportedResets.set(accountId, resetsAt);
 
@@ -165,11 +162,16 @@ export default function chatgptPool(pi: ExtensionAPI) {
 		if (provider !== POOL_PROVIDER) return ctx.ui.setStatus(STATUS_KEY, undefined);
 		const now = Date.now();
 		const active = accounts.find((account) => account.id === lastRouted);
+		const snapshot = active && usageCache.get(active.id)?.snapshot;
 		const limited = accounts.filter((account) => (account.resetsAt ?? 0) > now);
 		const parts = [`chatgpt: ${active?.label ?? "pool"}`];
+		if (snapshot) {
+			parts[0] += ` ${Math.round(snapshot.usedPercent)}%`;
+			parts.push(`resets in ${formatIn(snapshot.resetsAt - now)}`);
+		}
 		if (limited.length > 0) {
 			const next = Math.min(...limited.map((account) => account.resetsAt ?? now));
-			parts.push(`${limited.length} limited, next back ${formatReset(next)}`);
+			parts.push(`${limited.length} limited, next back in ${formatIn(next - now)}`);
 		}
 		ctx.ui.setStatus(STATUS_KEY, parts.join(" · "));
 	};
@@ -212,10 +214,18 @@ export default function chatgptPool(pi: ExtensionAPI) {
 							: "Every ChatGPT account in the pool is signed out or limited. Run /chatgpt-pool to see reset times and banked resets.",
 					);
 				}
+				if (sticky !== undefined && sticky !== routed.provider && ctx.hasUI) {
+					const from = accounts.find((candidate) => candidate.id === sticky);
+					const until = from?.resetsAt && from.resetsAt > Date.now() ? ` (back in ${formatIn(from.resetsAt - Date.now())})` : "";
+					ctx.ui.notify(`ChatGPT pool: ${from?.label ?? sticky} is limited${until}, switched to ${account.label}.`, "info");
+				}
 				if (lastRouted !== routed.provider) {
 					lastRouted = routed.provider;
 					updateStatus(ctx);
 				}
+				refreshUsage(ctx, routed.provider)
+					.then(() => updateStatus(ctx, POOL_PROVIDER))
+					.catch(() => undefined);
 				return { model: routed, thinkingLevel: request.thinkingLevel };
 			},
 		});
@@ -237,13 +247,11 @@ export default function chatgptPool(pi: ExtensionAPI) {
 		return {
 			message: {
 				...message,
-				errorMessage: `ChatGPT account "${account.label}" is rate limited; switching to another account in the pool.`,
+				errorMessage: failoverMessage(account.label),
 			},
 		};
 	});
 
-	type AccountStatus = { account: Account; signedIn: boolean; usage?: Usage; error?: string };
-
 	const loadStatuses = (ctx: ExtensionContext, signal?: AbortSignal): Promise<AccountStatus[]> =>
 		Promise.all(
 			accounts.map(async (account): Promise<AccountStatus> => {
@@ -352,7 +360,50 @@ export default function chatgptPool(pi: ExtensionAPI) {
 		if (next && isStrategy(next)) setStrategy(ctx, next);
 	};
 
+	const runPanel = async (ctx: ExtensionContext) => {
+		let statuses = await withLoader(ctx, "Checking ChatGPT accounts...", (signal) => loadStatuses(ctx, signal));
+		while (statuses) {
+			updateStatus(ctx);
+			const current = statuses.map((status) => ({
+				...status,
+				account: accounts.find((account) => account.id === status.account.id) ?? status.account,
+			}));
+			const strategyName = STRATEGIES[strategy].split(":")[0];
+			const action = await ctx.ui.custom<PanelAction>(
+				(tui, theme, _keybindings, done) => new PoolPanel(tui, theme, current, strategyName, lastRouted, done),
+			);
+			if (!action || action.type === "close") return;
+			const status = "accountId" in action ? current.find((entry) => entry.account.id === action.accountId) : undefined;
+			let reload = false;
+			if (action.type === "refresh") {
+				reload = true;
+			} else if (action.type === "add") {
+				const label = (await ctx.ui.input("Label for the new ChatGPT account", "work"))?.trim();
+				if (label) addAccount(ctx, label);
+				reload = !!label;
+			} else if (action.type === "strategy") {
+				await chooseStrategy(ctx);
+			} else if (status && action.type === "spend") {
+				await spend(ctx, status.account, status.usage);
+				reload = true;
+			} else if (status && action.type === "clear") {
+				setResetsAt(status.account.id, undefined);
+				ctx.ui.notify(`ChatGPT (${status.account.label}) is back in rotation.`, "info");
+			} else if (status && action.type === "remove") {
+				if (await ctx.ui.confirm(`Remove ${status.account.label}?`, "It will no longer be used by the pool.")) {
+					removeAccount(ctx, status.account);
+					statuses = statuses.filter((entry) => entry.account.id !== status.account.id);
+				}
+			}
+			if (reload) {
+				usageCache.clear();
+				statuses = await withLoader(ctx, "Checking ChatGPT accounts...", (signal) => loadStatuses(ctx, signal));
+			}
+		}
+	};
+
 	const openPool = async (ctx: ExtensionContext) => {
+		if (ctx.mode === "tui") return runPanel(ctx);
 		const statuses = await withLoader(ctx, "Checking ChatGPT accounts...", (signal) => loadStatuses(ctx, signal));
 		if (!statuses) return;
 		updateStatus(ctx);

package/src/panel.ts

@@ -0,0 +1,111 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, Key, matchesKey, truncateToWidth, type TUI, visibleWidth } from "@earendil-works/pi-tui";
+import { formatIn, formatWindow, usageBar } from "./format.ts";
+import type { Account } from "./pool.ts";
+import type { Usage } from "./usage.ts";
+
+export type AccountStatus = { account: Account; signedIn: boolean; usage?: Usage; error?: string };
+
+export type PanelAction =
+	| { type: "close" }
+	| { type: "refresh" }
+	| { type: "add" }
+	| { type: "strategy" }
+	| { type: "spend" | "clear" | "remove"; accountId: string };
+
+const ACCOUNT_KEYS = new Map<string, "spend" | "clear" | "remove">([
+	["s", "spend"],
+	["c", "clear"],
+	["d", "remove"],
+]);
+const POOL_KEYS = new Map<string, "refresh" | "add" | "strategy">([
+	["r", "refresh"],
+	["a", "add"],
+	["t", "strategy"],
+]);
+const BAR_WIDTH = 16;
+const HINTS = [
+	"↑↓ select · s spend reset · c clear limit · d remove · a add · t strategy · r refresh · esc close",
+	"↑↓ · s spend · c clear · d remove · a add · t strategy · r refresh · esc",
+	"s spend · c clear · d del · a add · t strat · esc",
+];
+
+export class PoolPanel implements Component {
+	private selected = 0;
+
+	constructor(
+		private readonly tui: TUI,
+		private readonly theme: Theme,
+		private readonly statuses: readonly AccountStatus[],
+		private readonly strategyName: string,
+		private readonly activeId: string | undefined,
+		private readonly done: (action: PanelAction) => void,
+	) {}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.escape) || data === "q") return this.done({ type: "close" });
+		if (matchesKey(data, Key.up) || data === "k") return this.move(-1);
+		if (matchesKey(data, Key.down) || data === "j") return this.move(1);
+		const poolAction = POOL_KEYS.get(data);
+		const accountAction = ACCOUNT_KEYS.get(data);
+		const account = this.statuses[this.selected]?.account;
+		if (poolAction) this.done({ type: poolAction });
+		else if (accountAction && account) this.done({ type: accountAction, accountId: account.id });
+	}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		const { theme } = this;
+		const rule = theme.fg("borderAccent", "─".repeat(width));
+		const lines = [
+			rule,
+			`${theme.fg("accent", theme.bold("ChatGPT pool"))}  ${theme.fg("muted", `strategy: ${this.strategyName}`)}`,
+			"",
+		];
+		if (this.statuses.length === 0) lines.push(theme.fg("muted", "No accounts yet. Press a to add one."), "");
+		this.statuses.forEach((status, index) => lines.push(...this.renderAccount(status, index === this.selected), ""));
+		const hint = HINTS.find((text) => visibleWidth(text) <= width) ?? HINTS[HINTS.length - 1];
+		lines.push(theme.fg("dim", hint), rule);
+		return lines.map((line) => truncateToWidth(line, width));
+	}
+
+	private move(delta: number): void {
+		if (this.statuses.length === 0) return;
+		this.selected = (this.selected + delta + this.statuses.length) % this.statuses.length;
+		this.tui.requestRender();
+	}
+
+	private renderAccount({ account, signedIn, usage, error }: AccountStatus, selected: boolean): string[] {
+		const { theme } = this;
+		const now = Date.now();
+		const pointer = selected ? theme.fg("accent", "› ") : "  ";
+		const name = selected ? theme.fg("accent", theme.bold(account.label)) : theme.bold(account.label);
+		const active = account.id === this.activeId ? theme.fg("muted", " (in use)") : "";
+		const limitedUntil = account.resetsAt && account.resetsAt > now ? account.resetsAt : undefined;
+		const state = !signedIn
+			? theme.fg("muted", "not signed in")
+			: limitedUntil
+				? theme.fg("warning", `limited · back in ${formatIn(limitedUntil - now)}`)
+				: theme.fg("success", "ready");
+		const banked =
+			usage && usage.banked > 0
+				? theme.fg("accent", `  ${usage.banked} banked reset${usage.banked === 1 ? "" : "s"}`) +
+					(usage.usableNow > 0 ? theme.fg("success", ` (${usage.usableNow} usable now)`) : "")
+				: "";
+		const header = `${pointer}${name}${active}  ${state}${banked}`;
+
+		if (!signedIn) return [header, theme.fg("dim", `    run /login and pick ChatGPT (${account.label})`)];
+		if (!usage) return [header, theme.fg("dim", `    usage unavailable${error ? `: ${error}` : ""}`)];
+		return [
+			header,
+			...usage.windows.map((window) => {
+				const bar = usageBar(window.usedPercent, BAR_WIDTH);
+				const color = window.usedPercent >= 90 ? "error" : window.usedPercent >= 70 ? "warning" : "success";
+				const label = formatWindow(window.windowSeconds).padEnd(7);
+				const percent = `${Math.round(window.usedPercent)}%`.padStart(4);
+				return `    ${theme.fg("muted", label)} ${theme.fg(color, bar.filled)}${theme.fg("dim", bar.empty)} ${percent}  ${theme.fg("muted", `resets in ${formatIn(window.resetsAt - now)}`)}`;
+			}),
+		];
+	}
+}

package/src/pool.ts

@@ -3,6 +3,10 @@ export type Account = { id: string; label: string; resetsAt?: number };
 const USAGE_LIMIT = /usage.?limit|subscription_sharing_usage_limit_exceeded|insufficient_quota|quota/i;
 const RATE_LIMIT = /rate.?limit|too many requests|\b429\b/i;
 
+export function failoverMessage(label: string): string {
+	return `ChatGPT account "${label}" hit its rate limit; switching to another account in the pool.`;
+}
+
 export const USAGE_COOLDOWN_MS = 60 * 60 * 1000;
 export const RATE_COOLDOWN_MS = 60 * 1000;