pi-better-openai 0.1.19 → 0.1.21

package/src/usage.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getCodexCredentials } from "./codex-auth.ts";
 export { AUTH_FILE, readCodexAuth } from "./codex-auth.ts";
 
@@ -21,6 +21,8 @@ export type CodexUsageResponse = {
 };
 
 export type UsageSnapshot = {
+  capturedAt: number;
+  scope: UsageScope;
   fiveHourLeftPercent: number | null;
   sevenDayLeftPercent: number | null;
   fiveHourResetInSeconds: number | null;
@@ -28,9 +30,42 @@ export type UsageSnapshot = {
   isLimited: boolean;
 };
 
+export type UsageScope = "default" | "spark";
+
 export const USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const SPARK_MODEL_ID = "gpt-5.3-codex-spark";
 const SPARK_LIMIT_NAME = "GPT-5.3-Codex-Spark";
+type ResetClockFormatters = {
+  time: Intl.DateTimeFormat;
+  weekday: Intl.DateTimeFormat;
+  date: Intl.DateTimeFormat;
+};
+const RESET_CLOCK_FORMATTER_CACHE_LIMIT = 4;
+const resetClockFormatters = new Map<string, ResetClockFormatters>();
+
+function currentTimeZoneKey(date: Date): string {
+  const zoneLabel = /\(([^)]+)\)$/.exec(date.toString())?.[1] ?? "";
+  return `${process.env.TZ ?? ""}:${date.getTimezoneOffset()}:${zoneLabel}`;
+}
+
+function getResetClockFormatters(now: Date, reset: Date): ResetClockFormatters {
+  const timeZoneKey = `${currentTimeZoneKey(now)}:${reset.getTimezoneOffset()}`;
+  let formatters = resetClockFormatters.get(timeZoneKey);
+  if (!formatters) {
+    formatters = {
+      time: new Intl.DateTimeFormat(undefined, { hour: "numeric", minute: "2-digit" }),
+      weekday: new Intl.DateTimeFormat(undefined, { weekday: "short" }),
+      date: new Intl.DateTimeFormat(undefined, { month: "numeric", day: "numeric" }),
+    };
+    resetClockFormatters.set(timeZoneKey, formatters);
+    while (resetClockFormatters.size > RESET_CLOCK_FORMATTER_CACHE_LIMIT) {
+      const oldestKey = resetClockFormatters.keys().next().value;
+      if (oldestKey === undefined) break;
+      resetClockFormatters.delete(oldestKey);
+    }
+  }
+  return formatters;
+}
 
 function asObject(value: unknown): Record<string, unknown> | null {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
@@ -42,12 +77,12 @@ function clampPercent(value: number): number {
 }
 
 function usedToLeftPercent(value: number | null | undefined): number | null {
-  if (typeof value !== "number" || Number.isNaN(value)) return null;
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
   return clampPercent(100 - value);
 }
 
 export function formatResetCountdown(seconds: number | null): string | null {
-  if (typeof seconds !== "number" || Number.isNaN(seconds)) return null;
+  if (typeof seconds !== "number" || !Number.isFinite(seconds)) return null;
   const total = Math.max(0, Math.round(seconds));
   const days = Math.floor(total / 86_400);
   const hours = Math.floor((total % 86_400) / 3_600);
@@ -62,15 +97,17 @@ export function formatResetCountdown(seconds: number | null): string | null {
 function formatResetClock(
   seconds: number | null,
   options?: { includeDate?: boolean },
+  now = Date.now(),
 ): string | null {
-  if (typeof seconds !== "number" || Number.isNaN(seconds)) return null;
-  const resetDate = new Date(Date.now() + Math.max(0, seconds) * 1000);
-  const now = new Date();
-  const time = resetDate.toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit" });
-  if (!options?.includeDate && resetDate.toDateString() === now.toDateString()) return time;
-  const weekday = resetDate.toLocaleDateString(undefined, { weekday: "short" });
+  if (typeof seconds !== "number" || !Number.isFinite(seconds)) return null;
+  const resetDate = new Date(now + seconds * 1000);
+  const currentDate = new Date(now);
+  const formatters = getResetClockFormatters(currentDate, resetDate);
+  const time = formatters.time.format(resetDate);
+  if (!options?.includeDate && resetDate.toDateString() === currentDate.toDateString()) return time;
+  const weekday = formatters.weekday.format(resetDate);
   if (!options?.includeDate) return `${weekday} ${time}`;
-  const date = resetDate.toLocaleDateString(undefined, { month: "numeric", day: "numeric" });
+  const date = formatters.date.format(resetDate);
   return `${weekday} ${date} ${time}`;
 }
 
@@ -78,9 +115,10 @@ function formatCompactReset(
   label: string,
   seconds: number | null,
   options?: { includeDate?: boolean },
+  now = Date.now(),
 ): string | null {
   const countdown = formatResetCountdown(seconds);
-  const clock = formatResetClock(seconds, options);
+  const clock = formatResetClock(seconds, options, now);
   return countdown && clock ? `${label} ↺ ${countdown} - ${clock}` : null;
 }
 
@@ -94,7 +132,7 @@ export async function requestCodexUsage(
 ): Promise<CodexUsageResponse | undefined> {
   const ctx = isAbortSignal(ctxOrSignal) ? undefined : ctxOrSignal;
   const requestSignal = isAbortSignal(ctxOrSignal) ? ctxOrSignal : signal;
-  const credentials = await getCodexCredentials(ctx);
+  const credentials = await getCodexCredentials(ctx, requestSignal);
   if (!credentials) return undefined;
   const response = await fetch(USAGE_URL, {
     headers: {
@@ -148,34 +186,45 @@ function findSparkRateLimitBucket(data: CodexUsageResponse): RateLimitBucket | n
   return null;
 }
 
-function getResetSeconds(window: UsageWindow | null | undefined): number | null {
-  if (typeof window?.reset_after_seconds === "number" && !Number.isNaN(window.reset_after_seconds))
+function getResetSeconds(window: UsageWindow | null | undefined, now: number): number | null {
+  if (
+    typeof window?.reset_after_seconds === "number" &&
+    Number.isFinite(window.reset_after_seconds)
+  )
     return window.reset_after_seconds;
-  if (typeof window?.reset_at !== "number" || Number.isNaN(window.reset_at)) return null;
+  if (typeof window?.reset_at !== "number" || !Number.isFinite(window.reset_at)) return null;
   const resetAtSeconds =
     window.reset_at > 100_000_000_000 ? window.reset_at / 1000 : window.reset_at;
-  return Math.max(0, resetAtSeconds - Date.now() / 1000);
+  return Math.max(0, resetAtSeconds - now / 1000);
+}
+
+export function usageScopeForModel(modelId: string | undefined): UsageScope {
+  return modelId === SPARK_MODEL_ID ? "spark" : "default";
 }
 
 export function parseUsageSnapshot(
   data: CodexUsageResponse,
   modelId: string | undefined,
+  now = Date.now(),
 ): UsageSnapshot {
+  const scope = usageScopeForModel(modelId);
   const bucket =
-    modelId === SPARK_MODEL_ID
-      ? findSparkRateLimitBucket(data)
+    scope === "spark"
+      ? (findSparkRateLimitBucket(data) ?? normalizeRateLimitBucket(data.rate_limit))
       : normalizeRateLimitBucket(data.rate_limit);
   return {
+    capturedAt: now,
+    scope,
     fiveHourLeftPercent: usedToLeftPercent(bucket?.primary_window?.used_percent),
     sevenDayLeftPercent: usedToLeftPercent(bucket?.secondary_window?.used_percent),
-    fiveHourResetInSeconds: getResetSeconds(bucket?.primary_window),
-    sevenDayResetInSeconds: getResetSeconds(bucket?.secondary_window),
+    fiveHourResetInSeconds: getResetSeconds(bucket?.primary_window, now),
+    sevenDayResetInSeconds: getResetSeconds(bucket?.secondary_window, now),
     isLimited: bucket?.limit_reached === true || bucket?.allowed === false,
   };
 }
 
 export function formatPercent(value: number | null): string {
-  return typeof value === "number" && !Number.isNaN(value)
+  return typeof value === "number" && Number.isFinite(value)
     ? `${Math.round(clampPercent(value))}%`
     : "--";
 }
@@ -183,14 +232,33 @@ export function formatPercent(value: number | null): string {
 export function formatUsageSnapshot(
   snapshot: UsageSnapshot,
   options: { showResetTimes: boolean },
+  now = Date.now(),
 ): string {
   const fiveHour = formatPercent(snapshot.fiveHourLeftPercent);
   const sevenDay = formatPercent(snapshot.sevenDayLeftPercent);
   const resets = options.showResetTimes
     ? [
-        formatCompactReset("5h", snapshot.fiveHourResetInSeconds),
-        formatCompactReset("7d", snapshot.sevenDayResetInSeconds, { includeDate: true }),
+        formatCompactReset(
+          "5h",
+          remainingResetSeconds(snapshot.fiveHourResetInSeconds, snapshot.capturedAt, now),
+          undefined,
+          now,
+        ),
+        formatCompactReset(
+          "7d",
+          remainingResetSeconds(snapshot.sevenDayResetInSeconds, snapshot.capturedAt, now),
+          { includeDate: true },
+          now,
+        ),
       ].filter((value): value is string => value !== null)
     : [];
   return `Usage: 5h: ${fiveHour} | 7d: ${sevenDay}${resets.length ? ` | ${resets.join(" | ")}` : ""}`;
 }
+
+function remainingResetSeconds(
+  seconds: number | null,
+  capturedAt: number,
+  now: number,
+): number | null {
+  return seconds === null ? null : seconds - (now - capturedAt) / 1000;
+}