708 lines
22 KiB
TypeScript
708 lines
22 KiB
TypeScript
import type { ExtensionAPI, ExtensionContext, Theme } from "@mariozechner/pi-coding-agent";
|
|
import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
|
|
import * as fs from "node:fs";
|
|
import { homedir } from "node:os";
|
|
import { join } from "node:path";
|
|
|
|
type ProviderName = "anthropic" | "codex" | "gemini" | "opencode-go";
|
|
|
|
interface RateWindow {
|
|
label: string;
|
|
usedPercent: number;
|
|
resetDescription?: string;
|
|
resetAt?: string;
|
|
}
|
|
|
|
interface UsageSnapshot {
|
|
provider: ProviderName;
|
|
displayName: string;
|
|
windows: RateWindow[];
|
|
error?: string;
|
|
fetchedAt: number;
|
|
lastSuccessAt?: number;
|
|
fromCache?: boolean;
|
|
}
|
|
|
|
interface ProviderCache {
|
|
usage?: UsageSnapshot;
|
|
lastSuccessAt?: number;
|
|
}
|
|
|
|
interface CodexRateWindow {
|
|
reset_at?: number;
|
|
limit_window_seconds?: number;
|
|
used_percent?: number;
|
|
}
|
|
|
|
interface CodexRateLimit {
|
|
primary_window?: CodexRateWindow;
|
|
secondary_window?: CodexRateWindow;
|
|
}
|
|
|
|
interface PiAuthShape {
|
|
anthropic?: { access?: string };
|
|
"google-gemini-cli"?: { access?: string };
|
|
"openai-codex"?: { access?: string; accountId?: string };
|
|
}
|
|
|
|
const CACHE_TTL_MS = 5 * 60 * 1000;
|
|
const ANTHROPIC_CACHE_TTL_MS = 30 * 60 * 1000;
|
|
const REFRESH_MS = 5 * 60 * 1000;
|
|
const PROVIDER_ORDER: ProviderName[] = ["anthropic", "codex", "gemini", "opencode-go"];
|
|
const SHORTCUT_TOGGLE = "ctrl+alt+b";
|
|
const SHORTCUT_BAR_STYLE = "ctrl+alt+t";
|
|
const showToggleState = async (ctx: ExtensionContext, next: boolean, refresh: () => Promise<void>) => {
|
|
if (!next) {
|
|
ctx.ui.setWidget("sub-bar-local", undefined);
|
|
ctx.ui.notify("sub bar hidden", "info");
|
|
return;
|
|
}
|
|
ctx.ui.notify("sub bar shown", "info");
|
|
await refresh();
|
|
};
|
|
|
|
const OPENCODE_CONFIG_FILE = join(homedir(), ".config", "opencode", "opencode-go-usage.json");
|
|
const PI_AUTH_FILE = join(homedir(), ".pi", "agent", "auth.json");
|
|
|
|
function readJsonFile<T>(path: string): T | undefined {
|
|
try {
|
|
if (!fs.existsSync(path)) return undefined;
|
|
const content = fs.readFileSync(path, "utf-8");
|
|
return JSON.parse(content) as T;
|
|
} catch {
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
function clampPercent(value: number | undefined): number {
|
|
if (typeof value !== "number" || Number.isNaN(value)) return 0;
|
|
return Math.max(0, Math.min(100, Math.round(value)));
|
|
}
|
|
|
|
function formatDuration(seconds?: number): string | undefined {
|
|
if (typeof seconds !== "number" || seconds <= 0) return undefined;
|
|
if (seconds < 60) return `${Math.max(1, Math.round(seconds))}s`;
|
|
if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
|
|
if (seconds < 86400) {
|
|
const h = Math.floor(seconds / 3600);
|
|
const m = Math.floor((seconds % 3600) / 60);
|
|
return m > 0 ? `${h}h ${m}m` : `${h}h`;
|
|
}
|
|
const d = Math.floor(seconds / 86400);
|
|
const h = Math.floor((seconds % 86400) / 3600);
|
|
return h > 0 ? `${d}d ${h}h` : `${d}d`;
|
|
}
|
|
|
|
function formatResetDate(resetIso?: string): string | undefined {
|
|
if (!resetIso) return undefined;
|
|
const resetDate = new Date(resetIso);
|
|
if (Number.isNaN(resetDate.getTime())) return undefined;
|
|
const diffSec = Math.max(0, Math.floor((resetDate.getTime() - Date.now()) / 1000));
|
|
return formatDuration(diffSec);
|
|
}
|
|
|
|
function getErrorAge(lastSuccessAt?: number): string | undefined {
|
|
if (!lastSuccessAt) return undefined;
|
|
const diffSec = Math.floor((Date.now() - lastSuccessAt) / 1000);
|
|
return formatDuration(diffSec);
|
|
}
|
|
|
|
function getPiAuth(): PiAuthShape {
|
|
return readJsonFile<PiAuthShape>(PI_AUTH_FILE) ?? {};
|
|
}
|
|
|
|
function loadAnthropicToken(): string | undefined {
|
|
const env = process.env.ANTHROPIC_OAUTH_TOKEN?.trim();
|
|
if (env) return env;
|
|
return getPiAuth().anthropic?.access;
|
|
}
|
|
|
|
function loadGeminiToken(): string | undefined {
|
|
const env = (
|
|
process.env.GOOGLE_GEMINI_CLI_OAUTH_TOKEN ||
|
|
process.env.GOOGLE_GEMINI_CLI_ACCESS_TOKEN ||
|
|
process.env.GEMINI_OAUTH_TOKEN
|
|
)?.trim();
|
|
if (env) return env;
|
|
return getPiAuth()["google-gemini-cli"]?.access;
|
|
}
|
|
|
|
function loadCodexCredentials(): { accessToken?: string; accountId?: string } {
|
|
const envToken = (
|
|
process.env.OPENAI_CODEX_OAUTH_TOKEN ||
|
|
process.env.OPENAI_CODEX_ACCESS_TOKEN ||
|
|
process.env.CODEX_OAUTH_TOKEN ||
|
|
process.env.CODEX_ACCESS_TOKEN
|
|
)?.trim();
|
|
const envAccountId = (process.env.OPENAI_CODEX_ACCOUNT_ID || process.env.CHATGPT_ACCOUNT_ID)?.trim();
|
|
if (envToken) {
|
|
return { accessToken: envToken, accountId: envAccountId || undefined };
|
|
}
|
|
const auth = getPiAuth()["openai-codex"];
|
|
if (!auth?.access) return {};
|
|
return { accessToken: auth.access, accountId: auth.accountId };
|
|
}
|
|
|
|
function loadOpenCodeGoCredentials(): { workspaceId?: string; authCookie?: string } {
|
|
const envWorkspaceId = process.env.OPENCODE_GO_WORKSPACE_ID?.trim();
|
|
const envAuthCookie = process.env.OPENCODE_GO_AUTH_COOKIE?.trim();
|
|
if (envWorkspaceId && envAuthCookie) {
|
|
return { workspaceId: envWorkspaceId, authCookie: envAuthCookie };
|
|
}
|
|
const config = readJsonFile<{ workspaceId?: string; authCookie?: string }>(OPENCODE_CONFIG_FILE);
|
|
return {
|
|
workspaceId: config?.workspaceId?.trim(),
|
|
authCookie: config?.authCookie?.trim(),
|
|
};
|
|
}
|
|
|
|
function modelToProvider(modelProvider?: string): ProviderName | undefined {
|
|
const id = (modelProvider ?? "").toLowerCase();
|
|
if (id.includes("opencode-go")) return "opencode-go";
|
|
if (id.includes("anthropic")) return "anthropic";
|
|
if (id.includes("gemini") || id.includes("google")) return "gemini";
|
|
if (id.includes("codex") || id.includes("openai")) return "codex";
|
|
return undefined;
|
|
}
|
|
|
|
function codexWindowLabel(window: CodexRateWindow | undefined, fallback: string): string {
|
|
if (!window || typeof window.limit_window_seconds !== "number" || window.limit_window_seconds <= 0) {
|
|
return fallback;
|
|
}
|
|
return formatDuration(window.limit_window_seconds) ?? fallback;
|
|
}
|
|
|
|
function pushCodexWindow(windows: RateWindow[], fallbackLabel: string, window?: CodexRateWindow): void {
|
|
if (!window) return;
|
|
const resetIso = typeof window.reset_at === "number" ? new Date(window.reset_at * 1000).toISOString() : undefined;
|
|
windows.push({
|
|
label: codexWindowLabel(window, fallbackLabel),
|
|
usedPercent: clampPercent(window.used_percent),
|
|
resetAt: resetIso,
|
|
});
|
|
}
|
|
|
|
function barForPercent(theme: Theme, usedPercent: number, width = 8, style: "thin" | "thick" = "thick"): string {
|
|
const safeWidth = Math.max(1, width);
|
|
const filled = Math.round((clampPercent(usedPercent) / 100) * safeWidth);
|
|
const empty = Math.max(0, safeWidth - filled);
|
|
const color = usedPercent >= 85 ? "error" : usedPercent >= 60 ? "warning" : "success";
|
|
const filledChar = style === "thin" ? "─" : "█";
|
|
const emptyChar = style === "thin" ? "─" : "░";
|
|
return `${theme.fg(color, filledChar.repeat(filled))}${theme.fg("dim", emptyChar.repeat(empty))}`;
|
|
}
|
|
|
|
function padToWidth(text: string, width: number): string {
|
|
const w = visibleWidth(text);
|
|
if (w >= width) return truncateToWidth(text, width);
|
|
return text + " ".repeat(width - w);
|
|
}
|
|
|
|
function buildColumnWidths(totalWidth: number, columns: number): number[] {
|
|
if (columns <= 0) return [];
|
|
const base = Math.max(1, Math.floor(totalWidth / columns));
|
|
let remainder = Math.max(0, totalWidth - base * columns);
|
|
const widths: number[] = [];
|
|
for (let i = 0; i < columns; i++) {
|
|
const extra = remainder > 0 ? 1 : 0;
|
|
widths.push(base + extra);
|
|
if (remainder > 0) remainder--;
|
|
}
|
|
return widths;
|
|
}
|
|
|
|
function formatUsageTwoLines(
|
|
theme: Theme,
|
|
usage: UsageSnapshot,
|
|
width: number,
|
|
statusNote?: string,
|
|
barStyle: "thin" | "thick" = "thick",
|
|
): { top: string; bottom?: string } {
|
|
const provider = theme.bold(theme.fg("accent", usage.displayName));
|
|
if (usage.error && usage.windows.length === 0) {
|
|
const age = getErrorAge(usage.lastSuccessAt);
|
|
const stale = age ? ` (stale ${age})` : "";
|
|
return { top: truncateToWidth(`${provider} ${theme.fg("warning", `⚠ ${usage.error}${stale}`)}`, width) };
|
|
}
|
|
if (usage.windows.length === 0) {
|
|
return { top: truncateToWidth(provider, width) };
|
|
}
|
|
|
|
const prefix = `${provider} ${theme.fg("dim", "•")} `;
|
|
const prefixWidth = Math.min(visibleWidth(prefix), Math.max(0, width - 1));
|
|
const contentWidth = Math.max(1, width - prefixWidth);
|
|
const gap = " ";
|
|
const gapWidth = visibleWidth(gap);
|
|
const windowsCount = usage.windows.length;
|
|
const totalGapWidth = Math.max(0, (windowsCount - 1) * gapWidth);
|
|
const columnsArea = Math.max(1, contentWidth - totalGapWidth);
|
|
const colWidths = buildColumnWidths(columnsArea, windowsCount);
|
|
|
|
const topCols = usage.windows.map((window, index) => {
|
|
const colWidth = colWidths[index] ?? 1;
|
|
const pct = clampPercent(window.usedPercent);
|
|
const resetRaw = formatResetDate(window.resetAt) ?? window.resetDescription ?? "";
|
|
const left = `${window.label} ${pct}%`;
|
|
const right = resetRaw;
|
|
if (!right) return padToWidth(theme.fg("text", left), colWidth);
|
|
const leftWidth = visibleWidth(left);
|
|
const rightWidth = visibleWidth(right);
|
|
if (leftWidth + 1 + rightWidth <= colWidth) {
|
|
const spaces = " ".repeat(colWidth - leftWidth - rightWidth);
|
|
return `${theme.fg("text", left)}${spaces}${theme.fg("dim", right)}`;
|
|
}
|
|
const compact = `${left} ${right}`;
|
|
return padToWidth(theme.fg("text", truncateToWidth(compact, colWidth)), colWidth);
|
|
});
|
|
|
|
const bottomCols = usage.windows.map((window, index) => {
|
|
const colWidth = colWidths[index] ?? 1;
|
|
const pct = clampPercent(window.usedPercent);
|
|
return barForPercent(theme, pct, colWidth, barStyle);
|
|
});
|
|
|
|
let top = prefix + topCols.join(gap);
|
|
if (statusNote) {
|
|
const note = theme.fg("warning", ` ⚠ ${statusNote}`);
|
|
top = truncateToWidth(top + note, width);
|
|
}
|
|
const bottomPrefix = " ".repeat(prefixWidth);
|
|
const bottom = bottomPrefix + bottomCols.join(gap);
|
|
|
|
return {
|
|
top: padToWidth(top, width),
|
|
bottom: padToWidth(bottom, width),
|
|
};
|
|
}
|
|
|
|
async function fetchAnthropicUsage(): Promise<UsageSnapshot> {
|
|
const token = loadAnthropicToken();
|
|
if (!token) throw new Error("missing anthropic oauth token");
|
|
|
|
const response = await fetch("https://api.anthropic.com/api/oauth/usage", {
|
|
headers: {
|
|
Authorization: `Bearer ${token}`,
|
|
"anthropic-beta": "oauth-2025-04-20",
|
|
},
|
|
});
|
|
if (!response.ok) throw new Error(`anthropic http ${response.status}`);
|
|
|
|
const data = (await response.json()) as {
|
|
five_hour?: { utilization?: number; resets_at?: string };
|
|
seven_day?: { utilization?: number; resets_at?: string };
|
|
extra_usage?: { utilization?: number; used_credits?: number; monthly_limit?: number; is_enabled?: boolean };
|
|
};
|
|
|
|
const windows: RateWindow[] = [];
|
|
if (data.five_hour?.utilization !== undefined) {
|
|
windows.push({ label: "5h", usedPercent: clampPercent(data.five_hour.utilization), resetAt: data.five_hour.resets_at });
|
|
}
|
|
if (data.seven_day?.utilization !== undefined) {
|
|
windows.push({ label: "Week", usedPercent: clampPercent(data.seven_day.utilization), resetAt: data.seven_day.resets_at });
|
|
}
|
|
// hide Anthropic extra_usage window for now (it is confusing/noisy for premium users)
|
|
if (windows.length === 0) throw new Error("no anthropic usage windows");
|
|
|
|
const now = Date.now();
|
|
return {
|
|
provider: "anthropic",
|
|
displayName: "Claude Plan",
|
|
windows,
|
|
fetchedAt: now,
|
|
lastSuccessAt: now,
|
|
};
|
|
}
|
|
|
|
async function fetchCodexUsage(): Promise<UsageSnapshot> {
|
|
const { accessToken, accountId } = loadCodexCredentials();
|
|
if (!accessToken) throw new Error("missing codex oauth token");
|
|
|
|
const headers: Record<string, string> = {
|
|
Authorization: `Bearer ${accessToken}`,
|
|
Accept: "application/json",
|
|
};
|
|
if (accountId) headers["ChatGPT-Account-Id"] = accountId;
|
|
|
|
const response = await fetch("https://chatgpt.com/backend-api/wham/usage", { headers });
|
|
if (!response.ok) throw new Error(`codex http ${response.status}`);
|
|
|
|
const data = (await response.json()) as {
|
|
rate_limit?: CodexRateLimit;
|
|
};
|
|
|
|
const windows: RateWindow[] = [];
|
|
pushCodexWindow(windows, "3h", data.rate_limit?.primary_window);
|
|
pushCodexWindow(windows, "Day", data.rate_limit?.secondary_window);
|
|
if (windows.length === 0) throw new Error("no codex usage windows");
|
|
|
|
const now = Date.now();
|
|
return {
|
|
provider: "codex",
|
|
displayName: "Codex Plan",
|
|
windows,
|
|
fetchedAt: now,
|
|
lastSuccessAt: now,
|
|
};
|
|
}
|
|
|
|
async function fetchGeminiUsage(): Promise<UsageSnapshot> {
|
|
const token = loadGeminiToken();
|
|
if (!token) throw new Error("missing gemini oauth token");
|
|
|
|
const response = await fetch("https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota", {
|
|
method: "POST",
|
|
headers: {
|
|
Authorization: `Bearer ${token}`,
|
|
"Content-Type": "application/json",
|
|
},
|
|
body: "{}",
|
|
});
|
|
if (!response.ok) throw new Error(`gemini http ${response.status}`);
|
|
|
|
const data = (await response.json()) as {
|
|
buckets?: Array<{ modelId?: string; remainingFraction?: number }>;
|
|
};
|
|
|
|
let minPro = 1;
|
|
let minFlash = 1;
|
|
let hasPro = false;
|
|
let hasFlash = false;
|
|
for (const bucket of data.buckets ?? []) {
|
|
const id = bucket.modelId?.toLowerCase() ?? "";
|
|
const remaining = typeof bucket.remainingFraction === "number" ? bucket.remainingFraction : 1;
|
|
if (id.includes("pro")) {
|
|
hasPro = true;
|
|
minPro = Math.min(minPro, remaining);
|
|
}
|
|
if (id.includes("flash")) {
|
|
hasFlash = true;
|
|
minFlash = Math.min(minFlash, remaining);
|
|
}
|
|
}
|
|
|
|
const windows: RateWindow[] = [];
|
|
if (hasPro) windows.push({ label: "Pro", usedPercent: clampPercent((1 - minPro) * 100) });
|
|
if (hasFlash) windows.push({ label: "Flash", usedPercent: clampPercent((1 - minFlash) * 100) });
|
|
if (windows.length === 0) throw new Error("no gemini usage windows");
|
|
|
|
const now = Date.now();
|
|
return {
|
|
provider: "gemini",
|
|
displayName: "Gemini Plan",
|
|
windows,
|
|
fetchedAt: now,
|
|
lastSuccessAt: now,
|
|
};
|
|
}
|
|
|
|
function parseInlineObject(raw: string): Record<string, unknown> {
|
|
const normalized = raw.replace(/([{,]\s*)([a-zA-Z_][a-zA-Z0-9_]*)(\s*:)/g, "$1\"$2\"$3");
|
|
return JSON.parse(normalized) as Record<string, unknown>;
|
|
}
|
|
|
|
async function fetchOpenCodeGoUsage(): Promise<UsageSnapshot> {
|
|
const { workspaceId, authCookie } = loadOpenCodeGoCredentials();
|
|
if (!workspaceId || !authCookie) throw new Error(`missing ${OPENCODE_CONFIG_FILE} credentials`);
|
|
if (!/^wrk_[a-zA-Z0-9]+$/.test(workspaceId)) throw new Error("invalid workspace id format");
|
|
|
|
const url = `https://opencode.ai/workspace/${encodeURIComponent(workspaceId)}/go`;
|
|
const response = await fetch(url, {
|
|
headers: {
|
|
"User-Agent": "Mozilla/5.0",
|
|
Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
|
|
Cookie: `auth=${authCookie}`,
|
|
},
|
|
});
|
|
if (!response.ok) throw new Error(`opencode-go http ${response.status}`);
|
|
|
|
const html = await response.text();
|
|
const patterns: Record<string, RegExp> = {
|
|
Rolling: /rollingUsage:\$R\[\d+\]=(\{[^}]+\})/,
|
|
Weekly: /weeklyUsage:\$R\[\d+\]=(\{[^}]+\})/,
|
|
Monthly: /monthlyUsage:\$R\[\d+\]=(\{[^}]+\})/,
|
|
};
|
|
|
|
const windows: RateWindow[] = [];
|
|
for (const [label, pattern] of Object.entries(patterns)) {
|
|
const match = html.match(pattern);
|
|
if (!match?.[1]) continue;
|
|
try {
|
|
const parsed = parseInlineObject(match[1]);
|
|
const usagePercent = clampPercent(Number(parsed.usagePercent));
|
|
const resetSec = Number(parsed.resetInSec);
|
|
const resetDescription = formatDuration(Number.isFinite(resetSec) ? resetSec : undefined);
|
|
const resetAt = Number.isFinite(resetSec) && resetSec > 0
|
|
? new Date(Date.now() + resetSec * 1000).toISOString()
|
|
: undefined;
|
|
windows.push({
|
|
label,
|
|
usedPercent: usagePercent,
|
|
resetDescription,
|
|
resetAt,
|
|
});
|
|
} catch {
|
|
// Ignore malformed chunks and keep parsing others
|
|
}
|
|
}
|
|
|
|
if (windows.length === 0) throw new Error("could not parse opencode-go usage from page");
|
|
|
|
const now = Date.now();
|
|
return {
|
|
provider: "opencode-go",
|
|
displayName: "OpenCode Go",
|
|
windows,
|
|
fetchedAt: now,
|
|
lastSuccessAt: now,
|
|
};
|
|
}
|
|
|
|
async function fetchUsage(provider: ProviderName): Promise<UsageSnapshot> {
|
|
switch (provider) {
|
|
case "anthropic":
|
|
return fetchAnthropicUsage();
|
|
case "codex":
|
|
return fetchCodexUsage();
|
|
case "gemini":
|
|
return fetchGeminiUsage();
|
|
case "opencode-go":
|
|
return fetchOpenCodeGoUsage();
|
|
}
|
|
}
|
|
|
|
export default function createSubBarLocal(pi: ExtensionAPI) {
|
|
let lastCtx: ExtensionContext | undefined;
|
|
let activeProvider: ProviderName | "auto" = "auto";
|
|
let widgetEnabled = true;
|
|
let barStyle: "thin" | "thick" = "thick";
|
|
let refreshTimer: NodeJS.Timeout | undefined;
|
|
let anthropicRetryAfter = 0;
|
|
const cache: Partial<Record<ProviderName, ProviderCache>> = {};
|
|
|
|
function getSelectedProvider(ctx?: ExtensionContext): ProviderName | undefined {
|
|
if (activeProvider !== "auto") return activeProvider;
|
|
return modelToProvider(ctx?.model?.provider);
|
|
}
|
|
|
|
function render(ctx: ExtensionContext): void {
|
|
if (!ctx.hasUI) return;
|
|
if (!widgetEnabled) {
|
|
ctx.ui.setWidget("sub-bar-local", undefined);
|
|
return;
|
|
}
|
|
const provider = getSelectedProvider(ctx);
|
|
if (!provider) {
|
|
ctx.ui.setWidget("sub-bar-local", undefined);
|
|
return;
|
|
}
|
|
const snapshot = cache[provider]?.usage;
|
|
|
|
const setWidgetWithPlacement = (ctx.ui as unknown as { setWidget: (...args: unknown[]) => void }).setWidget;
|
|
setWidgetWithPlacement(
|
|
"sub-bar-local",
|
|
(_tui: unknown, theme: Theme) => ({
|
|
render(width: number) {
|
|
const safeWidth = Math.max(1, width);
|
|
const topDivider = theme.fg("dim", "─".repeat(safeWidth));
|
|
if (!snapshot) {
|
|
const cooldown = provider === "anthropic" && anthropicRetryAfter > Date.now()
|
|
? formatDuration(Math.max(1, Math.floor((anthropicRetryAfter - Date.now()) / 1000)))
|
|
: undefined;
|
|
const text = cooldown
|
|
? `anthropic usage limited, retry in ${cooldown}`
|
|
: `sub bar loading ${provider} usage...`;
|
|
const loading = truncateToWidth(theme.fg("dim", text), safeWidth);
|
|
return [topDivider, padToWidth(loading, safeWidth)];
|
|
}
|
|
const cooldown = provider === "anthropic" && anthropicRetryAfter > Date.now()
|
|
? formatDuration(Math.max(1, Math.floor((anthropicRetryAfter - Date.now()) / 1000)))
|
|
: undefined;
|
|
const statusNote = snapshot.error
|
|
? snapshot.error
|
|
: cooldown
|
|
? `usage endpoint limited, retry in ${cooldown}`
|
|
: undefined;
|
|
const lines = formatUsageTwoLines(theme, snapshot, safeWidth, statusNote, barStyle);
|
|
const output = [topDivider, lines.top];
|
|
if (lines.bottom) output.push(lines.bottom);
|
|
return output;
|
|
},
|
|
invalidate() {},
|
|
}),
|
|
{ placement: "aboveEditor" },
|
|
);
|
|
}
|
|
|
|
async function refreshCurrent(ctx: ExtensionContext, force = false): Promise<void> {
|
|
const provider = getSelectedProvider(ctx);
|
|
if (!provider) {
|
|
ctx.ui.setWidget("sub-bar-local", undefined);
|
|
return;
|
|
}
|
|
if (provider === "anthropic" && anthropicRetryAfter > Date.now()) {
|
|
render(ctx);
|
|
return;
|
|
}
|
|
const cached = cache[provider]?.usage;
|
|
const ttl = provider === "anthropic" ? ANTHROPIC_CACHE_TTL_MS : CACHE_TTL_MS;
|
|
if (!force && cached && Date.now() - cached.fetchedAt < ttl) {
|
|
render(ctx);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const fresh = await fetchUsage(provider);
|
|
if (provider === "anthropic") {
|
|
anthropicRetryAfter = 0;
|
|
}
|
|
cache[provider] = {
|
|
usage: {
|
|
...fresh,
|
|
fromCache: false,
|
|
lastSuccessAt: Date.now(),
|
|
},
|
|
lastSuccessAt: Date.now(),
|
|
};
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : "fetch failed";
|
|
const fallback = cache[provider]?.usage;
|
|
const isAnthropic429 = provider === "anthropic" && message.includes("429");
|
|
|
|
if (isAnthropic429) {
|
|
anthropicRetryAfter = Date.now() + 30 * 60 * 1000;
|
|
}
|
|
|
|
if (isAnthropic429 && fallback) {
|
|
cache[provider] = {
|
|
usage: {
|
|
...fallback,
|
|
fetchedAt: Date.now(),
|
|
fromCache: true,
|
|
},
|
|
lastSuccessAt: cache[provider]?.lastSuccessAt,
|
|
};
|
|
} else if (isAnthropic429) {
|
|
delete cache[provider];
|
|
} else {
|
|
cache[provider] = {
|
|
usage: {
|
|
provider,
|
|
displayName: fallback?.displayName ?? provider,
|
|
windows: fallback?.windows ?? [],
|
|
error: message,
|
|
fetchedAt: Date.now(),
|
|
lastSuccessAt: cache[provider]?.lastSuccessAt,
|
|
fromCache: Boolean(fallback),
|
|
},
|
|
lastSuccessAt: cache[provider]?.lastSuccessAt,
|
|
};
|
|
}
|
|
}
|
|
|
|
render(ctx);
|
|
}
|
|
|
|
function startRefreshLoop(ctx: ExtensionContext): void {
|
|
if (refreshTimer) clearInterval(refreshTimer);
|
|
refreshTimer = setInterval(() => {
|
|
if (!lastCtx) return;
|
|
void refreshCurrent(lastCtx);
|
|
}, REFRESH_MS);
|
|
refreshTimer.unref?.();
|
|
void refreshCurrent(ctx, true);
|
|
}
|
|
|
|
pi.registerCommand("sub:refresh", {
|
|
description: "Refresh sub bar usage now",
|
|
handler: async (_args, ctx) => {
|
|
await refreshCurrent(ctx, true);
|
|
},
|
|
});
|
|
|
|
pi.registerCommand("sub:provider", {
|
|
description: "Set sub bar provider (auto|anthropic|codex|gemini|opencode-go)",
|
|
handler: async (args, ctx) => {
|
|
const raw = String(args ?? "").trim().toLowerCase();
|
|
if (!raw || raw === "auto") {
|
|
activeProvider = "auto";
|
|
ctx.ui.notify("sub bar provider: auto", "info");
|
|
await refreshCurrent(ctx, true);
|
|
return;
|
|
}
|
|
if (PROVIDER_ORDER.includes(raw as ProviderName)) {
|
|
activeProvider = raw as ProviderName;
|
|
ctx.ui.notify(`sub bar provider: ${activeProvider}`, "info");
|
|
await refreshCurrent(ctx, true);
|
|
return;
|
|
}
|
|
ctx.ui.notify("invalid provider. use: auto|anthropic|codex|gemini|opencode-go", "warning");
|
|
},
|
|
});
|
|
|
|
pi.registerCommand("sub:toggle", {
|
|
description: "Toggle sub bar on/off",
|
|
handler: async (_args, ctx) => {
|
|
widgetEnabled = !widgetEnabled;
|
|
await showToggleState(ctx, widgetEnabled, async () => refreshCurrent(ctx, true));
|
|
},
|
|
});
|
|
|
|
pi.registerShortcut(SHORTCUT_TOGGLE as import("@mariozechner/pi-tui").KeyId, {
|
|
description: "Toggle sub bar on/off",
|
|
handler: async (ctx) => {
|
|
widgetEnabled = !widgetEnabled;
|
|
await showToggleState(ctx, widgetEnabled, async () => refreshCurrent(ctx, true));
|
|
},
|
|
});
|
|
|
|
pi.registerCommand("sub:bars", {
|
|
description: "Set sub bar style (thin|thick|toggle)",
|
|
handler: async (args, ctx) => {
|
|
const raw = String(args ?? "").trim().toLowerCase();
|
|
if (!raw || raw === "toggle") {
|
|
barStyle = barStyle === "thin" ? "thick" : "thin";
|
|
} else if (raw === "thin" || raw === "thick") {
|
|
barStyle = raw;
|
|
} else {
|
|
ctx.ui.notify("invalid style. use: thin|thick|toggle", "warning");
|
|
return;
|
|
}
|
|
ctx.ui.notify(`sub bar style: ${barStyle}`, "info");
|
|
render(ctx);
|
|
},
|
|
});
|
|
|
|
pi.registerShortcut(SHORTCUT_BAR_STYLE as import("@mariozechner/pi-tui").KeyId, {
|
|
description: "Toggle sub bar bar style",
|
|
handler: async (ctx) => {
|
|
barStyle = barStyle === "thin" ? "thick" : "thin";
|
|
ctx.ui.notify(`sub bar style: ${barStyle}`, "info");
|
|
render(ctx);
|
|
},
|
|
});
|
|
|
|
pi.on("session_start", async (_event, ctx) => {
|
|
lastCtx = ctx;
|
|
if (!ctx.hasUI) return;
|
|
render(ctx);
|
|
startRefreshLoop(ctx);
|
|
});
|
|
|
|
pi.on("model_select", async (_event, ctx) => {
|
|
lastCtx = ctx;
|
|
if (!ctx.hasUI) return;
|
|
render(ctx);
|
|
if (activeProvider === "auto") {
|
|
await refreshCurrent(ctx, false);
|
|
}
|
|
});
|
|
|
|
pi.on("session_shutdown", async () => {
|
|
lastCtx = undefined;
|
|
if (refreshTimer) {
|
|
clearInterval(refreshTimer);
|
|
refreshTimer = undefined;
|
|
}
|
|
});
|
|
}
|