@monotykamary/pi-better-openai 0.1.42 → 0.1.44

package/index.ts

@@ -4,7 +4,12 @@
  * Adds `service_tier: "priority"` to OpenAI provider payloads while fast mode is
  * enabled and the selected model is in the configured allow-list.
  */
-import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  type ExtensionAPI,
+  type ExtensionContext,
+  type Theme,
+  type ThemeColor,
+} from "@earendil-works/pi-coding-agent";
 import {
   Container,
   Key,
@@ -58,12 +63,12 @@ import {
   applySettingToRawConfig,
 } from "./src/config.ts";
 import {
+  type UsageSegment,
+  type UsageSeverity,
   formatPercent,
   formatUsageSnapshot,
   parseUsageSnapshot,
   readCodexAuth,
-  requestCodexUsage,
-  type UsageSnapshot,
 } from "./src/usage.ts";
 import {
   buildBankedResetConfirmation,
@@ -71,10 +76,9 @@ import {
   formatBankedResetChoice,
   formatConsumeOutcome,
   newRedeemRequestId,
-  requestBankedResetCredits,
   selectBankedResetCredit,
-  type BankedResetCredits,
 } from "./src/resets.ts";
+import { ResetController } from "./src/reset-controller.ts";
 import { registerOpenAIImage, _imageTest } from "./src/image.ts";
 import { registerOpenAIWebSearch, _websearchTest } from "./src/websearch.ts";
 import { registerOpenAILive } from "./src/live/index.ts";
@@ -90,7 +94,7 @@ import {
   _petsTest,
 } from "./src/pets.ts";
 import { FastController, modelList, supportsFast } from "./src/fast-controller.ts";
-import { UsageController } from "./src/usage-controller.ts";
+import { isOpenAISubscriptionModel, UsageController } from "./src/usage-controller.ts";
 import { PetFooterController } from "./src/pet-footer-controller.ts";
 import {
   abbreviateHomePath,
@@ -117,6 +121,46 @@ const requireSettingsListTheme = (): SettingsListTheme => {
   return loadedSettingsListTheme;
 };
 
+const USAGE_SEVERITY_COLORS: Record<UsageSeverity, ThemeColor> = {
+  ok: "success",
+  warning: "warning",
+  critical: "error",
+  muted: "dim",
+};
+
+/**
+ * Keep a coloured segment on one line. Unlike sanitizeStatusText this leaves the
+ * spacing shared by neighbouring segments ("Usage: " + "5h: " + "90%") intact.
+ */
+function flattenSegment(text: string): string {
+  return text.replace(/[\r\n\t]+/g, " ");
+}
+
+/**
+ * Colour a usage line segment by segment: the percentages carry the severity
+ * colour while the labels, countdowns and banked resets stay dim.
+ */
+function colorizeUsageSegments(segments: UsageSegment[], theme: Theme): string {
+  return segments
+    .map((segment) =>
+      theme.fg(USAGE_SEVERITY_COLORS[segment.severity], flattenSegment(segment.text)),
+    )
+    .join("");
+}
+
+/** Pair the fast-mode segment with the usage segments for the status widget. */
+function statusWidgetParts(
+  fast: string | undefined,
+  usage: UsageSegment[] | undefined,
+): UsageSegment[] | undefined {
+  const parts: UsageSegment[] = fast ? [{ text: fast, severity: "muted" }] : [];
+  if (usage?.length) {
+    if (parts.length > 0) parts.push({ text: " · ", severity: "muted" });
+    parts.push(...usage);
+  }
+  return parts.length > 0 ? parts : undefined;
+}
+
 class DynamicBorder {
   readonly #color: (text: string) => string;
 
@@ -247,6 +291,7 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
   let cachedSessionNameLeafId: string | null | undefined;
   let cachedSessionName: string | undefined;
   const usageController = new UsageController(config, updateFooter);
+  const resetController = new ResetController();
   const petController = new PetFooterController(config, updateFooter, () => footerInstalled);
   let multiproviderService: MultiproviderService | undefined;
   let unsubscribeMultiprovider: (() => void) | undefined;
@@ -265,6 +310,7 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
       setActiveMultiproviderService(value);
       unsubscribeMultiprovider = value.onActiveAccountChanged(CODEX_PROVIDER_ID, (event) => {
         void usageController.refresh(event.ctx, undefined, { force: true });
+        void resetController.refresh(event.ctx, { force: true }).catch(() => {});
         updateFooter(event.ctx);
       });
       const ctx = multiproviderRefreshCtx;
@@ -402,27 +448,18 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
       ctx.ui.notify("/openai-resets requires an interactive TUI session.", "warning");
       return;
     }
-    const timeoutSignal = AbortSignal.timeout(15_000);
-    const signal = ctx.signal ? AbortSignal.any([ctx.signal, timeoutSignal]) : timeoutSignal;
-    let credits: BankedResetCredits | undefined;
-    let snapshot: UsageSnapshot | undefined;
-    try {
-      const [creditResult, usageResult] = await Promise.all([
-        requestBankedResetCredits(ctx, signal),
-        requestCodexUsage(ctx, signal).catch(() => undefined),
-      ]);
-      credits = creditResult;
-      snapshot = usageResult ? parseUsageSnapshot(usageResult, ctx.model?.id) : undefined;
-    } catch (error) {
-      ctx.ui.notify(
-        `Banked reset lookup failed: ${sanitizeDiagnosticError(
-          error instanceof Error ? error.message : String(error),
-        )}`,
-        "error",
-      );
+    let credits = resetController.snapshot?.credits;
+    if (!credits) {
+      await resetController.refresh(ctx, { force: true }).catch(() => {});
+      credits = resetController.snapshot?.credits;
+    }
+    if (!credits) {
+      const reason = resetController.lastError;
+      ctx.ui.notify(`Banked reset lookup failed${reason ? `: ${reason}` : "."}`, "error");
       return;
     }
-    if (!credits || credits.availableCount <= 0) {
+    void resetController.refresh(ctx).catch(() => {});
+    if (credits.availableCount <= 0) {
       ctx.ui.notify("No banked Codex resets are available for this account.", "info");
       return;
     }
@@ -440,17 +477,20 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     const confirmation = buildBankedResetConfirmation({
       credit: selected,
       availableCount: credits.availableCount,
-      snapshot,
+      snapshot: usageController.snapshot,
     });
     if (!(await ctx.ui.confirm(confirmation.title, confirmation.message))) {
       ctx.ui.notify("Banked reset redemption cancelled.", "info");
       return;
     }
     try {
+      const timeoutSignal = AbortSignal.timeout(15_000);
+      const signal = ctx.signal ? AbortSignal.any([ctx.signal, timeoutSignal]) : timeoutSignal;
       const result = await consumeBankedReset(ctx, selected?.id, newRedeemRequestId(), signal);
       const outcome = formatConsumeOutcome(result);
       ctx.ui.notify(outcome.message, outcome.level);
       void usageController.refresh(ctx, ctx.model?.id, { force: true });
+      void resetController.refresh(ctx, { force: true }).catch(() => {});
       updateFooter(ctx);
     } catch (error) {
       ctx.ui.notify(
@@ -1195,8 +1235,10 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
           const petColumnWidth = Math.min(petRenderSizeCells, Math.max(1, width - 1));
           const footerTextWidth = inlinePet ? Math.max(1, width - petColumnWidth - 2) : width;
 
-          const usageStatusLine = usageController.statusLine(ctx, cfg, usingSubscription);
-          const usageLine = usageStatusLine ? theme.fg("dim", usageStatusLine) : undefined;
+          const usageStatusSegments = usageController.statusSegments(ctx, cfg, usingSubscription);
+          const usageLine = usageStatusSegments
+            ? colorizeUsageSegments(usageStatusSegments, theme)
+            : undefined;
 
           let statsLeft = parts.join(" ");
           let statsLeftWidth = visibleWidth(statsLeft);
@@ -1322,22 +1364,22 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     statusInstalled = text !== undefined;
   }
 
-  function setStatusWidget(ctx: ExtensionContext, text: string | undefined): void {
-    if (!text && !statusWidgetInstalled) return;
+  function setStatusWidget(ctx: ExtensionContext, parts: UsageSegment[] | undefined): void {
+    if (!parts && !statusWidgetInstalled) return;
     ctx.ui.setWidget(
       STATUS_KEY,
-      text
+      parts
         ? (_tui, theme) => ({
             invalidate() {},
             render(width: number): string[] {
-              const line = theme.fg("dim", sanitizeStatusText(text));
+              const line = colorizeUsageSegments(parts, theme);
               return [truncateToWidth(line, width, theme.fg("dim", "..."))];
             },
           })
         : undefined,
       { placement: "belowEditor" },
     );
-    statusWidgetInstalled = text !== undefined;
+    statusWidgetInstalled = parts !== undefined;
   }
 
   function updateFooter(ctx: ExtensionContext): void {
@@ -1373,8 +1415,8 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     }
 
     const fast = fastController.statusSegment(ctx, cfg);
-    const usage = usageController.statusLine(ctx, cfg);
-    setStatusWidget(ctx, [fast, usage].filter(Boolean).join(" · ") || undefined);
+    const usage = usageController.statusSegments(ctx, cfg);
+    setStatusWidget(ctx, statusWidgetParts(fast, usage));
   }
 
   pi.on("session_start", (_event, ctx) => {
@@ -1393,6 +1435,8 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     updateFooter(ctx);
     if (hasTerminalUI(ctx) && nextConfig.pets.enabled) void petController.refresh(ctx, nextConfig);
     usageController.start(ctx);
+    if (nextConfig.usage.enabled && isOpenAISubscriptionModel(ctx, nextConfig))
+      resetController.start(ctx);
     if (fastController.active) ctx.ui.notify(fastController.stateText(ctx, nextConfig), "info");
   });
 
@@ -1469,6 +1513,7 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     invalidateSessionName();
     multiproviderRefreshCtx = undefined;
     usageController.shutdown();
+    resetController.stop();
     petController.shutdown();
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-better-openai",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "description": "Improve OpenAI in pi with fast mode, usage stats, realtime voice, image generation, and footer polish.",
   "keywords": [
     "fast",

package/src/reset-controller.ts

@@ -0,0 +1,97 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { sanitizeDiagnosticError } from "./format.ts";
+import { type BankedResetCredits, requestBankedResetCredits } from "./resets.ts";
+
+export const BANKED_RESET_CACHE_TTL_MS = 5 * 60_000;
+const BANKED_RESET_REQUEST_TIMEOUT_MS = 10_000;
+
+export type BankedResetCache = {
+  credits: BankedResetCredits;
+  updatedAt: number;
+};
+
+// Keeps the banked-reset credit list warm so /openai-resets opens without
+// paying the credential-resolution + wham round trip. The cache is prefetched
+// at session start, refreshed on a TTL, and served even when stale (a stale
+// open still kicks off a background refresh; the backend re-validates every
+// redemption server-side, so a stale offer can never be consumed twice).
+export class ResetController {
+  private cache: BankedResetCache | undefined;
+  private error: string | undefined;
+  private lastFetchAt: number | undefined;
+  private inFlight: Promise<void> | undefined;
+  private timer: ReturnType<typeof setInterval> | undefined;
+  private sessionSignal: AbortSignal | undefined;
+  private sessionAbortHandler: (() => void) | undefined;
+
+  get snapshot(): BankedResetCache | undefined {
+    return this.cache;
+  }
+
+  get lastError(): string | undefined {
+    return this.error;
+  }
+
+  isFresh(now = Date.now()): boolean {
+    return this.cache !== undefined && now - this.cache.updatedAt < BANKED_RESET_CACHE_TTL_MS;
+  }
+
+  refresh(ctx: ExtensionContext, options?: { force?: boolean }): Promise<void> {
+    if (this.inFlight) return this.inFlight;
+    if (
+      !options?.force &&
+      this.lastFetchAt !== undefined &&
+      Date.now() - this.lastFetchAt < BANKED_RESET_CACHE_TTL_MS
+    )
+      return Promise.resolve();
+    this.lastFetchAt = Date.now();
+    const timeoutSignal = AbortSignal.timeout(BANKED_RESET_REQUEST_TIMEOUT_MS);
+    const signal = ctx.signal ? AbortSignal.any([ctx.signal, timeoutSignal]) : timeoutSignal;
+    const task = (async () => {
+      try {
+        const credits = await requestBankedResetCredits(ctx, signal);
+        if (credits) {
+          this.cache = { credits, updatedAt: Date.now() };
+          this.error = undefined;
+        } else {
+          this.error = "OpenAI Codex credentials unavailable.";
+        }
+      } catch (error) {
+        this.error = sanitizeDiagnosticError(
+          error instanceof Error ? error.message : String(error),
+        );
+      } finally {
+        this.inFlight = undefined;
+      }
+    })();
+    this.inFlight = task;
+    return task;
+  }
+
+  start(ctx: ExtensionContext): void {
+    this.stop();
+    if (ctx.signal?.aborted) return;
+    this.sessionSignal = ctx.signal;
+    this.sessionAbortHandler = () => this.stop();
+    ctx.signal?.addEventListener("abort", this.sessionAbortHandler, { once: true });
+    void this.refresh(ctx).catch(() => {});
+    this.timer = setInterval(() => {
+      if (ctx.signal?.aborted) {
+        this.stop();
+        return;
+      }
+      void this.refresh(ctx).catch(() => {});
+    }, BANKED_RESET_CACHE_TTL_MS);
+    this.timer.unref?.();
+  }
+
+  stop(): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = undefined;
+    if (this.sessionSignal && this.sessionAbortHandler) {
+      this.sessionSignal.removeEventListener("abort", this.sessionAbortHandler);
+    }
+    this.sessionSignal = undefined;
+    this.sessionAbortHandler = undefined;
+  }
+}

package/src/usage-controller.ts

@@ -3,6 +3,7 @@ import type { ResolvedConfig } from "./config.ts";
 import { maskIdentifier, sanitizeDiagnosticError } from "./format.ts";
 import {
   AUTH_FILE,
+  type UsageSegment,
   type UsageSnapshot,
   formatResetCountdown,
   formatUsageSnapshot,
@@ -10,6 +11,7 @@ import {
   readCodexAuth,
   requestCodexUsage,
   usageScopeForModel,
+  usageSegments,
 } from "./usage.ts";
 import { currentModelKey } from "./fast-controller.ts";
 
@@ -70,20 +72,30 @@ export class UsageController {
     return this.usageSnapshot;
   }
 
-  statusLine(
+  statusSegments(
     ctx: ExtensionContext,
     cfg = this.getConfig(ctx),
     isUsingOAuth?: boolean,
-  ): string | undefined {
+  ): UsageSegment[] | undefined {
     return this.usageSnapshot &&
       !this.usageError &&
       this.usageSnapshot.scope === usageScopeForModel(ctx.model?.id) &&
       cfg.usage.enabled &&
       isOpenAISubscriptionModel(ctx, cfg, isUsingOAuth)
-      ? formatUsageSnapshot(this.usageSnapshot, cfg.usage)
+      ? usageSegments(this.usageSnapshot, cfg.usage)
       : undefined;
   }
 
+  statusLine(
+    ctx: ExtensionContext,
+    cfg = this.getConfig(ctx),
+    isUsingOAuth?: boolean,
+  ): string | undefined {
+    return this.statusSegments(ctx, cfg, isUsingOAuth)
+      ?.map((segment) => segment.text)
+      .join("");
+  }
+
   formatStatus(ctx: ExtensionContext): string {
     const cfg = this.getConfig(ctx);
     if (!cfg.usage.enabled) return "Usage display is disabled.";

package/src/usage.ts

@@ -253,11 +253,29 @@ export function formatPercent(value: number | null): string {
     : "--";
 }
 
-export function formatUsageSnapshot(
+export type UsageSeverity = "ok" | "warning" | "critical" | "muted";
+
+export type UsageSegment = {
+  text: string;
+  severity: UsageSeverity;
+};
+
+/** Remaining budget at or below these thresholds turns the percentage amber/red. */
+const WARNING_LEFT_PERCENT = 30;
+const CRITICAL_LEFT_PERCENT = 10;
+
+export function severityForLeftPercent(percent: number | null): UsageSeverity {
+  if (percent === null) return "muted";
+  if (percent <= CRITICAL_LEFT_PERCENT) return "critical";
+  if (percent <= WARNING_LEFT_PERCENT) return "warning";
+  return "ok";
+}
+
+export function usageSegments(
   snapshot: UsageSnapshot,
   options: { showResetTimes: boolean; showBankedResets?: boolean },
   now = Date.now(),
-): string {
+): UsageSegment[] {
   const windows = [
     {
       label: "5h",
@@ -276,24 +294,41 @@ export function formatUsageSnapshot(
     (window) => window.percent !== null || window.resetSeconds !== null,
   );
   const displayedWindows = availableWindows.length > 0 ? availableWindows : windows;
-  const usage = displayedWindows
-    .map((window) => `${window.label}: ${formatPercent(window.percent)}`)
-    .join(" · ");
-  const resets = options.showResetTimes
-    ? displayedWindows
-        .map((window) =>
-          formatCompactReset(
-            displayedWindows.length > 1 ? window.label : undefined,
-            remainingResetSeconds(window.resetSeconds, snapshot.capturedAt, now),
-            window.includeDate ? { includeDate: true } : undefined,
-            now,
-          ),
-        )
-        .filter((value): value is string => value !== null)
-    : [];
+  const segments: UsageSegment[] = [{ text: "Usage: ", severity: "muted" }];
+  displayedWindows.forEach((window, index) => {
+    if (index > 0) segments.push({ text: " · ", severity: "muted" });
+    segments.push({ text: `${window.label}: `, severity: "muted" });
+    segments.push({
+      text: formatPercent(window.percent),
+      severity: severityForLeftPercent(window.percent),
+    });
+  });
+  if (options.showResetTimes) {
+    for (const window of displayedWindows) {
+      const reset = formatCompactReset(
+        displayedWindows.length > 1 ? window.label : undefined,
+        remainingResetSeconds(window.resetSeconds, snapshot.capturedAt, now),
+        window.includeDate ? { includeDate: true } : undefined,
+        now,
+      );
+      if (reset) segments.push({ text: ` · ${reset}`, severity: "muted" });
+    }
+  }
   const banked =
     options.showBankedResets === false ? null : formatBankedResetsSuffix(snapshot.bankedResets);
-  return `Usage: ${usage}${resets.length ? ` · ${resets.join(" · ")}` : ""}${banked ? ` · ${banked}` : ""}`;
+  if (banked) segments.push({ text: ` · ${banked}`, severity: "muted" });
+  return segments;
+}
+
+/** Flat text form of {@link usageSegments}, used for status lines and notifications. */
+export function formatUsageSnapshot(
+  snapshot: UsageSnapshot,
+  options: { showResetTimes: boolean; showBankedResets?: boolean },
+  now = Date.now(),
+): string {
+  return usageSegments(snapshot, options, now)
+    .map((segment) => segment.text)
+    .join("");
 }
 
 export function formatBankedResetsSuffix(count: number | null): string | null {