@victor-software-house/pi-multicodex 2.3.0 → 2.3.1

package/account-manager.ts

@@ -30,11 +30,33 @@ export class AccountManager {
 	private manualEmail?: string;
 	private stateChangeHandlers = new Set<StateChangeHandler>();
 	private warnedAuthFailureEmails = new Set<string>();
+	private readyPromise: Promise<void> = Promise.resolve();
+	private readyResolve?: () => void;
 
 	constructor() {
 		this.data = loadStorage();
 	}
 
+	/**
+	 * Mark the account manager as initializing. The returned promise
+	 * resolves when {@link markReady} is called. Stream requests wait
+	 * on {@link waitUntilReady} so they don't race the startup refresh.
+	 */
+	beginInitialization(): void {
+		this.readyPromise = new Promise<void>((resolve) => {
+			this.readyResolve = resolve;
+		});
+	}
+
+	markReady(): void {
+		this.readyResolve?.();
+		this.readyResolve = undefined;
+	}
+
+	waitUntilReady(): Promise<void> {
+		return this.readyPromise;
+	}
+
 	private save(): void {
 		saveStorage(this.data);
 	}
@@ -255,21 +277,29 @@ export class AccountManager {
 		const account = this.getAccount(email);
 		if (account) {
 			account.quotaExhaustedUntil = until;
-			this.save();
+			if (!this.isPiAuthAccount(account)) {
+				this.save();
+			}
 			this.notifyStateChanged();
 		}
 	}
 
 	clearAllQuotaExhaustion(): number {
 		let cleared = 0;
-		for (const account of this.data.accounts) {
+		let managedChanged = false;
+		for (const account of this.getAccounts()) {
 			if (account.quotaExhaustedUntil) {
 				account.quotaExhaustedUntil = undefined;
 				cleared += 1;
+				if (!this.isPiAuthAccount(account)) {
+					managedChanged = true;
+				}
 			}
 		}
-		if (cleared > 0) {
+		if (managedChanged) {
 			this.save();
+		}
+		if (cleared > 0) {
 			this.notifyStateChanged();
 		}
 		return cleared;
@@ -377,7 +407,14 @@ export class AccountManager {
 			now,
 		});
 		if (selected) {
-			this.setActiveAccount(selected.email);
+			if (this.isPiAuthAccount(selected)) {
+				// Don't persist ephemeral pi auth email to disk — it would
+				// become a stale activeEmail after restart.
+				this.data.activeEmail = selected.email;
+				this.notifyStateChanged();
+			} else {
+				this.setActiveAccount(selected.email);
+			}
 		}
 		return selected;
 	}
@@ -398,15 +435,21 @@ export class AccountManager {
 	}
 
 	private clearExpiredExhaustion(now: number): void {
-		let changed = false;
-		for (const account of this.data.accounts) {
+		let managedChanged = false;
+		let anyChanged = false;
+		for (const account of this.getAccounts()) {
 			if (account.quotaExhaustedUntil && account.quotaExhaustedUntil <= now) {
 				account.quotaExhaustedUntil = undefined;
-				changed = true;
+				anyChanged = true;
+				if (!this.isPiAuthAccount(account)) {
+					managedChanged = true;
+				}
 			}
 		}
-		if (changed) {
+		if (managedChanged) {
 			this.save();
+		}
+		if (anyChanged) {
 			this.notifyStateChanged();
 		}
 	}

package/hooks.ts

@@ -6,28 +6,33 @@ async function refreshAndActivateBestAccount(
 	accountManager: AccountManager,
 	warningHandler?: WarningHandler,
 ): Promise<void> {
-	await accountManager.loadPiAuth();
-	await accountManager.refreshUsageForAllAccounts({ force: true });
+	accountManager.beginInitialization();
+	try {
+		await accountManager.loadPiAuth();
+		await accountManager.refreshUsageForAllAccounts({ force: true });
 
-	const needsReauth = accountManager.getAccountsNeedingReauth();
-	if (needsReauth.length > 0) {
-		const hints = needsReauth.map((a) => {
-			const cmd = accountManager.isPiAuthAccount(a)
-				? "/login openai-codex"
-				: `/multicodex use ${a.email}`;
-			return `${a.email} (${cmd})`;
-		});
-		warningHandler?.(
-			`Multicodex: ${needsReauth.length} account(s) need re-authentication: ${hints.join(", ")}`,
-		);
-	}
+		const needsReauth = accountManager.getAccountsNeedingReauth();
+		if (needsReauth.length > 0) {
+			const hints = needsReauth.map((a) => {
+				const cmd = accountManager.isPiAuthAccount(a)
+					? "/login openai-codex"
+					: `/multicodex use ${a.email}`;
+				return `${a.email} (${cmd})`;
+			});
+			warningHandler?.(
+				`Multicodex: ${needsReauth.length} account(s) need re-authentication: ${hints.join(", ")}`,
+			);
+		}
 
-	const manual = accountManager.getAvailableManualAccount();
-	if (manual) return;
-	if (accountManager.hasManualAccount()) {
-		accountManager.clearManualAccount();
+		const manual = accountManager.getAvailableManualAccount();
+		if (manual) return;
+		if (accountManager.hasManualAccount()) {
+			accountManager.clearManualAccount();
+		}
+		await accountManager.activateBestAccount();
+	} finally {
+		accountManager.markReady();
 	}
-	await accountManager.activateBestAccount();
 }
 
 export function handleSessionStart(
@@ -35,12 +40,12 @@ export function handleSessionStart(
 	warningHandler?: WarningHandler,
 ): void {
 	if (accountManager.getAccounts().length === 0) return;
-	void refreshAndActivateBestAccount(accountManager, warningHandler);
+	refreshAndActivateBestAccount(accountManager, warningHandler).catch(() => {});
 }
 
 export function handleNewSessionSwitch(
 	accountManager: AccountManager,
 	warningHandler?: WarningHandler,
 ): void {
-	void refreshAndActivateBestAccount(accountManager, warningHandler);
+	refreshAndActivateBestAccount(accountManager, warningHandler).catch(() => {});
 }

package/index.ts

@@ -22,6 +22,7 @@ export { createStreamWrapper } from "./stream-wrapper";
 export type { CodexUsageSnapshot } from "./usage";
 export {
 	formatResetAt,
+	getMaxUsedPercent,
 	getNextResetAt,
 	getWeeklyResetAt,
 	isUsageUntouched,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@victor-software-house/pi-multicodex",
-	"version": "2.3.0",
+	"version": "2.3.1",
 	"description": "Codex account rotation extension for pi",
 	"license": "MIT",
 	"type": "module",

package/selection.ts

@@ -1,6 +1,7 @@
 import type { Account } from "./storage";
 import {
 	type CodexUsageSnapshot,
+	getMaxUsedPercent,
 	getWeeklyResetAt,
 	isUsageUntouched,
 } from "./usage";
@@ -15,20 +16,26 @@ function pickRandomAccount(accounts: Account[]): Account | undefined {
 	return accounts[Math.floor(Math.random() * accounts.length)];
 }
 
-function pickEarliestWeeklyResetAccount(
+function pickLowestUsageAccount(
 	accounts: Account[],
 	usageByEmail: Map<string, CodexUsageSnapshot>,
 ): Account | undefined {
 	const candidates = accounts
-		.map((account) => ({
-			account,
-			resetAt: getWeeklyResetAt(usageByEmail.get(account.email)),
-		}))
-		.filter(
-			(entry): entry is { account: Account; resetAt: number } =>
-				typeof entry.resetAt === "number",
-		)
-		.sort((a, b) => a.resetAt - b.resetAt);
+		.map((account) => {
+			const usage = usageByEmail.get(account.email);
+			return {
+				account,
+				usedPercent: getMaxUsedPercent(usage) ?? 100,
+				resetAt: getWeeklyResetAt(usage) ?? Number.MAX_SAFE_INTEGER,
+			};
+		})
+		.sort((a, b) => {
+			// Primary: lowest usage first
+			const usageDiff = a.usedPercent - b.usedPercent;
+			if (usageDiff !== 0) return usageDiff;
+			// Tiebreaker: earliest weekly reset first
+			return a.resetAt - b.resetAt;
+		});
 
 	return candidates[0]?.account;
 }
@@ -55,16 +62,13 @@ export function pickBestAccount(
 
 	if (untouched.length > 0) {
 		return (
-			pickEarliestWeeklyResetAccount(untouched, usageByEmail) ??
+			pickLowestUsageAccount(untouched, usageByEmail) ??
 			pickRandomAccount(untouched)
 		);
 	}
 
-	const earliestWeeklyReset = pickEarliestWeeklyResetAccount(
-		withUsage,
-		usageByEmail,
-	);
-	if (earliestWeeklyReset) return earliestWeeklyReset;
+	const lowestUsage = pickLowestUsageAccount(withUsage, usageByEmail);
+	if (lowestUsage) return lowestUsage;
 
 	return pickRandomAccount(available);
 }

package/stream-wrapper.ts

@@ -39,6 +39,7 @@ export function createStreamWrapper(
 
 		(async () => {
 			try {
+				await accountManager.waitUntilReady();
 				const excludedEmails = new Set<string>();
 				for (let attempt = 0; attempt <= MAX_ROTATION_RETRIES; attempt++) {
 					const now = Date.now();

package/usage.ts

@@ -66,6 +66,17 @@ export function getNextResetAt(usage?: CodexUsageSnapshot): number | undefined {
 	return Math.min(...candidates);
 }
 
+export function getMaxUsedPercent(
+	usage?: CodexUsageSnapshot,
+): number | undefined {
+	const candidates = [
+		usage?.primary?.usedPercent,
+		usage?.secondary?.usedPercent,
+	].filter((value): value is number => typeof value === "number");
+	if (candidates.length === 0) return undefined;
+	return Math.max(...candidates);
+}
+
 export function getWeeklyResetAt(
 	usage?: CodexUsageSnapshot,
 ): number | undefined {