255 lines
10 KiB
TypeScript
255 lines
10 KiB
TypeScript
import { execFileSync } from "node:child_process";
|
|
import { existsSync, readFileSync } from "node:fs";
|
|
import { homedir } from "node:os";
|
|
import { basename, join } from "node:path";
|
|
import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
|
|
import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
|
|
|
|
type QuotaState =
|
|
| { status: "idle" | "loading" }
|
|
| { status: "ok"; detail: string; refreshedAt: number; weeklyRemaining?: number; shortRemaining?: number }
|
|
| { status: "missing" | "error"; detail: string; refreshedAt?: number };
|
|
|
|
const CODEX_USAGE_ENDPOINTS = [
|
|
"https://chatgpt.com/backend-api/wham/usage",
|
|
"https://chatgpt.com/backend-api/codex/usage",
|
|
];
|
|
const QUOTA_REFRESH_MS = 5 * 60 * 1000;
|
|
const REQUEST_TIMEOUT_MS = 10_000;
|
|
|
|
let quotaState: QuotaState = { status: "idle" };
|
|
let quotaRefreshPromise: Promise<void> | null = null;
|
|
|
|
function shortCwd(cwd: string): string {
|
|
const home = process.env.HOME;
|
|
if (home && cwd.startsWith(`${home}/`)) return `~/${basename(cwd)}`;
|
|
return basename(cwd) || cwd;
|
|
}
|
|
|
|
function gitBranch(cwd: string): string | null {
|
|
try {
|
|
const out = execFileSync("git", ["--no-optional-locks", "symbolic-ref", "--quiet", "--short", "HEAD"], {
|
|
cwd,
|
|
encoding: "utf8",
|
|
stdio: ["ignore", "pipe", "ignore"],
|
|
}).trim();
|
|
return out || null;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function authPath(): string {
|
|
return join(process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent"), "auth.json");
|
|
}
|
|
|
|
function readCodexCredentials(): { access: string; accountId?: string } | null {
|
|
const file = authPath();
|
|
if (!existsSync(file)) return null;
|
|
try {
|
|
const auth = JSON.parse(readFileSync(file, "utf8"));
|
|
const credential = auth?.["openai-codex"];
|
|
if (credential?.type !== "oauth" || typeof credential.access !== "string") return null;
|
|
if (typeof credential.expires === "number" && credential.expires <= Date.now() + 30_000) return null;
|
|
return {
|
|
access: credential.access,
|
|
accountId: typeof credential.accountId === "string" ? credential.accountId : undefined,
|
|
};
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function numberValue(value: unknown): number | undefined {
|
|
if (typeof value === "number" && Number.isFinite(value)) return value;
|
|
if (typeof value === "string" && value.trim() !== "") {
|
|
const parsed = Number(value);
|
|
if (Number.isFinite(parsed)) return parsed;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
function objectValue(value: unknown): Record<string, unknown> | undefined {
|
|
return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
|
|
}
|
|
|
|
function windowSeconds(raw: Record<string, unknown>): number | undefined {
|
|
const seconds = numberValue(raw.limit_window_seconds ?? raw.windowSeconds);
|
|
if (seconds !== undefined) return seconds;
|
|
const mins = numberValue(raw.windowDurationMins ?? raw.window_duration_mins);
|
|
return mins === undefined ? undefined : mins * 60;
|
|
}
|
|
|
|
function usedPercent(raw: Record<string, unknown>): number | undefined {
|
|
const value = numberValue(raw.used_percent ?? raw.usedPercent);
|
|
if (value === undefined) return undefined;
|
|
return Math.max(0, Math.min(100, value));
|
|
}
|
|
|
|
function collectWindows(raw: unknown, out: Array<{ seconds?: number; used: number; key: string }> = [], key = "root") {
|
|
if (Array.isArray(raw)) {
|
|
raw.forEach((item, index) => collectWindows(item, out, `${key}.${index}`));
|
|
return out;
|
|
}
|
|
const obj = objectValue(raw);
|
|
if (!obj) return out;
|
|
const used = usedPercent(obj);
|
|
if (used !== undefined) out.push({ seconds: windowSeconds(obj), used, key });
|
|
for (const [childKey, value] of Object.entries(obj)) {
|
|
if (value && typeof value === "object") collectWindows(value, out, `${key}.${childKey}`);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
function pickQuotaWindows(raw: unknown): { weeklyRemaining?: number; shortRemaining?: number } | null {
|
|
const windows = collectWindows(raw);
|
|
if (windows.length === 0) return null;
|
|
const weekly = windows.find((window) => window.seconds !== undefined && Math.abs(window.seconds - 604_800) <= 60 * 60)
|
|
?? windows.find((window) => /week|weekly|secondary/i.test(window.key));
|
|
const short = windows.find((window) => window.seconds !== undefined && Math.abs(window.seconds - 18_000) <= 60 * 30)
|
|
?? windows.find((window) => /five|session|primary|short/i.test(window.key));
|
|
return {
|
|
weeklyRemaining: weekly ? Math.max(0, Math.min(100, 100 - weekly.used)) : undefined,
|
|
shortRemaining: short ? Math.max(0, Math.min(100, 100 - short.used)) : undefined,
|
|
};
|
|
}
|
|
|
|
function safeFg(theme: any, color: string, text: string): string {
|
|
try {
|
|
return theme.fg(color, text);
|
|
} catch {
|
|
return theme.fg("accent", text);
|
|
}
|
|
}
|
|
|
|
function contextColor(percent: number): string {
|
|
if (percent >= 90) return "error";
|
|
if (percent >= 70) return "warning";
|
|
return "success";
|
|
}
|
|
|
|
function quotaColor(percent: number): string {
|
|
if (percent >= 80) return "error";
|
|
if (percent >= 50) return "warning";
|
|
return "border";
|
|
}
|
|
|
|
function bar(theme: any, width: number, percent: number | null, glyph: string, colorForPercent: (percent: number) => string): string {
|
|
const barWidth = Math.max(12, width);
|
|
if (percent === null) return theme.fg("muted", glyph.repeat(barWidth));
|
|
const clamped = Math.max(0, Math.min(100, percent));
|
|
const filled = Math.max(0, Math.min(barWidth, Math.round((clamped / 100) * barWidth)));
|
|
const empty = Math.max(0, barWidth - filled);
|
|
return safeFg(theme, colorForPercent(clamped), glyph.repeat(filled)) + theme.fg("dim", glyph.repeat(empty));
|
|
}
|
|
|
|
async function fetchCodexQuota(force = false): Promise<void> {
|
|
const fresh = quotaState.status === "ok" && Date.now() - quotaState.refreshedAt < QUOTA_REFRESH_MS;
|
|
if (!force && fresh) return;
|
|
if (quotaRefreshPromise) return quotaRefreshPromise;
|
|
|
|
quotaState = { status: "loading" };
|
|
quotaRefreshPromise = (async () => {
|
|
const credentials = readCodexCredentials();
|
|
if (!credentials) {
|
|
quotaState = { status: "missing", detail: "OpenAI Codex OAuth credentials were not found or are expired" };
|
|
return;
|
|
}
|
|
|
|
let lastError = "quota unavailable";
|
|
for (const endpoint of CODEX_USAGE_ENDPOINTS) {
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
|
|
try {
|
|
const headers: Record<string, string> = { Authorization: `Bearer ${credentials.access}` };
|
|
if (credentials.accountId) headers["ChatGPT-Account-Id"] = credentials.accountId;
|
|
const response = await fetch(endpoint, { headers, signal: controller.signal });
|
|
if (!response.ok) {
|
|
lastError = `${response.status} ${response.statusText}`;
|
|
continue;
|
|
}
|
|
const windows = pickQuotaWindows(await response.json());
|
|
if (!windows || (windows.weeklyRemaining === undefined && windows.shortRemaining === undefined)) {
|
|
lastError = "response had no recognized quota windows";
|
|
continue;
|
|
}
|
|
const details = [];
|
|
if (windows.weeklyRemaining !== undefined) details.push(`weekly ${Math.round(windows.weeklyRemaining)}%`);
|
|
if (windows.shortRemaining !== undefined) details.push(`short ${Math.round(windows.shortRemaining)}%`);
|
|
quotaState = {
|
|
status: "ok",
|
|
detail: `Codex quota remaining: ${details.join(", ")}`,
|
|
weeklyRemaining: windows.weeklyRemaining,
|
|
shortRemaining: windows.shortRemaining,
|
|
refreshedAt: Date.now(),
|
|
};
|
|
return;
|
|
} catch (error) {
|
|
lastError = error instanceof Error ? error.message : String(error);
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
}
|
|
}
|
|
quotaState = { status: "error", detail: `Codex quota failed: ${lastError}`, refreshedAt: Date.now() };
|
|
})().finally(() => {
|
|
quotaRefreshPromise = null;
|
|
});
|
|
return quotaRefreshPromise;
|
|
}
|
|
|
|
function statusLines(ctx: any, theme: any, width: number): string[] {
|
|
const cwd = ctx.sessionManager?.getCwd?.() ?? ctx.cwd ?? process.cwd();
|
|
const branch = gitBranch(cwd);
|
|
const where = branch ? ` ${shortCwd(cwd)} ${branch}` : ` ${shortCwd(cwd)}`;
|
|
const model = ctx.model?.id ?? process.env.PI_MODEL ?? "no-model";
|
|
const thinking = ctx.thinkingLevel ?? process.env.PI_REASONING_LEVEL ?? "off";
|
|
const left = theme.fg("accent", where);
|
|
const right = theme.fg("dim", `${model} • ${thinking}`);
|
|
const pad = " ".repeat(Math.max(1, width - visibleWidth(left) - visibleWidth(right)));
|
|
const contextPercentRaw = ctx.getContextUsage?.()?.percent;
|
|
const contextPercent = typeof contextPercentRaw === "number" && Number.isFinite(contextPercentRaw) ? contextPercentRaw : null;
|
|
const quotaConsumed = quotaState.status === "ok" && quotaState.weeklyRemaining !== undefined
|
|
? 100 - quotaState.weeklyRemaining
|
|
: null;
|
|
return [
|
|
truncateToWidth(left + pad + right, width),
|
|
bar(theme, width, contextPercent, "▃", contextColor),
|
|
bar(theme, width, quotaConsumed, "▔", quotaColor),
|
|
];
|
|
}
|
|
|
|
function setCompactStatusUi(ctx: any) {
|
|
if (!ctx.hasUI) return;
|
|
ctx.ui.setWidget("compact-status", (_tui: any, theme: any) => ({
|
|
invalidate() {},
|
|
render(width: number) {
|
|
return statusLines(ctx, theme, width);
|
|
},
|
|
}));
|
|
ctx.ui.setFooter(() => ({ invalidate() {}, render: () => [] }));
|
|
}
|
|
|
|
export default function compactStatus(pi: ExtensionAPI) {
|
|
function refreshUi(ctx: any) {
|
|
setCompactStatusUi(ctx);
|
|
}
|
|
|
|
pi.on("session_start", (_event, ctx) => {
|
|
refreshUi(ctx);
|
|
void fetchCodexQuota(false).then(() => refreshUi(ctx));
|
|
});
|
|
pi.on("model_select", (_event, ctx) => refreshUi(ctx));
|
|
pi.on("agent_settled", (_event, ctx) => refreshUi(ctx));
|
|
|
|
pi.registerCommand("codex-quota", {
|
|
description: "Refresh and show ChatGPT Codex quota",
|
|
handler: async (_args, ctx) => {
|
|
refreshUi(ctx);
|
|
await fetchCodexQuota(true);
|
|
refreshUi(ctx);
|
|
const level = quotaState.status === "ok" ? "info" : quotaState.status === "missing" ? "warning" : "error";
|
|
ctx.ui.notify(quotaState.status === "idle" || quotaState.status === "loading" ? "Codex quota refresh in progress" : quotaState.detail, level);
|
|
},
|
|
});
|
|
}
|