jeopi-ai 16.2.13

package/src/usage/openai-codex.ts

@@ -0,0 +1,535 @@
+import { Buffer } from "node:buffer";
+import type {
+	CredentialRankingStrategy,
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageResetCredits,
+	UsageWindow,
+} from "../usage";
+import { isRecord } from "../utils";
+import { normalizeCodexBaseUrl } from "./openai-codex-base-url";
+import { listCodexResetCredits } from "./openai-codex-reset";
+import { toNumber } from "./shared";
+
+const CODEX_USAGE_PATH = "wham/usage";
+const JWT_AUTH_CLAIM = "https://api.openai.com/auth";
+const JWT_PROFILE_CLAIM = "https://api.openai.com/profile";
+
+interface CodexUsageWindowPayload {
+	used_percent?: number;
+	limit_window_seconds?: number;
+	reset_after_seconds?: number;
+	reset_at?: number;
+}
+
+interface CodexUsageRateLimitPayload {
+	allowed?: boolean;
+	limit_reached?: boolean;
+	primary_window?: CodexUsageWindowPayload | null;
+	secondary_window?: CodexUsageWindowPayload | null;
+}
+
+interface CodexUsageAdditionalRateLimitPayload {
+	limit_name?: string;
+	metered_feature?: string;
+	rate_limit?: CodexUsageRateLimitPayload | null;
+}
+
+interface CodexUsagePayload {
+	plan_type?: string;
+	rate_limit?: CodexUsageRateLimitPayload | null;
+	additional_rate_limits?: CodexUsageAdditionalRateLimitPayload[] | null;
+}
+
+interface ParsedUsageWindow {
+	usedPercent?: number;
+	limitWindowSeconds?: number;
+	resetAfterSeconds?: number;
+	resetAt?: number;
+}
+
+interface ParsedAdditionalUsage {
+	limitName?: string;
+	meteredFeature?: string;
+	allowed?: boolean;
+	limitReached?: boolean;
+	primary?: ParsedUsageWindow;
+	secondary?: ParsedUsageWindow;
+}
+
+interface ParsedUsage {
+	planType?: string;
+	allowed?: boolean;
+	limitReached?: boolean;
+	primary?: ParsedUsageWindow;
+	secondary?: ParsedUsageWindow;
+	additional: ParsedAdditionalUsage[];
+	raw: CodexUsagePayload;
+}
+
+interface JwtPayload {
+	[JWT_AUTH_CLAIM]?: {
+		chatgpt_account_id?: string;
+	};
+	[JWT_PROFILE_CLAIM]?: {
+		email?: string;
+	};
+}
+
+const toBoolean = (value: unknown): boolean | undefined => {
+	if (typeof value === "boolean") return value;
+	return undefined;
+};
+
+function base64UrlDecode(input: string): string {
+	const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+	const padLen = (4 - (base64.length % 4)) % 4;
+	const padded = base64 + "=".repeat(padLen);
+	return Buffer.from(padded, "base64").toString("utf8");
+}
+
+function parseJwt(token: string): JwtPayload | null {
+	const parts = token.split(".");
+	if (parts.length !== 3) return null;
+	try {
+		const payloadJson = base64UrlDecode(parts[1]);
+		return JSON.parse(payloadJson) as JwtPayload;
+	} catch {
+		return null;
+	}
+}
+
+function normalizeEmail(email: string | undefined): string | undefined {
+	if (!email) return undefined;
+	const normalized = email.trim().toLowerCase();
+	return normalized || undefined;
+}
+
+function extractAccountId(token: string | undefined): string | undefined {
+	if (!token) return undefined;
+	const payload = parseJwt(token);
+	return payload?.[JWT_AUTH_CLAIM]?.chatgpt_account_id ?? undefined;
+}
+
+function extractEmail(token: string | undefined): string | undefined {
+	if (!token) return undefined;
+	const payload = parseJwt(token);
+	return normalizeEmail(payload?.[JWT_PROFILE_CLAIM]?.email);
+}
+
+function parseUsageWindow(payload: unknown): ParsedUsageWindow | undefined {
+	if (!isRecord(payload)) return undefined;
+	const usedPercent = toNumber(payload.used_percent);
+	const limitWindowSeconds = toNumber(payload.limit_window_seconds);
+	const resetAfterSeconds = toNumber(payload.reset_after_seconds);
+	const resetAt = toNumber(payload.reset_at);
+	if (
+		usedPercent === undefined &&
+		limitWindowSeconds === undefined &&
+		resetAfterSeconds === undefined &&
+		resetAt === undefined
+	) {
+		return undefined;
+	}
+	return {
+		usedPercent,
+		limitWindowSeconds,
+		resetAfterSeconds,
+		resetAt,
+	};
+}
+
+function parseAdditionalRateLimit(payload: unknown): ParsedAdditionalUsage | null {
+	if (!isRecord(payload)) return null;
+	const limitName = typeof payload.limit_name === "string" ? payload.limit_name : undefined;
+	const meteredFeature = typeof payload.metered_feature === "string" ? payload.metered_feature : undefined;
+	const rateLimit = isRecord(payload.rate_limit) ? payload.rate_limit : undefined;
+	if (!rateLimit) return null;
+	const primary = parseUsageWindow(rateLimit.primary_window);
+	const secondary = parseUsageWindow(rateLimit.secondary_window);
+	const allowed = toBoolean(rateLimit.allowed);
+	const limitReached = toBoolean(rateLimit.limit_reached);
+	if (!primary && !secondary && allowed === undefined && limitReached === undefined) return null;
+	return { limitName, meteredFeature, allowed, limitReached, primary, secondary };
+}
+
+function parseUsagePayload(payload: unknown): ParsedUsage | null {
+	if (!isRecord(payload)) return null;
+	const planType = typeof payload.plan_type === "string" ? payload.plan_type : undefined;
+	const rateLimit = isRecord(payload.rate_limit) ? payload.rate_limit : undefined;
+	const additionalRaw = Array.isArray(payload.additional_rate_limits) ? payload.additional_rate_limits : [];
+	const additional = additionalRaw
+		.map(parseAdditionalRateLimit)
+		.filter((value): value is ParsedAdditionalUsage => value !== null);
+	if (!rateLimit && additional.length === 0) return null;
+	const parsed: ParsedUsage = {
+		planType,
+		allowed: rateLimit ? toBoolean(rateLimit.allowed) : undefined,
+		limitReached: rateLimit ? toBoolean(rateLimit.limit_reached) : undefined,
+		primary: rateLimit ? parseUsageWindow(rateLimit.primary_window) : undefined,
+		secondary: rateLimit ? parseUsageWindow(rateLimit.secondary_window) : undefined,
+		additional,
+		raw: payload as CodexUsagePayload,
+	};
+	if (
+		!parsed.primary &&
+		!parsed.secondary &&
+		parsed.allowed === undefined &&
+		parsed.limitReached === undefined &&
+		parsed.additional.length === 0
+	) {
+		return null;
+	}
+	return parsed;
+}
+
+/**
+ * Parse the `rate_limit_reset_credits` block from `/wham/usage`. OpenAI Codex
+ * reports the count of saved rate-limit resets the account can redeem here; the
+ * redeem action itself lives in `./openai-codex-reset`.
+ */
+function parseResetCredits(payload: unknown): UsageResetCredits | undefined {
+	if (!isRecord(payload)) return undefined;
+	const block = payload.rate_limit_reset_credits;
+	if (!isRecord(block)) return undefined;
+	const availableCount = toNumber(block.available_count);
+	if (availableCount === undefined) return undefined;
+	return { availableCount: Math.max(0, Math.trunc(availableCount)) };
+}
+
+function buildCodexUsageUrl(baseUrl: string): string {
+	const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+	return `${normalized}${CODEX_USAGE_PATH}`;
+}
+
+function formatWindowLabel(value: number, unit: "hour" | "day"): string {
+	const rounded = Math.round(value);
+	const suffix = rounded === 1 ? unit : `${unit}s`;
+	return `${rounded} ${suffix}`;
+}
+
+function buildWindowLabel(seconds: number): { id: string; label: string } {
+	const daySeconds = 86_400;
+	if (seconds >= daySeconds) {
+		const days = Math.round(seconds / daySeconds);
+		return { id: `${days}d`, label: formatWindowLabel(days, "day") };
+	}
+	const hours = Math.max(1, Math.round(seconds / 3600));
+	return { id: `${hours}h`, label: formatWindowLabel(hours, "hour") };
+}
+
+function resolveResetTime(window: ParsedUsageWindow, nowMs: number): number | undefined {
+	const resetAt = window.resetAt;
+	if (resetAt !== undefined) {
+		const resetAtMs = resetAt > 1_000_000_000_000 ? resetAt : resetAt * 1000;
+		if (Number.isFinite(resetAtMs)) return resetAtMs;
+	}
+	if (window.resetAfterSeconds !== undefined) {
+		return nowMs + window.resetAfterSeconds * 1000;
+	}
+	return undefined;
+}
+
+function buildUsageWindow(window: ParsedUsageWindow, key: string, nowMs: number): UsageWindow {
+	const resetsAt = resolveResetTime(window, nowMs);
+	if (window.limitWindowSeconds !== undefined) {
+		const { id, label } = buildWindowLabel(window.limitWindowSeconds);
+		const durationMs = window.limitWindowSeconds * 1000;
+		return { id, label, durationMs, ...(resetsAt !== undefined ? { resetsAt } : {}) };
+	}
+	const fallbackLabel = key === "primary" ? "Primary window" : "Secondary window";
+	return { id: key, label: fallbackLabel, ...(resetsAt !== undefined ? { resetsAt } : {}) };
+}
+
+function buildUsageAmount(window: ParsedUsageWindow): UsageAmount {
+	const usedPercent = window.usedPercent;
+	if (usedPercent === undefined) {
+		return { unit: "percent" };
+	}
+	const clamped = Math.min(Math.max(usedPercent, 0), 100);
+	const usedFraction = clamped / 100;
+	return {
+		used: clamped,
+		limit: 100,
+		remaining: Math.max(0, 100 - clamped),
+		usedFraction,
+		remainingFraction: Math.max(0, 1 - usedFraction),
+		unit: "percent",
+	};
+}
+
+function buildUsageStatus(usedFraction?: number, limitReached?: boolean): UsageLimit["status"] {
+	if (limitReached) return "exhausted";
+	if (usedFraction === undefined) return "unknown";
+	if (usedFraction >= 1) return "exhausted";
+	if (usedFraction >= 0.9) return "warning";
+	return "ok";
+}
+
+function buildUsageLimit(args: {
+	key: "primary" | "secondary";
+	window: ParsedUsageWindow;
+	accountId?: string;
+	planType?: string;
+	limitReached?: boolean;
+	nowMs: number;
+}): UsageLimit {
+	const usageWindow = buildUsageWindow(args.window, args.key, args.nowMs);
+	const amount = buildUsageAmount(args.window);
+	return {
+		id: `openai-codex:${args.key}`,
+		label: usageWindow.label,
+		scope: {
+			provider: "openai-codex",
+			accountId: args.accountId,
+			tier: args.planType,
+			windowId: usageWindow.id,
+			shared: true,
+		},
+		window: usageWindow,
+		amount,
+		status: buildUsageStatus(amount.usedFraction, args.limitReached),
+	};
+}
+function additionalLimitSlug(args: { limitName?: string; meteredFeature?: string }): string {
+	const probe = `${args.limitName ?? ""} ${args.meteredFeature ?? ""}`.toLowerCase();
+	if (probe.includes("spark") || probe.includes("bengalfox")) return "spark";
+	const source = (args.meteredFeature ?? args.limitName ?? "extra").toLowerCase();
+	return (
+		source
+			.replace(/^codex[-_]/, "")
+			.replace(/[^a-z0-9]+/g, "-")
+			.replace(/^-+|-+$/g, "") || "extra"
+	);
+}
+
+function additionalDisplayName(slug: string, limitName?: string): string {
+	if (slug === "spark") return "Spark";
+	if (limitName) return limitName;
+	return slug.replace(
+		/(^|-)([a-z])/g,
+		(_match, sep: string, ch: string) => `${sep === "-" ? " " : ""}${ch.toUpperCase()}`,
+	);
+}
+
+function buildAdditionalUsageLimit(args: {
+	key: "primary" | "secondary";
+	slug: string;
+	displayName: string;
+	window: ParsedUsageWindow;
+	accountId?: string;
+	limitReached?: boolean;
+	limitName?: string;
+	meteredFeature?: string;
+	nowMs: number;
+}): UsageLimit {
+	const usageWindow = buildUsageWindow(args.window, args.key, args.nowMs);
+	const amount = buildUsageAmount(args.window);
+	return {
+		id: `openai-codex:${args.slug}:${args.key}`,
+		label: `${usageWindow.label} (${args.displayName})`,
+		scope: {
+			provider: "openai-codex",
+			accountId: args.accountId,
+			tier: args.slug,
+			modelId: args.limitName,
+			windowId: usageWindow.id,
+			shared: true,
+		},
+		window: usageWindow,
+		amount,
+		status: buildUsageStatus(amount.usedFraction, args.limitReached),
+	};
+}
+
+export const openaiCodexUsageProvider: UsageProvider = {
+	id: "openai-codex",
+	supports(params: UsageFetchParams): boolean {
+		return params.provider === "openai-codex" && params.credential.type === "oauth";
+	},
+	async fetchUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+		if (params.provider !== "openai-codex") return null;
+		const { credential } = params;
+		if (credential.type !== "oauth") return null;
+
+		const accessToken = credential.accessToken;
+		if (!accessToken) return null;
+
+		const nowMs = Date.now();
+		if (credential.expiresAt !== undefined && credential.expiresAt <= nowMs) {
+			ctx.logger?.warn("Codex usage token expired", { provider: params.provider });
+			return null;
+		}
+
+		const baseUrl = normalizeCodexBaseUrl(params.baseUrl);
+		const accountId = credential.accountId ?? extractAccountId(accessToken);
+		const email = normalizeEmail(credential.email ?? extractEmail(accessToken));
+
+		const headers: Record<string, string> = {
+			Authorization: `Bearer ${accessToken}`,
+			"User-Agent": "OpenCode-Status-Plugin/1.0",
+		};
+		if (accountId) {
+			headers["ChatGPT-Account-Id"] = accountId;
+		}
+
+		const url = buildCodexUsageUrl(baseUrl);
+		let payload: unknown;
+		try {
+			const response = await ctx.fetch(url, { headers, signal: params.signal });
+			if (!response.ok) {
+				ctx.logger?.warn("Codex usage request failed", { status: response.status, provider: params.provider });
+				return null;
+			}
+			payload = await response.json();
+		} catch (error) {
+			ctx.logger?.warn("Codex usage request error", { provider: params.provider, error: String(error) });
+			return null;
+		}
+
+		const parsed = parseUsagePayload(payload);
+		const planType =
+			parsed?.planType ??
+			(isRecord(payload) && typeof payload.plan_type === "string" ? payload.plan_type : undefined);
+
+		const limits: UsageLimit[] = [];
+		if (parsed?.primary) {
+			limits.push(
+				buildUsageLimit({
+					key: "primary",
+					window: parsed.primary,
+					accountId,
+					planType,
+					limitReached: parsed.limitReached,
+					nowMs,
+				}),
+			);
+		}
+		if (parsed?.secondary) {
+			limits.push(
+				buildUsageLimit({
+					key: "secondary",
+					window: parsed.secondary,
+					accountId,
+					planType,
+					limitReached: parsed.limitReached,
+					nowMs,
+				}),
+			);
+		}
+		for (const extra of parsed?.additional ?? []) {
+			const slug = additionalLimitSlug({ limitName: extra.limitName, meteredFeature: extra.meteredFeature });
+			const displayName = additionalDisplayName(slug, extra.limitName);
+			if (extra.primary) {
+				limits.push(
+					buildAdditionalUsageLimit({
+						key: "primary",
+						slug,
+						displayName,
+						window: extra.primary,
+						accountId,
+						limitReached: extra.limitReached,
+						limitName: extra.limitName,
+						meteredFeature: extra.meteredFeature,
+						nowMs,
+					}),
+				);
+			}
+			if (extra.secondary) {
+				limits.push(
+					buildAdditionalUsageLimit({
+						key: "secondary",
+						slug,
+						displayName,
+						window: extra.secondary,
+						accountId,
+						limitReached: extra.limitReached,
+						limitName: extra.limitName,
+						meteredFeature: extra.meteredFeature,
+						nowMs,
+					}),
+				);
+			}
+		}
+
+		const resetCredits = parseResetCredits(payload);
+		if (resetCredits && resetCredits.availableCount > 0) {
+			try {
+				const list = await listCodexResetCredits({
+					accessToken,
+					accountId,
+					baseUrl: params.baseUrl,
+					fetch: ctx.fetch,
+					signal: params.signal,
+				});
+				if (list?.credits.length) {
+					resetCredits.credits = list.credits
+						.filter(c => (c.status ?? "available") === "available")
+						.map(c => ({
+							grantedAt: c.grantedAt,
+							expiresAt: c.expiresAt,
+							status: c.status,
+						}));
+				}
+				// Always sync the live count from the detail endpoint — it may report
+				// fewer or zero available credits after expiry/redeem, even when the
+				// /wham/usage payload still has a stale count.
+				if (list) {
+					resetCredits.availableCount = list.availableCount;
+				}
+			} catch (error) {
+				ctx.logger?.warn("Codex reset credits detail fetch failed", { error: String(error) });
+			}
+		}
+		const report: UsageReport = {
+			provider: "openai-codex",
+			fetchedAt: nowMs,
+			limits,
+			...(resetCredits ? { resetCredits } : {}),
+			metadata: {
+				planType,
+				allowed: parsed?.allowed,
+				limitReached: parsed?.limitReached,
+				email,
+				accountId,
+			},
+			raw: parsed?.raw ?? payload,
+		};
+
+		return report;
+	},
+};
+
+const FIVE_HOUR_MS = 5 * 60 * 60 * 1000;
+
+export const codexRankingStrategy: CredentialRankingStrategy = {
+	findWindowLimits(report) {
+		const findLimit = (key: "primary" | "secondary"): UsageLimit | undefined => {
+			const direct = report.limits.find(l => l.id === `openai-codex:${key}`);
+			if (direct) return direct;
+			const byId = report.limits.find(l => l.id.toLowerCase().includes(key));
+			if (byId) return byId;
+			const windowId = key === "secondary" ? "7d" : "1h";
+			return report.limits.find(l => l.scope.windowId?.toLowerCase() === windowId);
+		};
+		return { primary: findLimit("primary"), secondary: findLimit("secondary") };
+	},
+	windowDefaults: { primaryMs: 60 * 60 * 1000, secondaryMs: 7 * 24 * 60 * 60 * 1000 },
+	hasPriorityBoost(primary) {
+		if (!primary) return false;
+		const windowId = primary.scope.windowId?.toLowerCase();
+		const durationMs = primary.window?.durationMs;
+		const isFiveHourWindow =
+			windowId === "5h" ||
+			(typeof durationMs === "number" &&
+				Number.isFinite(durationMs) &&
+				Math.abs(durationMs - FIVE_HOUR_MS) <= 60_000);
+		if (!isFiveHourWindow) return false;
+		const usedFraction = primary.amount.usedFraction;
+		return typeof usedFraction === "number" && Number.isFinite(usedFraction) && usedFraction === 0;
+	},
+};

package/src/usage/opencode-go.ts

@@ -0,0 +1,89 @@
+import type { UsageCostHistoryEntry, UsageLimit, UsageProvider, UsageWindow } from "../usage";
+
+const OPENCODE_GO_PROVIDER = "opencode-go";
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+const OPENCODE_GO_LIMITS = [
+	{ id: "rolling-5h", label: "5 Hour", durationMs: 5 * HOUR_MS, limitUsd: 12 },
+	{ id: "weekly", label: "Weekly", durationMs: 7 * DAY_MS, limitUsd: 30 },
+	{ id: "monthly", label: "Monthly", durationMs: 30 * DAY_MS, limitUsd: 60 },
+] as const;
+
+function sumWindowCosts(entries: UsageCostHistoryEntry[], sinceMs: number): { used: number; resetsAt?: number } {
+	let used = 0;
+	let firstRecordedAt: number | undefined;
+	for (const entry of entries) {
+		if (entry.recordedAt < sinceMs) continue;
+		used += entry.costUsd;
+		if (firstRecordedAt === undefined || entry.recordedAt < firstRecordedAt) {
+			firstRecordedAt = entry.recordedAt;
+		}
+	}
+	return { used, resetsAt: firstRecordedAt };
+}
+
+function resolveStatus(usedFraction: number): UsageLimit["status"] {
+	if (usedFraction >= 1) return "exhausted";
+	if (usedFraction >= 0.8) return "warning";
+	return "ok";
+}
+
+function buildWindowLimit(
+	limit: (typeof OPENCODE_GO_LIMITS)[number],
+	entries: UsageCostHistoryEntry[],
+	nowMs: number,
+): UsageLimit {
+	const sinceMs = nowMs - limit.durationMs;
+	const windowCost = sumWindowCosts(entries, sinceMs);
+	const used = Number(windowCost.used.toFixed(6));
+	const usedFraction = used / limit.limitUsd;
+	const window: UsageWindow = {
+		id: limit.id,
+		label: limit.label,
+		durationMs: limit.durationMs,
+	};
+	if (windowCost.resetsAt !== undefined) {
+		window.resetsAt = windowCost.resetsAt + limit.durationMs;
+	}
+	return {
+		id: limit.id,
+		label: `${limit.label} limit`,
+		scope: {
+			provider: OPENCODE_GO_PROVIDER,
+			windowId: limit.id,
+		},
+		window,
+		amount: {
+			used,
+			limit: limit.limitUsd,
+			remaining: Math.max(0, limit.limitUsd - used),
+			usedFraction,
+			remainingFraction: Math.max(0, 1 - usedFraction),
+			unit: "usd",
+		},
+		status: resolveStatus(usedFraction),
+	};
+}
+
+export const opencodeGoUsageProvider: UsageProvider = {
+	id: OPENCODE_GO_PROVIDER,
+	supports: params => params.provider === OPENCODE_GO_PROVIDER && params.credential.type === "api_key",
+	validatesCredentials: false,
+	async fetchUsage(params, ctx) {
+		if (params.provider !== OPENCODE_GO_PROVIDER || params.credential.type !== "api_key") return null;
+		const nowMs = Date.now();
+		const sinceMs = nowMs - OPENCODE_GO_LIMITS[OPENCODE_GO_LIMITS.length - 1]!.durationMs;
+		const entries =
+			ctx.listUsageCosts?.({ provider: OPENCODE_GO_PROVIDER, accountKey: params.accountKey, sinceMs }) ?? [];
+		return {
+			provider: OPENCODE_GO_PROVIDER,
+			fetchedAt: nowMs,
+			limits: OPENCODE_GO_LIMITS.map(limit => buildWindowLimit(limit, entries, nowMs)),
+			notes: ["OMP-observed spend only; OpenCode usage outside OMP is not included."],
+			metadata: {
+				planType: "OpenCode Go",
+				source: "omp-observed-request-costs",
+			},
+		};
+	},
+};

package/src/usage/shared.ts

@@ -0,0 +1,10 @@
+export const toNumber = (value: unknown): number | undefined => {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed) return undefined;
+		const parsed = Number(trimmed);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+	return undefined;
+};