@narumitw/pi-usage 0.60.0 → 0.60.2

package/src/types.ts

@@ -53,23 +53,51 @@ export interface ResolvedUsageAuth {
 	fingerprint: string;
 	secrets: string[];
 	model: PiModel;
+	auth?: {
+		apiKey?: string;
+		headers?: Record<string, string | null>;
+		baseUrl?: string;
+	};
+	env?: Record<string, string>;
+	source?: string;
+	effectiveBaseUrl?: string;
 }
 
 export interface UsageQuerySettings {
 	fireworksAccountId?: string;
 }
 
+export type UsageRequestGuard = () => Promise<void>;
+
+export interface UsageProviderTarget {
+	id: string;
+	label: string;
+	description?: string;
+}
+
+export interface UsageTargetResolver {
+	singularLabel: string;
+	pluralLabel: string;
+	list(
+		auth: ResolvedUsageAuth,
+		signal: AbortSignal,
+		timeoutMs: number,
+		guard: UsageRequestGuard,
+	): Promise<readonly UsageProviderTarget[]>;
+}
+
 export interface UsageProviderAdapter {
 	id: string;
 	displayName: string;
 	semantics: UsageSemantics;
 	publishesStatusline?: boolean;
+	targets?: UsageTargetResolver;
 	query(
 		auth: ResolvedUsageAuth,
 		signal: AbortSignal,
 		timeoutMs: number,
-		guard?: () => Promise<void>,
-		settings?: Readonly<UsageQuerySettings>,
+		guard?: UsageRequestGuard,
+		targetId?: string,
 	): Promise<UsageReport>;
 }
 
@@ -81,6 +109,15 @@ export type ProviderUsageState =
 			status: "ready";
 			report: UsageReport;
 	  }
+	| {
+			providerId: string;
+			providerName: string;
+			displayState: UsageDisplayState;
+			status: "selection-required";
+			singularLabel: string;
+			pluralLabel: string;
+			choices: readonly UsageProviderTarget[];
+	  }
 	| {
 			providerId: string;
 			providerName: string;

package/src/usage-settings-ui.ts

@@ -11,16 +11,12 @@ import {
 	Text,
 } from "@earendil-works/pi-tui";
 import { errorMessage } from "./core.js";
-import { isFireworksAccountId } from "./providers/fireworks.js";
-import type { UsageSettings, UsageSettingsRuntime } from "./settings.js";
+import type { UsageSettingsRuntime } from "./settings.js";
 
-const AUTO = "Auto";
-const EDIT = "Edit…";
 const OFF = "Off";
 const ON = "On";
 
-type UsageSettingId = keyof UsageSettings;
-type SettingsScreenResult = { changed: boolean; editFireworksAccount: boolean };
+type UsageSettingId = "codexFastMode" | "codexStatusResetCountdown";
 
 export async function showUsageSettings(
 	ctx: ExtensionCommandContext,
@@ -33,187 +29,96 @@ export async function showUsageSettings(
 		if (ctx.hasUI) ctx.ui.notify(`Edit settings manually: ${settingsRuntime.get().path}`, "info");
 		return false;
 	}
-	let changed = false;
-	while (!parentSignal.aborted && isCurrent()) {
-		const result = await showSettingsList(ctx, settingsRuntime, parentSignal, isCurrent, onApplied);
-		if (!result) return changed;
-		changed ||= result.changed;
-		if (!result.editFireworksAccount) return changed;
-		changed ||= await editFireworksAccount(
-			ctx,
-			settingsRuntime,
-			parentSignal,
-			isCurrent,
-			onApplied,
-		);
-	}
-	return changed;
-}
+	return (
+		(await ctx.ui.custom<boolean>((tui, theme, _keybindings, done) => {
+			const localController = new AbortController();
+			const signal = AbortSignal.any([parentSignal, localController.signal]);
+			let changed = false;
+			let closing = false;
+			let saveQueue = Promise.resolve();
+			const state = settingsRuntime.get();
+			const items: SettingItem[] = [
+				{
+					id: "codexFastMode",
+					label: "Codex Fast mode",
+					description: "Use faster Codex routing at increased plan allowance consumption.",
+					currentValue: state.settings.codexFastMode ? ON : OFF,
+					values: [OFF, ON],
+				},
+				{
+					id: "codexStatusResetCountdown",
+					label: "Codex reset countdown",
+					description: "Show time remaining until each Codex usage limit resets.",
+					currentValue: state.settings.codexStatusResetCountdown ? ON : OFF,
+					values: [OFF, ON],
+				},
+			];
+			const container = new Container();
+			container.addChild(new Text(theme.fg("accent", theme.bold("pi-usage Settings")), 1, 1));
 
-async function showSettingsList(
-	ctx: ExtensionCommandContext,
-	settingsRuntime: UsageSettingsRuntime,
-	parentSignal: AbortSignal,
-	isCurrent: () => boolean,
-	onApplied: (id: UsageSettingId) => void,
-): Promise<SettingsScreenResult | undefined> {
-	return ctx.ui.custom<SettingsScreenResult>((tui, theme, _keybindings, done) => {
-		const localController = new AbortController();
-		const signal = AbortSignal.any([parentSignal, localController.signal]);
-		let changed = false;
-		let closing = false;
-		let saveQueue = Promise.resolve();
-		const state = settingsRuntime.get();
-		const fireworksValue = state.settings.fireworksAccountId ?? AUTO;
-		const items: SettingItem[] = [
-			{
-				id: "codexFastMode",
-				label: "Codex Fast mode",
-				description: "Use faster Codex routing at increased plan allowance consumption.",
-				currentValue: state.settings.codexFastMode ? ON : OFF,
-				values: [OFF, ON],
-			},
-			{
-				id: "codexStatusResetCountdown",
-				label: "Codex reset countdown",
-				description: "Show time remaining until each Codex usage limit resets.",
-				currentValue: state.settings.codexStatusResetCountdown ? ON : OFF,
-				values: [OFF, ON],
-			},
-			{
-				id: "fireworksAccountId",
-				label: "Fireworks account",
-				description: "Select Edit to enter a visible account slug, or submit blank to clear it.",
-				currentValue: fireworksValue,
-				values: state.settings.fireworksAccountId
-					? [state.settings.fireworksAccountId, EDIT]
-					: [AUTO, EDIT],
-			},
-		];
-		const container = new Container();
-		container.addChild(new Text(theme.fg("accent", theme.bold("pi-usage Settings")), 1, 1));
-
-		let settingsList: SettingsList;
-		const cancel = () => {
-			if (closing) return;
-			closing = true;
-			localController.abort();
-			done({ changed, editFireworksAccount: false });
-		};
-		const queueUpdate = (
-			id: UsageSettingId,
-			requested: UsageSettings[UsageSettingId],
-			display: string,
-		) => {
-			saveQueue = saveQueue.then(async () => {
-				const previous = settingsRuntime.get().settings[id];
-				if (settingsRuntime.get().kind === "invalid") {
-					settingsList.updateValue(id, displaySetting(id, previous));
-					if (!signal.aborted && isCurrent()) {
-						ctx.ui.notify("Repair pi-usage.json and reload before changing settings.", "error");
+			let settingsList: SettingsList;
+			const cancel = () => {
+				if (closing) return;
+				closing = true;
+				localController.abort();
+				done(changed);
+			};
+			const queueUpdate = (id: UsageSettingId, requested: boolean, display: string) => {
+				saveQueue = saveQueue.then(async () => {
+					const previous = settingsRuntime.get().settings[id];
+					if (settingsRuntime.get().kind === "invalid") {
+						settingsList.updateValue(id, previous ? ON : OFF);
+						if (!signal.aborted && isCurrent()) {
+							ctx.ui.notify("Repair pi-usage.json and reload before changing settings.", "error");
+							tui.requestRender();
+						}
+						return;
+					}
+					try {
+						await settingsRuntime.update({ [id]: requested }, signal);
+					} catch (error) {
+						if (signal.aborted || !isCurrent()) return;
+						settingsList.updateValue(id, previous ? ON : OFF);
+						ctx.ui.notify(`Could not save pi-usage.json: ${errorMessage(error)}`, "error");
 						tui.requestRender();
+						return;
+					}
+					if (previous !== requested) {
+						changed = true;
+						onApplied(id);
 					}
-					return;
-				}
-				try {
-					await settingsRuntime.update({ [id]: requested }, signal);
-				} catch (error) {
 					if (signal.aborted || !isCurrent()) return;
-					settingsList.updateValue(id, displaySetting(id, previous));
-					ctx.ui.notify(`Could not save pi-usage.json: ${errorMessage(error)}`, "error");
+					settingsList.updateValue(id, display);
 					tui.requestRender();
-					return;
-				}
-				if (previous !== requested) {
-					changed = true;
-					onApplied(id);
-				}
-				if (signal.aborted || !isCurrent()) return;
-				settingsList.updateValue(id, display);
-				tui.requestRender();
-			});
-		};
-		settingsList = new SettingsList(
-			items,
-			items.length + 2,
-			getSettingsListTheme(),
-			(id, value) => {
-				if (closing || signal.aborted || !isCurrent()) return;
-				if (id === "fireworksAccountId") {
-					if (value === EDIT) {
-						saveQueue = saveQueue.then(() => {
-							if (closing || signal.aborted || !isCurrent()) return;
-							closing = true;
-							done({ changed, editFireworksAccount: true });
-						});
-					}
-					return;
-				}
-				const settingId = id as "codexFastMode" | "codexStatusResetCountdown";
-				queueUpdate(settingId, value !== OFF, value);
-			},
-			cancel,
-		);
-		container.addChild(settingsList);
+				});
+			};
+			settingsList = new SettingsList(
+				items,
+				items.length + 2,
+				getSettingsListTheme(),
+				(id, value) => {
+					if (closing || signal.aborted || !isCurrent()) return;
+					queueUpdate(id as UsageSettingId, value !== OFF, value);
+				},
+				cancel,
+			);
+			container.addChild(settingsList);
 
-		parentSignal.addEventListener("abort", cancel, { once: true });
-		return {
-			render: (width: number) => container.render(width),
-			invalidate: () => container.invalidate(),
-			handleInput(data: string) {
-				if (closing) return;
-				if (matchesKey(data, Key.ctrl("c"))) cancel();
-				else settingsList.handleInput(data);
-				tui.requestRender();
-			},
-			dispose() {
-				localController.abort();
-				parentSignal.removeEventListener("abort", cancel);
-			},
-		};
-	});
-}
-
-async function editFireworksAccount(
-	ctx: ExtensionCommandContext,
-	settingsRuntime: UsageSettingsRuntime,
-	signal: AbortSignal,
-	isCurrent: () => boolean,
-	onApplied: (id: UsageSettingId) => void,
-): Promise<boolean> {
-	while (!signal.aborted && isCurrent()) {
-		const state = settingsRuntime.get();
-		if (state.kind === "invalid") {
-			ctx.ui.notify("Repair pi-usage.json and reload before changing settings.", "error");
-			return false;
-		}
-		const entered = await ctx.ui.input(
-			"Fireworks account slug · submit blank for Auto",
-			state.settings.fireworksAccountId ?? "Example: acme",
-			{ signal },
-		);
-		if (signal.aborted || !isCurrent() || entered === undefined) return false;
-		const normalized = entered.trim();
-		const requested = normalized || undefined;
-		if (requested !== undefined && !isFireworksAccountId(requested)) {
-			ctx.ui.notify("Enter a URL-safe Fireworks account slug.", "warning");
-			continue;
-		}
-		if (requested === state.settings.fireworksAccountId) return false;
-		try {
-			await settingsRuntime.update({ fireworksAccountId: requested }, signal);
-		} catch (error) {
-			if (signal.aborted || !isCurrent()) return false;
-			ctx.ui.notify(`Could not save pi-usage.json: ${errorMessage(error)}`, "error");
-			return false;
-		}
-		onApplied("fireworksAccountId");
-		return true;
-	}
-	return false;
-}
-
-function displaySetting(id: UsageSettingId, value: UsageSettings[UsageSettingId]): string {
-	if (id === "fireworksAccountId") return typeof value === "string" ? value : AUTO;
-	return value ? ON : OFF;
+			parentSignal.addEventListener("abort", cancel, { once: true });
+			return {
+				render: (width: number) => container.render(width),
+				invalidate: () => container.invalidate(),
+				handleInput(data: string) {
+					if (closing) return;
+					if (matchesKey(data, Key.ctrl("c"))) cancel();
+					else settingsList.handleInput(data);
+					tui.requestRender();
+				},
+				dispose() {
+					localController.abort();
+					parentSignal.removeEventListener("abort", cancel);
+				},
+			};
+		})) ?? false
+	);
 }

package/src/usage-targets.ts

@@ -0,0 +1,143 @@
+import { sanitizeDisplayText } from "./core.js";
+import type {
+	ResolvedUsageAuth,
+	UsageProviderAdapter,
+	UsageProviderTarget,
+	UsageRequestGuard,
+} from "./types.js";
+
+const MAX_TARGETS = 1_000;
+const MAX_TARGET_ID_CHARS = 256;
+const MAX_TARGET_LABEL_CHARS = 120;
+const MAX_TARGET_DESCRIPTION_CHARS = 180;
+
+export type UsageTargetResolution =
+	| { kind: "selected"; targetId?: string }
+	| {
+			kind: "selection-required";
+			choices: readonly UsageProviderTarget[];
+	  };
+
+export interface UsageTargetSelectOptions {
+	options: readonly string[];
+	targetIdFor(option: string): string | undefined;
+}
+
+export async function resolveUsageTarget(
+	adapter: UsageProviderAdapter,
+	auth: ResolvedUsageAuth,
+	rememberedTargetId: string | undefined,
+	signal: AbortSignal,
+	timeoutMs: number,
+	guard: UsageRequestGuard,
+): Promise<UsageTargetResolution> {
+	if (!adapter.targets) return { kind: "selected" };
+	if (rememberedTargetId !== undefined && !isBoundedTargetId(rememberedTargetId)) {
+		throw new Error(`The remembered ${adapter.targets.singularLabel} identifier was invalid.`);
+	}
+	const choices = await listUsageTargets(adapter, auth, signal, timeoutMs, guard);
+	if (rememberedTargetId) {
+		return choices.some((choice) => choice.id === rememberedTargetId)
+			? { kind: "selected", targetId: rememberedTargetId }
+			: { kind: "selection-required", choices };
+	}
+	if (choices.length === 1) return { kind: "selected", targetId: choices[0]?.id };
+	return { kind: "selection-required", choices };
+}
+
+export async function listUsageTargets(
+	adapter: UsageProviderAdapter,
+	auth: ResolvedUsageAuth,
+	signal: AbortSignal,
+	timeoutMs: number,
+	guard: UsageRequestGuard,
+): Promise<readonly UsageProviderTarget[]> {
+	if (!adapter.targets) return [];
+	const startedAt = Date.now();
+	await guard();
+	const listed = await adapter.targets.list(
+		auth,
+		signal,
+		remainingTargetTimeout(timeoutMs, startedAt),
+		guard,
+	);
+	await guard();
+	remainingTargetTimeout(timeoutMs, startedAt);
+	const choices = normalizeUsageTargets(listed);
+	if (choices.length === 0) {
+		throw new Error(`${adapter.targets.pluralLabel} discovery returned no choices.`);
+	}
+	return choices;
+}
+
+export function normalizeUsageTargets(
+	targets: readonly UsageProviderTarget[],
+): readonly UsageProviderTarget[] {
+	if (!Array.isArray(targets)) throw new Error("Target discovery did not return a choices array.");
+	if (targets.length > MAX_TARGETS) {
+		throw new Error(`Target discovery exceeded ${MAX_TARGETS} choices.`);
+	}
+	const seen = new Set<string>();
+	return targets.map((target) => {
+		if (!target || typeof target !== "object" || Array.isArray(target)) {
+			throw new Error("Target discovery returned an invalid choice.");
+		}
+		const { id, label, description } = target as Partial<UsageProviderTarget>;
+		if (!isBoundedTargetId(id)) throw new Error("Target discovery returned an invalid ID.");
+		if (seen.has(id)) throw new Error(`Target discovery repeated ${id}.`);
+		seen.add(id);
+		if (typeof label !== "string") {
+			throw new Error("Target discovery returned an invalid display label.");
+		}
+		if (description !== undefined && typeof description !== "string") {
+			throw new Error("Target discovery returned an invalid description.");
+		}
+		const safeLabel = sanitizeDisplayText(label, MAX_TARGET_LABEL_CHARS);
+		if (!safeLabel) throw new Error("Target discovery returned an empty display label.");
+		const safeDescription = description
+			? sanitizeDisplayText(description, MAX_TARGET_DESCRIPTION_CHARS)
+			: undefined;
+		return { id, label: safeLabel, ...(safeDescription ? { description: safeDescription } : {}) };
+	});
+}
+
+export function createUsageTargetSelectOptions(
+	targets: readonly UsageProviderTarget[],
+): UsageTargetSelectOptions {
+	const normalized = normalizeUsageTargets(targets);
+	const ids = new Map<string, string>();
+	const options = normalized.map((target) => {
+		const base = target.description ? `${target.label} — ${target.description}` : target.label;
+		let option = base;
+		if (ids.has(option)) {
+			const safeId = sanitizeDisplayText(target.id, 80) || "target";
+			option = `${base} · ${safeId}`;
+			let duplicate = 2;
+			while (ids.has(option)) {
+				option = `${base} · ${safeId} (${duplicate})`;
+				duplicate += 1;
+			}
+		}
+		ids.set(option, target.id);
+		return option;
+	});
+	return { options, targetIdFor: (option) => ids.get(option) };
+}
+
+function remainingTargetTimeout(timeoutMs: number, startedAt: number): number {
+	const remaining = timeoutMs - (Date.now() - startedAt);
+	if (remaining <= 0) throw new Error("Timed out while discovering provider targets.");
+	return remaining;
+}
+
+export function isBoundedTargetId(value: unknown): value is string {
+	return (
+		typeof value === "string" &&
+		value.length > 0 &&
+		value.length <= MAX_TARGET_ID_CHARS &&
+		![...value].some((character) => {
+			const codePoint = character.codePointAt(0) ?? 0;
+			return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f);
+		})
+	);
+}