@diousk/pi-usage-fast 0.1.0

package/src/usage-settings-ui.ts

@@ -0,0 +1,152 @@
+import { stripVTControlCharacters } from "node:util";
+import { type ExtensionCommandContext, getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, type SettingItem, SettingsList, Text } from "@earendil-works/pi-tui";
+import { errorMessage } from "./core.js";
+import type { UsageSettings, UsageSettingsRuntime } from "./settings.js";
+
+const OFF = "Off";
+const ON = "On";
+const REMAINING = "Remaining";
+const USED = "Used";
+
+type UsageSettingId = "codexFastMode" | "codexStatusResetCountdown" | "codexStatusPercentage";
+
+function settingValueLabel(id: UsageSettingId, value: UsageSettings[UsageSettingId]): string {
+  if (id === "codexStatusPercentage") return value === "used" ? USED : REMAINING;
+  return value === true ? ON : OFF;
+}
+
+export async function showUsageSettings(
+  ctx: ExtensionCommandContext,
+  settingsRuntime: UsageSettingsRuntime,
+  parentSignal: AbortSignal,
+  isCurrent: () => boolean,
+  onApplied: (id: UsageSettingId) => void,
+): Promise<boolean> {
+  if (ctx.mode !== "tui") {
+    if (ctx.hasUI) ctx.ui.notify(`Edit settings manually: ${settingsRuntime.get().path}`, "info");
+    return false;
+  }
+  const { HorizontalRule, renderBoundedFrame } = await import("@narumitw/pi-tui-kit");
+  if (parentSignal.aborted || !isCurrent()) return false;
+  return (
+    (await ctx.ui.custom<boolean>((tui, theme, _keybindings, done) => {
+      const localController = new AbortController();
+      const signal = AbortSignal.any([parentSignal, localController.signal]);
+      let changed = false;
+      let closing = false;
+      let saveQueue = Promise.resolve();
+      const state = settingsRuntime.get();
+      const items: SettingItem[] = [
+        {
+          id: "codexFastMode",
+          label: "Codex Fast mode",
+          description: "Use faster Codex routing at increased plan allowance consumption.",
+          currentValue: state.settings.codexFastMode ? ON : OFF,
+          values: [OFF, ON],
+        },
+        {
+          id: "codexStatusResetCountdown",
+          label: "Codex reset countdown",
+          description: "Show time remaining until each Codex usage limit resets.",
+          currentValue: state.settings.codexStatusResetCountdown ? ON : OFF,
+          values: [OFF, ON],
+        },
+        {
+          id: "codexStatusPercentage",
+          label: "Codex percentage",
+          description: "Show remaining or used Codex quota in the statusline.",
+          currentValue: settingValueLabel("codexStatusPercentage", state.settings.codexStatusPercentage),
+          values: [REMAINING, USED],
+        },
+      ];
+      const rule = new HorizontalRule({ ruleStyle: (text) => theme.fg("border", text) });
+
+      let settingsList: SettingsList;
+      const cancel = () => {
+        if (closing) return;
+        closing = true;
+        localController.abort();
+        done(changed);
+      };
+      const queueUpdate = <Id extends UsageSettingId>(id: Id, requested: UsageSettings[Id], display: string) => {
+        saveQueue = saveQueue.then(async () => {
+          const previous = settingsRuntime.get().settings[id];
+          if (settingsRuntime.get().kind === "invalid") {
+            settingsList.updateValue(id, settingValueLabel(id, previous));
+            if (!signal.aborted && isCurrent()) {
+              ctx.ui.notify("Repair pi-usage.json and reload before changing settings.", "error");
+              tui.requestRender();
+            }
+            return;
+          }
+          try {
+            const patch: Partial<UsageSettings> = {};
+            patch[id] = requested;
+            await settingsRuntime.update(patch, signal);
+          } catch (error) {
+            if (signal.aborted || !isCurrent()) return;
+            settingsList.updateValue(id, settingValueLabel(id, previous));
+            ctx.ui.notify(`Could not save pi-usage.json: ${errorMessage(error)}`, "error");
+            tui.requestRender();
+            return;
+          }
+          if (previous !== requested) {
+            changed = true;
+            onApplied(id);
+          }
+          if (signal.aborted || !isCurrent()) return;
+          settingsList.updateValue(id, display);
+          tui.requestRender();
+        });
+      };
+      settingsList = new SettingsList(
+        items,
+        items.length + 2,
+        getSettingsListTheme(),
+        (id, value) => {
+          if (closing || signal.aborted || !isCurrent()) return;
+          if (id === "codexStatusPercentage") {
+            queueUpdate(id, value === USED ? "used" : "remaining", value);
+          } else if (id === "codexFastMode" || id === "codexStatusResetCountdown") {
+            queueUpdate(id, value === ON, value);
+          }
+        },
+        cancel,
+      );
+
+      parentSignal.addEventListener("abort", cancel, { once: true });
+      return {
+        render(width: number) {
+          // Compatibility: Kit puts the title directly below the top rule and keeps compact
+          // rules when at least five rows fit; both replace the legacy wrapper layout.
+          const title = new Text(theme.fg("accent", theme.bold("pi-usage Settings")), 1, 0).render(width);
+          const content = settingsList.render(width);
+          const focusedRow = content.findIndex((line) => /^[→›]\s/u.test(stripVTControlCharacters(line)));
+          const terminalRows = Number.isFinite(tui.terminal?.rows) ? Math.floor(tui.terminal.rows) : 24;
+          const [ruleLine = ""] = rule.render(width);
+          return renderBoundedFrame({
+            width,
+            maxRows: Math.max(1, terminalRows - 3),
+            rule: ruleLine,
+            title,
+            content,
+            priorityRows: focusedRow < 0 ? [] : [focusedRow],
+            focusedRow,
+          });
+        },
+        invalidate: () => settingsList.invalidate(),
+        handleInput(data: string) {
+          if (closing) return;
+          if (matchesKey(data, Key.ctrl("c"))) cancel();
+          else settingsList.handleInput(data);
+          tui.requestRender();
+        },
+        dispose() {
+          localController.abort();
+          parentSignal.removeEventListener("abort", cancel);
+        },
+      };
+    })) ?? false
+  );
+}

package/src/usage-targets.ts

@@ -0,0 +1,127 @@
+import { sanitizeDisplayText } from "./core.js";
+import type { ResolvedUsageAuth, UsageProviderAdapter, UsageProviderTarget, UsageRequestGuard } from "./types.js";
+
+const MAX_TARGETS = 1_000;
+const MAX_TARGET_ID_CHARS = 256;
+const MAX_TARGET_LABEL_CHARS = 120;
+const MAX_TARGET_DESCRIPTION_CHARS = 180;
+
+export type UsageTargetResolution =
+  | { kind: "selected"; targetId?: string }
+  | {
+      kind: "selection-required";
+      choices: readonly UsageProviderTarget[];
+    };
+
+export interface UsageTargetSelectOptions {
+  options: readonly string[];
+  targetIdFor(option: string): string | undefined;
+}
+
+export async function resolveUsageTarget(
+  adapter: UsageProviderAdapter,
+  auth: ResolvedUsageAuth,
+  rememberedTargetId: string | undefined,
+  signal: AbortSignal,
+  timeoutMs: number,
+  guard: UsageRequestGuard,
+): Promise<UsageTargetResolution> {
+  if (!adapter.targets) return { kind: "selected" };
+  if (rememberedTargetId !== undefined && !isBoundedTargetId(rememberedTargetId)) {
+    throw new Error(`The remembered ${adapter.targets.singularLabel} identifier was invalid.`);
+  }
+  const choices = await listUsageTargets(adapter, auth, signal, timeoutMs, guard);
+  if (rememberedTargetId) {
+    return choices.some((choice) => choice.id === rememberedTargetId)
+      ? { kind: "selected", targetId: rememberedTargetId }
+      : { kind: "selection-required", choices };
+  }
+  if (choices.length === 1) return { kind: "selected", targetId: choices[0]?.id };
+  return { kind: "selection-required", choices };
+}
+
+export async function listUsageTargets(
+  adapter: UsageProviderAdapter,
+  auth: ResolvedUsageAuth,
+  signal: AbortSignal,
+  timeoutMs: number,
+  guard: UsageRequestGuard,
+): Promise<readonly UsageProviderTarget[]> {
+  if (!adapter.targets) return [];
+  const startedAt = Date.now();
+  await guard();
+  const listed = await adapter.targets.list(auth, signal, remainingTargetTimeout(timeoutMs, startedAt), guard);
+  await guard();
+  remainingTargetTimeout(timeoutMs, startedAt);
+  const choices = normalizeUsageTargets(listed);
+  if (choices.length === 0) {
+    throw new Error(`${adapter.targets.pluralLabel} discovery returned no choices.`);
+  }
+  return choices;
+}
+
+export function normalizeUsageTargets(targets: readonly UsageProviderTarget[]): readonly UsageProviderTarget[] {
+  if (!Array.isArray(targets)) throw new Error("Target discovery did not return a choices array.");
+  if (targets.length > MAX_TARGETS) {
+    throw new Error(`Target discovery exceeded ${MAX_TARGETS} choices.`);
+  }
+  const seen = new Set<string>();
+  return targets.map((target) => {
+    if (!target || typeof target !== "object" || Array.isArray(target)) {
+      throw new Error("Target discovery returned an invalid choice.");
+    }
+    const { id, label, description } = target as Partial<UsageProviderTarget>;
+    if (!isBoundedTargetId(id)) throw new Error("Target discovery returned an invalid ID.");
+    if (seen.has(id)) throw new Error(`Target discovery repeated ${id}.`);
+    seen.add(id);
+    if (typeof label !== "string") {
+      throw new Error("Target discovery returned an invalid display label.");
+    }
+    if (description !== undefined && typeof description !== "string") {
+      throw new Error("Target discovery returned an invalid description.");
+    }
+    const safeLabel = sanitizeDisplayText(label, MAX_TARGET_LABEL_CHARS);
+    if (!safeLabel) throw new Error("Target discovery returned an empty display label.");
+    const safeDescription = description ? sanitizeDisplayText(description, MAX_TARGET_DESCRIPTION_CHARS) : undefined;
+    return { id, label: safeLabel, ...(safeDescription ? { description: safeDescription } : {}) };
+  });
+}
+
+export function createUsageTargetSelectOptions(targets: readonly UsageProviderTarget[]): UsageTargetSelectOptions {
+  const normalized = normalizeUsageTargets(targets);
+  const ids = new Map<string, string>();
+  const options = normalized.map((target) => {
+    const base = target.description ? `${target.label} — ${target.description}` : target.label;
+    let option = base;
+    if (ids.has(option)) {
+      const safeId = sanitizeDisplayText(target.id, 80) || "target";
+      option = `${base} · ${safeId}`;
+      let duplicate = 2;
+      while (ids.has(option)) {
+        option = `${base} · ${safeId} (${duplicate})`;
+        duplicate += 1;
+      }
+    }
+    ids.set(option, target.id);
+    return option;
+  });
+  return { options, targetIdFor: (option) => ids.get(option) };
+}
+
+function remainingTargetTimeout(timeoutMs: number, startedAt: number): number {
+  const remaining = timeoutMs - (Date.now() - startedAt);
+  if (remaining <= 0) throw new Error("Timed out while discovering provider targets.");
+  return remaining;
+}
+
+export function isBoundedTargetId(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length > 0 &&
+    value.length <= MAX_TARGET_ID_CHARS &&
+    ![...value].some((character) => {
+      const codePoint = character.codePointAt(0) ?? 0;
+      return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f);
+    })
+  );
+}