pi-better-openai 0.1.18 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-openai",
-  "version": "0.1.18",
+  "version": "0.1.21",
   "description": "Personal pi extension that improves OpenAI with fast mode, usage stats, and footer polish.",
   "keywords": [
     "fast",
@@ -41,15 +41,20 @@
     "sharp": "^0.34.5"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0",
+    "@earendil-works/pi-coding-agent": "0.80.6",
+    "@earendil-works/pi-tui": "0.80.6",
+    "@types/node": "^24.13.2",
     "oxfmt": "^0.47.0",
     "oxlint": "^1.62.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": ">=0.57.0",
-    "@mariozechner/pi-tui": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   },
   "pi": {
     "extensions": [

package/src/codex-auth.ts

@@ -0,0 +1,136 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { piAgentDir } from "./paths.ts";
+
+export const AUTH_FILE = join(piAgentDir(), "auth.json");
+
+export type CodexCredentials = {
+  accessToken: string;
+  accountId: string;
+};
+
+export type CodexCredentialsWithSource = CodexCredentials & {
+  source: "modelRegistry" | "authFile";
+};
+
+function waitForSignal<T>(operation: Promise<T>, signal?: AbortSignal): Promise<T> {
+  if (!signal) return operation;
+  if (signal.aborted) return Promise.reject(signal.reason ?? new Error("Operation was aborted."));
+
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason ?? new Error("Operation was aborted."));
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+    void operation.then(
+      (value) => {
+        cleanup();
+        resolve(value);
+      },
+      (error: unknown) => {
+        cleanup();
+        reject(error);
+      },
+    );
+  });
+}
+
+function decodeBase64Url(value: string): string {
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
+  return Buffer.from(padded, "base64").toString("utf8");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function extractAccountIdFromJwt(token: string): string | undefined {
+  try {
+    const [, payload] = token.split(".");
+    if (!payload) return undefined;
+    const parsed = JSON.parse(decodeBase64Url(payload)) as unknown;
+    if (!isRecord(parsed)) return undefined;
+    const auth = parsed["https://api.openai.com/auth"];
+    if (!isRecord(auth)) return undefined;
+    const accountId = auth.chatgpt_account_id;
+    return typeof accountId === "string" && accountId.trim() ? accountId.trim() : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function parseCodexRegistryCredentials(
+  raw: string | undefined,
+): CodexCredentials | undefined {
+  const value = raw?.trim();
+  if (!value) return undefined;
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    if (isRecord(parsed)) {
+      const accessToken =
+        typeof parsed.access === "string"
+          ? parsed.access
+          : typeof parsed.token === "string"
+            ? parsed.token
+            : undefined;
+      const accountId =
+        typeof parsed.accountId === "string"
+          ? parsed.accountId
+          : typeof parsed.account_id === "string"
+            ? parsed.account_id
+            : undefined;
+      if (accessToken?.trim() && accountId?.trim())
+        return { accessToken: accessToken.trim(), accountId: accountId.trim() };
+    }
+  } catch {
+    // Plain bearer token is expected for openai-codex in pi.
+  }
+  const accountId = extractAccountIdFromJwt(value);
+  return accountId ? { accessToken: value, accountId } : undefined;
+}
+
+export function readCodexAuth(): CodexCredentials | undefined {
+  try {
+    const auth = JSON.parse(readFileSync(AUTH_FILE, "utf8")) as Record<
+      string,
+      | {
+          type?: string;
+          access?: string | null;
+          accountId?: string | null;
+          account_id?: string | null;
+          expires?: number | null;
+        }
+      | undefined
+    >;
+    const entry = auth["openai-codex"];
+    if (entry?.type !== "oauth") return undefined;
+    if (typeof entry.expires === "number" && Date.now() >= entry.expires) return undefined;
+    const accessToken = entry.access?.trim();
+    const accountId = (entry.accountId ?? entry.account_id)?.trim();
+    return accessToken && accountId ? { accessToken, accountId } : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function getCodexCredentials(
+  ctx?: Pick<ExtensionContext, "modelRegistry">,
+  signal?: AbortSignal,
+): Promise<CodexCredentialsWithSource | undefined> {
+  if (signal?.aborted) throw signal.reason ?? new Error("Operation was aborted.");
+  const registryRequest = ctx?.modelRegistry?.getApiKeyForProvider("openai-codex");
+  const registryToken = registryRequest
+    ? await waitForSignal(
+        registryRequest.catch(() => undefined),
+        signal,
+      )
+    : undefined;
+  const registryCredentials = parseCodexRegistryCredentials(registryToken);
+  if (registryCredentials) return { ...registryCredentials, source: "modelRegistry" };
+  const auth = readCodexAuth();
+  return auth ? { ...auth, source: "authFile" } : undefined;
+}

package/src/config.ts

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { CONFIG_BASENAME, logPrefix } from "./identity.ts";
+import { piAgentDir } from "./paths.ts";
 
 export const FOOTER_MODES = ["replace", "status", "off"] as const;
 export const IMAGE_SAVE_MODES = ["none", "project", "global", "custom"] as const;
@@ -145,14 +146,274 @@ export const DEFAULT_CONFIG: ConfigFile = {
   pets: DEFAULT_PET_CONFIG,
 };
 
+export type SettingsOptionSection = "root" | "usage" | "footer" | "image" | "pets";
+
+export type SettingsValueContext = {
+  petEmptyValue?: string;
+};
+
+export type SettingsOptionDescriptor = {
+  id: string;
+  section: SettingsOptionSection;
+  key: string;
+  label: string;
+  description: string;
+  values?: readonly string[];
+  parse(rawValue: string, context?: SettingsValueContext): boolean | number | string;
+  currentValue(cfg: ResolvedConfig): string;
+};
+
+const booleanSetting = (rawValue: string): boolean => rawValue === "true";
+const numberSetting = (rawValue: string): number => Number(rawValue);
+const stringSetting = (rawValue: string): string => rawValue;
+
+export const FAST_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
+  {
+    id: "persistState",
+    section: "root",
+    key: "persistState",
+    label: "Persist fast state",
+    currentValue: (cfg) => String(cfg.persistState),
+    values: ["true", "false"],
+    description: "Remember fast-mode state across sessions.",
+    parse: booleanSetting,
+  },
+];
+
+export const FOOTER_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
+  {
+    id: "footer.mode",
+    section: "footer",
+    key: "mode",
+    label: "Footer mode",
+    currentValue: (cfg) => cfg.footer.mode,
+    values: FOOTER_MODES,
+    description:
+      "replace = custom footer, status = pi footer plus status line, off = no Better OpenAI footer/status unless Footer pet is enabled.",
+    parse: stringSetting,
+  },
+];
+
+export const USAGE_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
+  {
+    id: "usage.enabled",
+    section: "usage",
+    key: "enabled",
+    label: "Usage display",
+    currentValue: (cfg) => String(cfg.usage.enabled),
+    values: ["true", "false"],
+    description: "Fetch and display OpenAI subscription usage windows.",
+    parse: booleanSetting,
+  },
+  {
+    id: "usage.refreshIntervalMs",
+    section: "usage",
+    key: "refreshIntervalMs",
+    label: "Usage refresh",
+    currentValue: (cfg) => String(cfg.usage.refreshIntervalMs),
+    values: ["15000", "30000", "60000", "120000", "300000", "600000"],
+    description: "Usage refresh interval in milliseconds.",
+    parse: numberSetting,
+  },
+  {
+    id: "usage.showOnlyOnSubscriptionModels",
+    section: "usage",
+    key: "showOnlyOnSubscriptionModels",
+    label: "Usage only on OAuth",
+    currentValue: (cfg) => String(cfg.usage.showOnlyOnSubscriptionModels),
+    values: ["true", "false"],
+    description: "Only show usage when the current OpenAI model uses subscription/OAuth auth.",
+    parse: booleanSetting,
+  },
+  {
+    id: "usage.showResetTimes",
+    section: "usage",
+    key: "showResetTimes",
+    label: "Usage reset times",
+    currentValue: (cfg) => String(cfg.usage.showResetTimes),
+    values: ["true", "false"],
+    description: "Include compact reset countdowns and local reset times.",
+    parse: booleanSetting,
+  },
+];
+
+export const IMAGE_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
+  {
+    id: "image.enabled",
+    section: "image",
+    key: "enabled",
+    label: "Image tool",
+    currentValue: (cfg) => String(cfg.image.enabled),
+    values: ["true", "false"],
+    description: "Allow the openai_image tool to make image requests.",
+    parse: booleanSetting,
+  },
+  {
+    id: "image.defaultModel",
+    section: "image",
+    key: "defaultModel",
+    label: "Image model",
+    currentValue: (cfg) => cfg.image.defaultModel,
+    values: ["gpt-5.5", "gpt-5.4", "gpt-5.2", "gpt-5"],
+    description: "Mainline model used for image generation when current model is not openai-codex.",
+    parse: stringSetting,
+  },
+  {
+    id: "image.defaultSave",
+    section: "image",
+    key: "defaultSave",
+    label: "Image save",
+    currentValue: (cfg) => cfg.image.defaultSave,
+    values: IMAGE_SAVE_MODES,
+    description: "Where generated images are saved by default.",
+    parse: stringSetting,
+  },
+  {
+    id: "image.outputFormat",
+    section: "image",
+    key: "outputFormat",
+    label: "Image format",
+    currentValue: (cfg) => cfg.image.outputFormat,
+    values: IMAGE_OUTPUT_FORMATS,
+    description: "Generated image file format.",
+    parse: stringSetting,
+  },
+  {
+    id: "image.timeoutMs",
+    section: "image",
+    key: "timeoutMs",
+    label: "Image timeout",
+    currentValue: (cfg) => String(cfg.image.timeoutMs),
+    values: ["30000", "60000", "120000", "180000", "300000"],
+    description: "Image request timeout in milliseconds.",
+    parse: numberSetting,
+  },
+];
+
+export const PET_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
+  {
+    id: "pets.enabled",
+    section: "pets",
+    key: "enabled",
+    label: "Enabled",
+    currentValue: (cfg) => String(cfg.pets.enabled),
+    values: ["true", "false"],
+    description:
+      "Render a custom Codex pet from ${CODEX_HOME:-~/.codex}/pets in the Better OpenAI footer.",
+    parse: booleanSetting,
+  },
+  {
+    id: "pets.slug",
+    section: "pets",
+    key: "slug",
+    label: "Pet",
+    currentValue: (cfg) => cfg.pets.slug,
+    description: "Selected custom pet slug.",
+    parse: (rawValue, context) =>
+      rawValue === (context?.petEmptyValue ?? "not selected") ? "" : rawValue,
+  },
+  {
+    id: "pets.placement",
+    section: "pets",
+    key: "placement",
+    label: "Placement",
+    currentValue: (cfg) => cfg.pets.placement,
+    values: PET_PLACEMENTS,
+    description: "Footer layout: stacked, inline-left, inline-right, badge, or habitat divider.",
+    parse: stringSetting,
+  },
+  {
+    id: "pets.state",
+    section: "pets",
+    key: "state",
+    label: "Idle state",
+    currentValue: (cfg) => cfg.pets.state,
+    values: PET_STATES,
+    description: "Animation row to show when pi is idle.",
+    parse: stringSetting,
+  },
+  {
+    id: "pets.thinkingState",
+    section: "pets",
+    key: "thinkingState",
+    label: "Thinking state",
+    currentValue: (cfg) => cfg.pets.thinkingState,
+    values: PET_STATES,
+    description: "Animation row to show while the model is thinking or streaming.",
+    parse: stringSetting,
+  },
+  {
+    id: "pets.toolState",
+    section: "pets",
+    key: "toolState",
+    label: "Tool state",
+    currentValue: (cfg) => cfg.pets.toolState,
+    values: PET_STATES,
+    description: "Animation row to show during tool execution.",
+    parse: stringSetting,
+  },
+  {
+    id: "pets.failedToolState",
+    section: "pets",
+    key: "failedToolState",
+    label: "Failed tool state",
+    currentValue: (cfg) => cfg.pets.failedToolState,
+    values: PET_STATES,
+    description: "Animation row to flash after any tool call returns an error.",
+    parse: stringSetting,
+  },
+  {
+    id: "pets.idleEmotes",
+    section: "pets",
+    key: "idleEmotes",
+    label: "Random idle emotes",
+    currentValue: (cfg) => String(cfg.pets.idleEmotes),
+    values: ["true", "false"],
+    description: "Occasionally flash a wave or jump while pi is idle.",
+    parse: booleanSetting,
+  },
+  {
+    id: "pets.idleEmoteIntervalMs",
+    section: "pets",
+    key: "idleEmoteIntervalMs",
+    label: "Idle emote interval",
+    currentValue: (cfg) => String(cfg.pets.idleEmoteIntervalMs),
+    values: ["5000", "15000", "30000", "60000", "120000", "300000"],
+    description: "Average delay between random idle pet emotes in milliseconds.",
+    parse: numberSetting,
+  },
+  {
+    id: "pets.sizeCells",
+    section: "pets",
+    key: "sizeCells",
+    label: "Size",
+    currentValue: (cfg) => String(cfg.pets.sizeCells),
+    values: ["4", "6", "8", "10", "12", "16"],
+    description: "Pet image width in terminal cells.",
+    parse: numberSetting,
+  },
+];
+
+export const SETTINGS_OPTION_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
+  ...FAST_SETTING_DESCRIPTORS,
+  ...FOOTER_SETTING_DESCRIPTORS,
+  ...USAGE_SETTING_DESCRIPTORS,
+  ...IMAGE_SETTING_DESCRIPTORS,
+  ...PET_SETTING_DESCRIPTORS,
+];
+
+const SETTINGS_OPTION_BY_ID = new Map(
+  SETTINGS_OPTION_DESCRIPTORS.map((descriptor) => [descriptor.id, descriptor]),
+);
+
 export function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-export function configPaths(cwd: string, home = homedir()) {
+export function configPaths(cwd: string, home = homedir(), env = process.env) {
   return {
     project: join(cwd, ".pi", "extensions", CONFIG_BASENAME),
-    global: join(home, ".pi", "agent", "extensions", CONFIG_BASENAME),
+    global: join(piAgentDir(env, home), "extensions", CONFIG_BASENAME),
   };
 }
 
@@ -276,6 +537,40 @@ export function readConfig(path: string): ConfigFile | undefined {
   return config;
 }
 
+export type SettingPatchContext = SettingsValueContext & {
+  persistState?: boolean;
+  active?: boolean;
+  desiredActive?: boolean;
+};
+
+export function applySettingToRawConfig(
+  current: Record<string, unknown>,
+  id: string,
+  rawValue: string,
+  context: SettingPatchContext = {},
+): Record<string, unknown> {
+  const next: Record<string, unknown> = { ...current };
+  const bool = rawValue === "true";
+  if (id === "fast.enabled") {
+    if (context.persistState) {
+      next.active = context.active ?? bool;
+      next.desiredActive = context.desiredActive ?? bool;
+    }
+  } else {
+    const descriptor = SETTINGS_OPTION_BY_ID.get(id);
+    if (!descriptor) return next;
+    const parsedValue = descriptor.parse(rawValue, context);
+    if (descriptor.section === "root") next[descriptor.key] = parsedValue;
+    else {
+      const currentSection = next[descriptor.section];
+      const section = isRecord(currentSection) ? { ...currentSection } : {};
+      section[descriptor.key] = parsedValue;
+      next[descriptor.section] = section;
+    }
+  }
+  return next;
+}
+
 export function writeConfig(path: string, config: ConfigFile | Record<string, unknown>): void {
   try {
     mkdirSync(dirname(path), { recursive: true });

package/src/fast-controller.ts

@@ -0,0 +1,109 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ResolvedConfig, SupportedModel } from "./config.ts";
+import { isRecord } from "./config.ts";
+
+export function currentModelKey(ctx: ExtensionContext): string {
+  return ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "none";
+}
+
+export function supportsFast(ctx: ExtensionContext, supportedModels: SupportedModel[]): boolean {
+  const current = ctx.model;
+  if (!current) return false;
+  return supportedModels.some(
+    (model) => model.provider === current.provider && model.id === current.id,
+  );
+}
+
+export function modelList(supportedModels: SupportedModel[]): string {
+  return supportedModels.length > 0
+    ? supportedModels.map((model) => `${model.provider}/${model.id}`).join(", ")
+    : "none configured";
+}
+
+export function fastStateText(
+  ctx: ExtensionContext,
+  desiredActive: boolean,
+  active: boolean,
+  supportedModels: SupportedModel[],
+): string {
+  const model = currentModelKey(ctx);
+  if (active) return `Fast mode is on for ${model}.`;
+  if (desiredActive) {
+    return `Fast mode is requested, but inactive for unsupported model ${model}. Supported models: ${modelList(supportedModels)}.`;
+  }
+  return `Fast mode is off. Current model: ${model}.`;
+}
+
+export class FastController {
+  desiredActive = false;
+  active = false;
+  private lastInjectedAt: number | undefined;
+  private lastInjectedModel: string | undefined;
+  private lastInjectedTier: string | undefined;
+
+  constructor(private readonly serviceTier: string) {}
+
+  applyDesiredState(ctx: ExtensionContext, cfg: ResolvedConfig): void {
+    this.active = this.desiredActive && supportsFast(ctx, cfg.supportedModels);
+  }
+
+  initializeForSession(ctx: ExtensionContext, cfg: ResolvedConfig, flagActive: boolean): void {
+    this.desiredActive = cfg.persistState ? cfg.desiredActive : false;
+    if (flagActive) this.desiredActive = true;
+    this.applyDesiredState(ctx, cfg);
+  }
+
+  setDesired(ctx: ExtensionContext, cfg: ResolvedConfig, next: boolean): void {
+    this.desiredActive = next;
+    this.applyDesiredState(ctx, cfg);
+  }
+
+  stateText(ctx: ExtensionContext, cfg: ResolvedConfig): string {
+    return fastStateText(ctx, this.desiredActive, this.active, cfg.supportedModels);
+  }
+
+  unsupportedRequestMessage(ctx: ExtensionContext, cfg: ResolvedConfig): string {
+    return `Fast mode requested, but ${currentModelKey(ctx)} is unsupported. It will activate automatically when you switch to a supported model: ${modelList(cfg.supportedModels)}.`;
+  }
+
+  inactiveForModelMessage(ctx: ExtensionContext): string {
+    return `Fast mode inactive for unsupported model ${currentModelKey(ctx)}.`;
+  }
+
+  settingsSummary(ctx: ExtensionContext, cfg: ResolvedConfig): string {
+    if (this.active) return "on";
+    if (this.desiredActive)
+      return supportsFast(ctx, cfg.supportedModels) ? "requested" : "requested inactive";
+    return "off";
+  }
+
+  statusSegment(ctx: ExtensionContext, cfg: ResolvedConfig): string | undefined {
+    return this.active && supportsFast(ctx, cfg.supportedModels)
+      ? `${ctx.model?.id ?? "model"} fast`
+      : undefined;
+  }
+
+  injectProviderPayload(
+    event: { payload?: unknown },
+    ctx: ExtensionContext,
+    cfg: ResolvedConfig,
+  ): unknown {
+    if (!this.active || !supportsFast(ctx, cfg.supportedModels) || !isRecord(event.payload))
+      return undefined;
+    this.lastInjectedAt = Date.now();
+    this.lastInjectedModel = currentModelKey(ctx);
+    this.lastInjectedTier = this.serviceTier;
+    return { ...event.payload, service_tier: this.serviceTier };
+  }
+
+  debugLines(ctx: ExtensionContext, cfg: ResolvedConfig): string[] {
+    return [
+      `Fast desired: ${this.desiredActive}`,
+      `Fast active: ${this.active}`,
+      `Current model: ${currentModelKey(ctx)}`,
+      `Supported model: ${supportsFast(ctx, cfg.supportedModels)}`,
+      `Configured service_tier: ${this.serviceTier}`,
+      `Last injected: ${this.lastInjectedAt ? `${new Date(this.lastInjectedAt).toLocaleTimeString()} (${this.lastInjectedModel}, ${this.lastInjectedTier})` : "never"}`,
+    ];
+  }
+}