@narumitw/pi-usage 0.49.3 → 0.51.0

package/src/codex-resets.ts

@@ -0,0 +1,308 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { readStoredCredential } from "@earendil-works/pi-coding-agent";
+import { fingerprintResolvedAuth, sanitizeDisplayText } from "./core.js";
+import {
+	AUTH_FINGERPRINT_SALT,
+	adapterForProvider,
+	fetchProviderJson,
+	resolveUsageAuth,
+} from "./query.js";
+import type { ResolvedUsageAuth, UsageReport } from "./types.js";
+
+const CODEX_RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
+const CODEX_RESET_CONSUME_URL = `${CODEX_RESET_CREDITS_URL}/consume`;
+const MAX_RESET_OPTIONS = 32;
+const MAX_CREDIT_ID_CHARS = 1_024;
+
+type StoredCredentialReader = (providerId: string) => unknown;
+
+export type CodexResetOutcomeCode = "reset" | "nothing_to_reset" | "no_credit" | "already_redeemed";
+
+export interface CodexResetOption {
+	creditId?: string;
+	title: string;
+	description: string;
+	expiresAt?: number;
+}
+
+export interface CodexResetAvailability {
+	availableCount: number;
+	options: CodexResetOption[];
+}
+
+export interface CodexResetOutcome {
+	code: CodexResetOutcomeCode;
+	windowsReset: number;
+}
+
+export function codexResetCount(report: UsageReport): number | undefined {
+	const value = report.metrics.find((metric) => metric.id === "reset-credits")?.value;
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+
+export function codexResetActionDescription(report: UsageReport): string {
+	const count = codexResetCount(report);
+	if (count === undefined) return "Check reset availability.";
+	if (count === 0) return "No usage limit resets available.";
+	return `You have ${count} ${resetLabel(count)} available.`;
+}
+
+export function genericCodexResetOption(): CodexResetOption {
+	return {
+		title: "Full reset",
+		description: "Reset your current usage limits.",
+	};
+}
+
+export function resetOptionExpiration(option: CodexResetOption): string {
+	if (option.expiresAt === undefined) return "Does not expire.";
+	const expiration = new Date(option.expiresAt * 1_000);
+	if (Number.isNaN(expiration.getTime())) return "Expiration unavailable.";
+	return `Expires ${expiration.toLocaleString()}.`;
+}
+
+export function resetConfirmationLines(option: CodexResetOption | undefined): string[] {
+	if (!option) return ["The selected reset is unavailable."];
+	return [
+		option.title,
+		resetOptionExpiration(option),
+		option.description,
+		"This consumes one earned reset for the current OpenAI Codex account.",
+	];
+}
+
+export function formatCodexResetOutcome(
+	outcome: CodexResetOutcome | undefined,
+	remainingCount: number | undefined,
+): string {
+	const remaining =
+		remainingCount === undefined
+			? ""
+			: ` You have ${remainingCount} ${resetLabel(remainingCount)} left.`;
+	if (!outcome) return "You don't have any usage limit resets available.";
+	if (outcome.code === "reset") return `Usage reset.${remaining}`.trim();
+	if (outcome.code === "already_redeemed") {
+		return `Usage reset was already completed.${remaining}`.trim();
+	}
+	if (outcome.code === "nothing_to_reset") {
+		return "Your usage does not need a reset right now.";
+	}
+	return "No usage limit resets are available.";
+}
+
+export function resetLabel(count: number): string {
+	return count === 1 ? "usage limit reset" : "usage limit resets";
+}
+
+export async function resolveCodexResetAuth(
+	ctx: ExtensionContext,
+	salt: Uint8Array = AUTH_FINGERPRINT_SALT,
+	credentialReader: StoredCredentialReader = readStoredCredential,
+): Promise<ResolvedUsageAuth> {
+	const model = ctx.model;
+	if (model?.provider !== "openai-codex") {
+		throw new Error("Usage limit resets require the current model to use OpenAI Codex.");
+	}
+	const expectedModel = `${model.provider}/${model.id}`;
+	const adapter = adapterForProvider("openai-codex");
+	if (!adapter) throw new Error("OpenAI Codex usage support is unavailable.");
+	const auth = await resolveUsageAuth(ctx, adapter, salt, credentialReader);
+	if (`${ctx.model?.provider}/${ctx.model?.id}` !== expectedModel) {
+		throw new Error("The current model changed while resolving Codex reset authentication.");
+	}
+	if (!auth) throw new Error("No runtime credential is configured for OpenAI Codex.");
+
+	const credential = asObject(credentialReader("openai-codex"));
+	if (credential?.type !== "oauth") {
+		throw new Error(
+			"Usage limit resets require the OpenAI Codex OAuth account configured through Pi /login.",
+		);
+	}
+	const storedAccess = asNonemptyString(credential.access);
+	const resolvedAccess = bearerToken(headerValue(auth.headers, "Authorization")) ?? auth.apiKey;
+	if (!storedAccess || !resolvedAccess) {
+		throw new Error("OpenAI Codex OAuth credentials were incomplete.");
+	}
+	if (storedAccess !== resolvedAccess) {
+		throw new Error(
+			"The active OpenAI Codex runtime account does not match Pi's stored OAuth account.",
+		);
+	}
+	const accountId = validHeaderValue(credential.accountId);
+	if (!accountId)
+		throw new Error("The OpenAI Codex OAuth credential did not include a valid account ID.");
+
+	const authorization = `Bearer ${resolvedAccess}`;
+	const headers = {
+		Authorization: authorization,
+		"chatgpt-account-id": accountId,
+	};
+	return {
+		apiKey: resolvedAccess,
+		headers,
+		fingerprint: fingerprintResolvedAuth({ headers }, salt),
+		secrets: [
+			...new Set([...auth.secrets, storedAccess, resolvedAccess, authorization, accountId]),
+		],
+		model: auth.model,
+	};
+}
+
+export async function listCodexResetCredits(
+	auth: ResolvedUsageAuth,
+	signal: AbortSignal,
+	timeoutMs: number,
+): Promise<CodexResetAvailability> {
+	const payload = await fetchProviderJson(
+		CODEX_RESET_CREDITS_URL,
+		auth,
+		signal,
+		timeoutMs,
+		"Codex usage-limit reset endpoint",
+	);
+	return normalizeCodexResetCreditsPayload(payload);
+}
+
+export async function consumeCodexResetCredit(
+	auth: ResolvedUsageAuth,
+	option: CodexResetOption,
+	redeemRequestId: string,
+	signal: AbortSignal,
+	timeoutMs: number,
+): Promise<CodexResetOutcome> {
+	if (!redeemRequestId) throw new Error("Codex reset redemption request ID must not be empty.");
+	const payload = await fetchProviderJson(
+		CODEX_RESET_CONSUME_URL,
+		auth,
+		signal,
+		timeoutMs,
+		"Codex usage-limit reset consume endpoint",
+		{
+			method: "POST",
+			body: {
+				redeem_request_id: redeemRequestId,
+				...(option.creditId ? { credit_id: option.creditId } : {}),
+			},
+		},
+	);
+	const code = payload.code;
+	if (!isCodexResetOutcomeCode(code)) {
+		throw new Error("Codex reset consume endpoint returned an unknown outcome code.");
+	}
+	const windowsReset =
+		payload.windows_reset === undefined ? 0 : nonnegativeInteger(payload.windows_reset);
+	if (windowsReset === undefined) {
+		throw new Error("Codex reset consume endpoint returned an invalid windows_reset value.");
+	}
+	return { code, windowsReset };
+}
+
+export function normalizeCodexResetCreditsPayload(
+	payload: Record<string, unknown>,
+): CodexResetAvailability {
+	const availableCount = nonnegativeInteger(payload.available_count);
+	if (availableCount === undefined) {
+		throw new Error("Codex reset credits response returned an invalid available_count.");
+	}
+	const rawCredits = payload.credits;
+	if (rawCredits !== undefined && !Array.isArray(rawCredits)) {
+		throw new Error("Codex reset credits response returned invalid credits.");
+	}
+
+	const options = (rawCredits ?? [])
+		.map(asObject)
+		.filter((credit): credit is Record<string, unknown> => Boolean(credit))
+		.filter((credit) => credit.status === "available" && credit.reset_type === "codex_rate_limits")
+		.map(normalizeResetOption)
+		.sort(
+			(left, right) =>
+				(left.expiresAt ?? Number.MAX_SAFE_INTEGER) - (right.expiresAt ?? Number.MAX_SAFE_INTEGER),
+		)
+		.slice(0, Math.min(availableCount, MAX_RESET_OPTIONS));
+
+	if (availableCount > 0 && options.length === 0) {
+		options.push(genericCodexResetOption());
+	}
+	return { availableCount, options };
+}
+
+function normalizeResetOption(credit: Record<string, unknown>): CodexResetOption {
+	const creditId = asOpaqueId(credit.id);
+	if (!creditId) throw new Error("Codex reset credits response returned an invalid credit ID.");
+	let expiresAt: number | undefined;
+	if (credit.expires_at !== undefined && credit.expires_at !== null) {
+		if (typeof credit.expires_at !== "string") {
+			throw new Error("Codex reset credits response returned an invalid expiration time.");
+		}
+		const parsed = Date.parse(credit.expires_at);
+		if (!Number.isFinite(parsed)) {
+			throw new Error("Codex reset credits response returned an invalid expiration time.");
+		}
+		expiresAt = Math.floor(parsed / 1_000);
+	}
+	const title = displayString(credit.title) ?? "Full reset";
+	const description = displayString(credit.description) ?? "Reset your current usage limits.";
+	return {
+		creditId,
+		title,
+		description,
+		...(expiresAt === undefined ? {} : { expiresAt }),
+	};
+}
+
+function isCodexResetOutcomeCode(value: unknown): value is CodexResetOutcomeCode {
+	return (
+		value === "reset" ||
+		value === "nothing_to_reset" ||
+		value === "no_credit" ||
+		value === "already_redeemed"
+	);
+}
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	return value as Record<string, unknown>;
+}
+
+function asNonemptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function asOpaqueId(value: unknown): string | undefined {
+	if (typeof value !== "string" || value.length === 0 || value.length > MAX_CREDIT_ID_CHARS) {
+		return undefined;
+	}
+	return value;
+}
+
+function displayString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	return sanitizeDisplayText(value, 160) || undefined;
+}
+
+function validHeaderValue(value: unknown): string | undefined {
+	if (typeof value !== "string" || !value || value.length > 512) return undefined;
+	if (/[^\x20-\x7e]/u.test(value)) return undefined;
+	return value;
+}
+
+function nonnegativeInteger(value: unknown): number | undefined {
+	const parsed =
+		typeof value === "number"
+			? value
+			: typeof value === "string" && value.trim()
+				? Number(value)
+				: Number.NaN;
+	if (!Number.isSafeInteger(parsed) || parsed < 0) return undefined;
+	return parsed;
+}
+
+function bearerToken(authorization: string | undefined): string | undefined {
+	return /^Bearer\s+(.+)$/iu.exec(authorization ?? "")?.[1];
+}
+
+function headerValue(headers: Record<string, string>, name: string): string | undefined {
+	return Object.entries(headers).find(
+		([candidate]) => candidate.toLowerCase() === name.toLowerCase(),
+	)?.[1];
+}

package/src/index.ts

@@ -1,3 +1,26 @@
+export {
+	CODEX_FAST_MODEL_IDS,
+	CODEX_FAST_SERVICE_TIER,
+	CODEX_STANDARD_SERVICE_TIER,
+	codexFastAvailability,
+	codexFastIsEffective,
+	codexFastRequestTier,
+	codexFastStatusLabel,
+	correctCodexFastMessageCost,
+	rewriteCodexFastPayload,
+} from "./codex-fast.js";
+export type {
+	CodexResetAvailability,
+	CodexResetOption,
+	CodexResetOutcome,
+	CodexResetOutcomeCode,
+} from "./codex-resets.js";
+export {
+	consumeCodexResetCredit,
+	listCodexResetCredits,
+	normalizeCodexResetCreditsPayload,
+	resolveCodexResetAuth,
+} from "./codex-resets.js";
 export {
 	abortError,
 	awaitWithDeadline,
@@ -20,6 +43,18 @@ export {
 	resolveUsageAuth,
 	SUPPORTED_ADAPTERS,
 } from "./query.js";
+export type {
+	UsageSettings,
+	UsageSettingsRuntime,
+	UsageSettingsState,
+} from "./settings.js";
+export {
+	createUsageSettingsRuntime,
+	DEFAULT_USAGE_SETTINGS,
+	loadUsageSettings,
+	normalizeUsageSettings,
+	usageSettingsPath,
+} from "./settings.js";
 export type {
 	ProviderUsageState,
 	ResolvedUsageAuth,

package/src/query.ts

@@ -182,12 +182,16 @@ function candidateModels(ctx: ExtensionContext, providerId: string): PiModel[] {
 	return candidates;
 }
 
-async function fetchProviderJson(
+export async function fetchProviderJson(
 	url: string,
 	auth: ResolvedUsageAuth,
 	signal: AbortSignal,
 	timeoutMs: number,
 	description: string,
+	request: {
+		method?: "GET" | "POST";
+		body?: Record<string, unknown>;
+	} = {},
 ): Promise<Record<string, unknown>> {
 	const controller = new AbortController();
 	let timedOut = false;
@@ -201,7 +205,15 @@ async function fetchProviderJson(
 	try {
 		const headers = { ...auth.headers };
 		if (!hasHeader(headers, "User-Agent")) headers["User-Agent"] = "pi-usage";
-		const response = await fetch(url, { headers, signal: controller.signal });
+		if (request.body && !hasHeader(headers, "Content-Type")) {
+			headers["Content-Type"] = "application/json";
+		}
+		const response = await fetch(url, {
+			method: request.method ?? "GET",
+			headers,
+			...(request.body ? { body: JSON.stringify(request.body) } : {}),
+			signal: controller.signal,
+		});
 		if (controller.signal.aborted)
 			throw Object.assign(new Error("Usage query aborted."), { name: "AbortError" });
 		const text = await readBoundedResponse(

package/src/settings.ts

@@ -0,0 +1,208 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { chmod, mkdir, open, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export const USAGE_SETTINGS_FILE = "pi-usage.json";
+export const MAX_USAGE_SETTINGS_BYTES = 64 * 1024;
+
+export interface UsageSettings {
+	codexFastMode: boolean;
+}
+
+export const DEFAULT_USAGE_SETTINGS: Readonly<UsageSettings> = Object.freeze({
+	codexFastMode: false,
+});
+
+export interface UsageSettingsState {
+	kind: "missing" | "loaded" | "invalid";
+	path: string;
+	settings: UsageSettings;
+	document?: Record<string, unknown>;
+	issue?: string;
+}
+
+export interface UsageSettingsRuntime {
+	get(): Readonly<UsageSettingsState>;
+	reload(signal?: AbortSignal): Promise<Readonly<UsageSettingsState>>;
+	update(
+		patch: Partial<UsageSettings>,
+		signal?: AbortSignal,
+	): Promise<Readonly<UsageSettingsState>>;
+	flush(): Promise<void>;
+}
+
+interface UsageSettingsFileOperations {
+	rename: typeof rename;
+	writeFile: typeof writeFile;
+}
+
+interface UsageSettingsRuntimeOptions {
+	operations?: Partial<UsageSettingsFileOperations>;
+	path?: string;
+}
+
+export function usageSettingsPath(): string {
+	return join(getAgentDir(), USAGE_SETTINGS_FILE);
+}
+
+export function normalizeUsageSettings(value: unknown): UsageSettings | undefined {
+	if (!isRecord(value)) return undefined;
+	if (Object.hasOwn(value, "codexFastMode") && typeof value.codexFastMode !== "boolean") {
+		return undefined;
+	}
+	return {
+		codexFastMode:
+			typeof value.codexFastMode === "boolean"
+				? value.codexFastMode
+				: DEFAULT_USAGE_SETTINGS.codexFastMode,
+	};
+}
+
+export async function loadUsageSettings(
+	path = usageSettingsPath(),
+	signal?: AbortSignal,
+): Promise<UsageSettingsState> {
+	throwIfAborted(signal);
+	try {
+		const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+		let text: string;
+		try {
+			const stats = await handle.stat();
+			throwIfAborted(signal);
+			if (!stats.isFile()) throw new Error("settings path is not a regular file");
+			if (stats.size > MAX_USAGE_SETTINGS_BYTES) {
+				throw new Error("settings file exceeds 64 KiB");
+			}
+			text = await handle.readFile("utf8");
+		} finally {
+			await handle.close();
+		}
+		throwIfAborted(signal);
+		const document = JSON.parse(text) as unknown;
+		const settings = normalizeUsageSettings(document);
+		if (!settings || !isRecord(document)) throw new Error("invalid settings shape");
+		return { kind: "loaded", path, settings, document };
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		if (isNodeError(error) && error.code === "ENOENT") {
+			return {
+				kind: "missing",
+				path,
+				settings: { ...DEFAULT_USAGE_SETTINGS },
+				document: {},
+			};
+		}
+		return {
+			kind: "invalid",
+			path,
+			settings: { ...DEFAULT_USAGE_SETTINGS },
+			issue:
+				isNodeError(error) && error.code === "ELOOP"
+					? "symbolic links are not accepted"
+					: error instanceof Error
+						? error.message
+						: String(error),
+		};
+	}
+}
+
+export function createUsageSettingsRuntime(
+	options: UsageSettingsRuntimeOptions | string = {},
+): UsageSettingsRuntime {
+	const path = typeof options === "string" ? options : (options.path ?? usageSettingsPath());
+	const operations: UsageSettingsFileOperations = {
+		rename,
+		writeFile,
+		...(typeof options === "string" ? undefined : options.operations),
+	};
+	let state: UsageSettingsState = {
+		kind: "missing",
+		path,
+		settings: { ...DEFAULT_USAGE_SETTINGS },
+		document: {},
+	};
+	let queue = Promise.resolve();
+	const enqueue = <T>(operation: () => Promise<T>): Promise<T> => {
+		const result = queue.then(operation, operation);
+		queue = result.then(
+			() => undefined,
+			() => undefined,
+		);
+		return result;
+	};
+	return {
+		get: () => structuredClone(state),
+		reload: (signal) =>
+			enqueue(async () => {
+				const loaded = await loadUsageSettings(path, signal);
+				state = loaded;
+				return structuredClone(state);
+			}),
+		update: (patch, signal) =>
+			enqueue(async () => {
+				const saved = await saveUsageSettingsPatch(path, patch, operations, signal);
+				state = saved;
+				return structuredClone(state);
+			}),
+		flush: () => queue,
+	};
+}
+
+async function saveUsageSettingsPatch(
+	path: string,
+	patch: Partial<UsageSettings>,
+	operations: UsageSettingsFileOperations,
+	signal?: AbortSignal,
+): Promise<UsageSettingsState> {
+	const latest = await loadUsageSettings(path, signal);
+	if (latest.kind === "invalid") {
+		throw new Error("Cannot overwrite an invalid pi-usage.json; repair it and reload first");
+	}
+	const document = { ...latest.document, ...patch };
+	const settings = normalizeUsageSettings(document);
+	if (!settings) throw new Error("Refusing to save invalid pi-usage settings");
+	const directory = dirname(path);
+	const temporaryPath = join(directory, `.${basename(path)}.${randomUUID()}.tmp`);
+	await mkdir(directory, { recursive: true, mode: 0o700 });
+	throwIfAborted(signal);
+	try {
+		await operations.writeFile(temporaryPath, `${JSON.stringify(document, null, 2)}\n`, {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 0o600,
+		});
+		if (process.platform !== "win32") await chmodPrivate(temporaryPath);
+		throwIfAborted(signal);
+		const current = await loadUsageSettings(path, signal);
+		if (
+			current.kind === "invalid" ||
+			current.kind !== latest.kind ||
+			JSON.stringify(current.document) !== JSON.stringify(latest.document)
+		) {
+			throw new Error("pi-usage.json changed while saving; retry the action");
+		}
+		throwIfAborted(signal);
+		await operations.rename(temporaryPath, path);
+	} finally {
+		await rm(temporaryPath, { force: true }).catch(() => undefined);
+	}
+	return { kind: "loaded", path, settings, document };
+}
+
+async function chmodPrivate(path: string): Promise<void> {
+	await chmod(path, 0o600);
+}
+
+function throwIfAborted(signal?: AbortSignal): void {
+	if (signal?.aborted) throw new DOMException("Settings operation aborted", "AbortError");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+	return error instanceof Error && "code" in error;
+}

package/src/usage-helpers.ts

@@ -0,0 +1,40 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { sanitizeDisplayText } from "./core.js";
+import { providerIsConfigured, SUPPORTED_ADAPTERS } from "./query.js";
+import type { PiModel, UsageProviderAdapter } from "./types.js";
+
+export function configuredAdapters(ctx: ExtensionContext): UsageProviderAdapter[] {
+	return SUPPORTED_ADAPTERS.filter(
+		(adapter) => adapter.id === ctx.model?.provider || providerIsConfigured(ctx, adapter.id),
+	);
+}
+
+export function providerDisplayName(ctx: ExtensionContext, providerId: string): string {
+	try {
+		return sanitizeDisplayText(ctx.modelRegistry.getProviderDisplayName(providerId), 80);
+	} catch {
+		return sanitizeDisplayText(providerId, 80);
+	}
+}
+
+export function setBoundedMap<T>(map: Map<string, T>, key: string, value: T, limit: number): void {
+	map.delete(key);
+	while (map.size >= limit) {
+		const oldest = map.keys().next().value;
+		if (oldest === undefined) break;
+		map.delete(oldest);
+	}
+	map.set(key, value);
+}
+
+export function modelIdentity(model: PiModel | undefined): string | undefined {
+	return model ? `${model.provider}/${model.id}` : undefined;
+}
+
+export function isAbortError(error: unknown): boolean {
+	return error instanceof Error && error.name === "AbortError";
+}
+
+export function isTimeoutError(error: unknown): boolean {
+	return error instanceof Error && error.name === "TimeoutError";
+}