@eiei114/pi-sub-core 1.5.1

package/src/providers/impl/codex.ts

@@ -0,0 +1,186 @@
+/**
+ * OpenAI Codex usage provider
+ */
+
+import * as path from "node:path";
+import type { Dependencies, RateWindow, UsageSnapshot } from "../../types.js";
+import { BaseProvider } from "../../provider.js";
+import { noCredentials, fetchFailed, httpError } from "../../errors.js";
+import { formatReset, createTimeoutController } from "../../utils.js";
+import { API_TIMEOUT_MS } from "../../config.js";
+
+interface CodexRateWindow {
+	reset_at?: number;
+	limit_window_seconds?: number;
+	used_percent?: number;
+}
+
+interface CodexRateLimit {
+	primary_window?: CodexRateWindow;
+	secondary_window?: CodexRateWindow;
+}
+
+interface CodexAdditionalRateLimit {
+	limit_name?: string;
+	metered_feature?: string;
+	rate_limit?: CodexRateLimit;
+}
+
+/**
+ * Load Codex credentials from auth.json
+ * First tries pi's auth.json, then falls back to legacy codex location
+ */
+function loadCodexCredentials(deps: Dependencies): { accessToken?: string; accountId?: string } {
+	// Explicit override via env var
+	const envAccessToken = (
+		deps.env.OPENAI_CODEX_OAUTH_TOKEN ||
+		deps.env.OPENAI_CODEX_ACCESS_TOKEN ||
+		deps.env.CODEX_OAUTH_TOKEN ||
+		deps.env.CODEX_ACCESS_TOKEN
+	)?.trim();
+	const envAccountId = (deps.env.OPENAI_CODEX_ACCOUNT_ID || deps.env.CHATGPT_ACCOUNT_ID)?.trim();
+	if (envAccessToken) {
+		return { accessToken: envAccessToken, accountId: envAccountId || undefined };
+	}
+
+	// Try pi's auth.json first
+	const piAuthPath = path.join(deps.homedir(), ".pi", "agent", "auth.json");
+	try {
+		if (deps.fileExists(piAuthPath)) {
+			const data = JSON.parse(deps.readFile(piAuthPath) ?? "{}");
+			if (data["openai-codex"]?.access) {
+				return {
+					accessToken: data["openai-codex"].access,
+					accountId: data["openai-codex"].accountId,
+				};
+			}
+		}
+	} catch {
+		// Ignore parse errors, try legacy location
+	}
+
+	// Fall back to legacy codex location
+	const codexHome = deps.env.CODEX_HOME || path.join(deps.homedir(), ".codex");
+	const authPath = path.join(codexHome, "auth.json");
+	try {
+		if (deps.fileExists(authPath)) {
+			const data = JSON.parse(deps.readFile(authPath) ?? "{}");
+			if (data.OPENAI_API_KEY) {
+				return { accessToken: data.OPENAI_API_KEY };
+			} else if (data.tokens?.access_token) {
+				return {
+					accessToken: data.tokens.access_token,
+					accountId: data.tokens.account_id,
+				};
+			}
+		}
+	} catch {
+		// Ignore parse errors
+	}
+
+	return {};
+}
+
+function getWindowLabel(windowSeconds?: number, fallbackWindowSeconds?: number): string {
+	const safeWindowSeconds =
+		typeof windowSeconds === "number" && windowSeconds > 0
+			? windowSeconds
+			: typeof fallbackWindowSeconds === "number" && fallbackWindowSeconds > 0
+				? fallbackWindowSeconds
+				: 0;
+	if (!safeWindowSeconds) {
+		return "0h";
+	}
+	const windowHours = Math.round(safeWindowSeconds / 3600);
+	if (windowHours >= 144) return "Week";
+	if (windowHours >= 24) return "Day";
+	return `${windowHours}h`;
+}
+
+function pushWindow(
+	windows: RateWindow[],
+	prefix: string | undefined,
+	window: CodexRateWindow | undefined,
+	fallbackWindowSeconds?: number
+): void {
+	if (!window) return;
+	const resetDate = window.reset_at ? new Date(window.reset_at * 1000) : undefined;
+	const label = getWindowLabel(window.limit_window_seconds, fallbackWindowSeconds);
+	const windowLabel = prefix ? `${prefix} ${label}` : label;
+	windows.push({
+		label: windowLabel,
+		usedPercent: window.used_percent || 0,
+		resetDescription: resetDate ? formatReset(resetDate) : undefined,
+		resetAt: resetDate?.toISOString(),
+	});
+}
+
+function addRateWindows(windows: RateWindow[], rateLimit: CodexRateLimit | undefined, prefix?: string): void {
+	pushWindow(windows, prefix, rateLimit?.primary_window, 10800);
+	pushWindow(windows, prefix, rateLimit?.secondary_window, 86400);
+}
+
+export class CodexProvider extends BaseProvider {
+	readonly name = "codex" as const;
+	readonly displayName = "Codex Plan";
+
+	hasCredentials(deps: Dependencies): boolean {
+		return Boolean(loadCodexCredentials(deps).accessToken);
+	}
+
+	async fetchUsage(deps: Dependencies): Promise<UsageSnapshot> {
+		const { accessToken, accountId } = loadCodexCredentials(deps);
+		if (!accessToken) {
+			return this.emptySnapshot(noCredentials());
+		}
+
+		const { controller, clear } = createTimeoutController(API_TIMEOUT_MS);
+
+		try {
+			const headers: Record<string, string> = {
+				Authorization: `Bearer ${accessToken}`,
+				Accept: "application/json",
+			};
+			if (accountId) {
+				headers["ChatGPT-Account-Id"] = accountId;
+			}
+
+			const res = await deps.fetch("https://chatgpt.com/backend-api/wham/usage", {
+				headers,
+				signal: controller.signal,
+			});
+			clear();
+
+			if (!res.ok) {
+				return this.emptySnapshot(httpError(res.status));
+			}
+
+			const data = (await res.json()) as {
+				rate_limit?: CodexRateLimit;
+				additional_rate_limits?: CodexAdditionalRateLimit[];
+			};
+
+			const windows: RateWindow[] = [];
+			addRateWindows(windows, data.rate_limit);
+
+			if (Array.isArray(data.additional_rate_limits)) {
+				for (const entry of data.additional_rate_limits) {
+					if (!entry || typeof entry !== "object") continue;
+					const prefix =
+						typeof entry.limit_name === "string" && entry.limit_name.trim().length > 0
+							? entry.limit_name.trim()
+							: typeof entry.metered_feature === "string" && entry.metered_feature.trim().length > 0
+								? entry.metered_feature.trim()
+								: "Additional";
+					addRateWindows(windows, entry.rate_limit, prefix);
+				}
+			}
+
+			return this.snapshot({ windows });
+		} catch {
+			clear();
+			return this.emptySnapshot(fetchFailed());
+		}
+	}
+
+}

package/src/providers/impl/copilot.ts

@@ -0,0 +1,176 @@
+/**
+ * GitHub Copilot usage provider
+ */
+
+import * as path from "node:path";
+import type { Dependencies, RateWindow, UsageSnapshot } from "../../types.js";
+import { BaseProvider } from "../../provider.js";
+import { noCredentials, fetchFailed, httpError } from "../../errors.js";
+import { formatReset, createTimeoutController } from "../../utils.js";
+import { API_TIMEOUT_MS } from "../../config.js";
+
+/**
+ * Copilot token entries stored by legacy GitHub Copilot CLI
+ */
+type CopilotHostEntry = {
+	oauth_token?: string;
+	user_token?: string;
+	github_token?: string;
+	token?: string;
+};
+
+const COPILOT_TOKEN_KEYS: Array<keyof CopilotHostEntry> = [
+	"oauth_token",
+	"user_token",
+	"github_token",
+	"token",
+];
+
+function getTokenFromHostEntry(entry: CopilotHostEntry | undefined): string | undefined {
+	if (!entry) return undefined;
+	for (const key of COPILOT_TOKEN_KEYS) {
+		const value = entry[key];
+		if (typeof value === "string" && value.length > 0) {
+			return value;
+		}
+	}
+	return undefined;
+}
+
+function loadLegacyCopilotToken(deps: Dependencies): string | undefined {
+	const configHome = deps.env.XDG_CONFIG_HOME || path.join(deps.homedir(), ".config");
+	const legacyPaths = [
+		path.join(configHome, "github-copilot", "hosts.json"),
+		path.join(deps.homedir(), ".github-copilot", "hosts.json"),
+	];
+
+	for (const hostsPath of legacyPaths) {
+		try {
+			if (!deps.fileExists(hostsPath)) continue;
+			const data = JSON.parse(deps.readFile(hostsPath) ?? "{}");
+			if (!data || typeof data !== "object") continue;
+
+			const normalizedHosts: Record<string, CopilotHostEntry> = {};
+			for (const [host, entry] of Object.entries(data as Record<string, CopilotHostEntry>)) {
+				normalizedHosts[host.toLowerCase()] = entry;
+			}
+
+			const preferredToken =
+				getTokenFromHostEntry(normalizedHosts["github.com"]) ||
+				getTokenFromHostEntry(normalizedHosts["api.github.com"]);
+			if (preferredToken) return preferredToken;
+
+			for (const entry of Object.values(normalizedHosts)) {
+				const token = getTokenFromHostEntry(entry);
+				if (token) return token;
+			}
+		} catch {
+			// Ignore parse errors
+		}
+	}
+
+	return undefined;
+}
+
+/**
+ * Load Copilot token from pi auth.json first, then fallback to legacy locations.
+ */
+function loadCopilotToken(deps: Dependencies): string | undefined {
+	// Explicit override via env var
+	const envToken = (deps.env.COPILOT_GITHUB_TOKEN || deps.env.GH_TOKEN || deps.env.GITHUB_TOKEN || deps.env.COPILOT_TOKEN)?.trim();
+	if (envToken) return envToken;
+
+	const authPath = path.join(deps.homedir(), ".pi", "agent", "auth.json");
+	try {
+		if (deps.fileExists(authPath)) {
+			const data = JSON.parse(deps.readFile(authPath) ?? "{}");
+			// Prefer refresh token (GitHub access token) for GitHub API endpoints.
+			const piToken = data["github-copilot"]?.refresh || data["github-copilot"]?.access;
+			if (typeof piToken === "string" && piToken.length > 0) return piToken;
+		}
+	} catch {
+		// Ignore parse errors
+	}
+
+	return loadLegacyCopilotToken(deps);
+}
+
+export class CopilotProvider extends BaseProvider {
+	readonly name = "copilot" as const;
+	readonly displayName = "Copilot Plan";
+
+	hasCredentials(deps: Dependencies): boolean {
+		return Boolean(loadCopilotToken(deps));
+	}
+
+	async fetchUsage(deps: Dependencies): Promise<UsageSnapshot> {
+		const token = loadCopilotToken(deps);
+		if (!token) {
+			return this.emptySnapshot(noCredentials());
+		}
+
+		const { controller, clear } = createTimeoutController(API_TIMEOUT_MS);
+
+		try {
+			const res = await deps.fetch("https://api.github.com/copilot_internal/user", {
+				headers: {
+					"Editor-Version": "vscode/1.96.2",
+					"User-Agent": "GitHubCopilotChat/0.26.7",
+					"X-Github-Api-Version": "2025-04-01",
+					Accept: "application/json",
+					Authorization: `token ${token}`,
+				},
+				signal: controller.signal,
+			});
+			clear();
+
+			if (!res.ok) {
+				return this.emptySnapshot(httpError(res.status));
+			}
+
+			const data = (await res.json()) as {
+				quota_reset_date_utc?: string;
+				quota_snapshots?: {
+					premium_interactions?: {
+						percent_remaining?: number;
+						remaining?: number;
+						entitlement?: number;
+					};
+				};
+			};
+
+			const windows: RateWindow[] = [];
+			const resetDate = data.quota_reset_date_utc ? new Date(data.quota_reset_date_utc) : undefined;
+			const resetDesc = resetDate ? formatReset(resetDate) : undefined;
+
+			let requestsRemaining: number | undefined;
+			let requestsEntitlement: number | undefined;
+
+			if (data.quota_snapshots?.premium_interactions) {
+				const pi = data.quota_snapshots.premium_interactions;
+				const monthUsedPercent = Math.max(0, 100 - (pi.percent_remaining || 0));
+				windows.push({
+					label: "Month",
+					usedPercent: monthUsedPercent,
+					resetDescription: resetDesc,
+					resetAt: resetDate?.toISOString(),
+				});
+
+				const remaining = pi.remaining ?? 0;
+				const entitlement = pi.entitlement ?? 0;
+				requestsRemaining = remaining;
+				requestsEntitlement = entitlement;
+			}
+
+			return this.snapshot({
+				windows,
+				requestsRemaining,
+				requestsEntitlement,
+			});
+		} catch {
+			clear();
+			return this.emptySnapshot(fetchFailed());
+		}
+	}
+
+}

package/src/providers/impl/gemini.ts

@@ -0,0 +1,130 @@
+/**
+ * Google Gemini usage provider
+ */
+
+import * as path from "node:path";
+import type { Dependencies, RateWindow, UsageSnapshot } from "../../types.js";
+import { BaseProvider } from "../../provider.js";
+import { noCredentials, fetchFailed, httpError } from "../../errors.js";
+import { createTimeoutController } from "../../utils.js";
+import { API_TIMEOUT_MS } from "../../config.js";
+
+/**
+ * Load Gemini access token from various sources
+ */
+function loadGeminiToken(deps: Dependencies): string | undefined {
+	// Explicit override via env var
+	const envToken = (
+		deps.env.GOOGLE_GEMINI_CLI_OAUTH_TOKEN ||
+		deps.env.GOOGLE_GEMINI_CLI_ACCESS_TOKEN ||
+		deps.env.GEMINI_OAUTH_TOKEN ||
+		deps.env.GOOGLE_GEMINI_OAUTH_TOKEN
+	)?.trim();
+	if (envToken) return envToken;
+
+	// Try pi auth.json first
+	const piAuthPath = path.join(deps.homedir(), ".pi", "agent", "auth.json");
+	try {
+		if (deps.fileExists(piAuthPath)) {
+			const data = JSON.parse(deps.readFile(piAuthPath) ?? "{}");
+			if (data["google-gemini-cli"]?.access) return data["google-gemini-cli"].access;
+		}
+	} catch {
+		// Ignore parse errors
+	}
+
+	// Try ~/.gemini/oauth_creds.json
+	const credPath = path.join(deps.homedir(), ".gemini", "oauth_creds.json");
+	try {
+		if (deps.fileExists(credPath)) {
+			const data = JSON.parse(deps.readFile(credPath) ?? "{}");
+			if (data.access_token) return data.access_token;
+		}
+	} catch {
+		// Ignore parse errors
+	}
+
+	return undefined;
+}
+
+export class GeminiProvider extends BaseProvider {
+	readonly name = "gemini" as const;
+	readonly displayName = "Gemini Plan";
+
+	hasCredentials(deps: Dependencies): boolean {
+		return Boolean(loadGeminiToken(deps));
+	}
+
+	async fetchUsage(deps: Dependencies): Promise<UsageSnapshot> {
+		const token = loadGeminiToken(deps);
+		if (!token) {
+			return this.emptySnapshot(noCredentials());
+		}
+
+		const { controller, clear } = createTimeoutController(API_TIMEOUT_MS);
+
+		try {
+			const res = await deps.fetch("https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota", {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${token}`,
+					"Content-Type": "application/json",
+				},
+				body: "{}",
+				signal: controller.signal,
+			});
+			clear();
+
+			if (!res.ok) {
+				return this.emptySnapshot(httpError(res.status));
+			}
+
+			const data = (await res.json()) as {
+				buckets?: Array<{
+					modelId?: string;
+					remainingFraction?: number;
+				}>;
+			};
+
+			// Aggregate quotas by model type
+			const quotas: Record<string, number> = {};
+			for (const bucket of data.buckets || []) {
+				const model = bucket.modelId || "unknown";
+				const frac = bucket.remainingFraction ?? 1;
+				if (!quotas[model] || frac < quotas[model]) {
+					quotas[model] = frac;
+				}
+			}
+
+			const windows: RateWindow[] = [];
+			let proMin = 1;
+			let flashMin = 1;
+			let hasProModel = false;
+			let hasFlashModel = false;
+
+			for (const [model, frac] of Object.entries(quotas)) {
+				if (model.toLowerCase().includes("pro")) {
+					hasProModel = true;
+					if (frac < proMin) proMin = frac;
+				}
+				if (model.toLowerCase().includes("flash")) {
+					hasFlashModel = true;
+					if (frac < flashMin) flashMin = frac;
+				}
+			}
+
+			if (hasProModel) {
+				windows.push({ label: "Pro", usedPercent: (1 - proMin) * 100 });
+			}
+			if (hasFlashModel) {
+				windows.push({ label: "Flash", usedPercent: (1 - flashMin) * 100 });
+			}
+
+			return this.snapshot({ windows });
+		} catch {
+			clear();
+			return this.emptySnapshot(fetchFailed());
+		}
+	}
+
+}

package/src/providers/impl/kiro.ts

@@ -0,0 +1,92 @@
+/**
+ * AWS Kiro usage provider
+ */
+
+import type { Dependencies, RateWindow, UsageSnapshot } from "../../types.js";
+import { BaseProvider } from "../../provider.js";
+import { noCli, notLoggedIn, fetchFailed } from "../../errors.js";
+import { formatReset, stripAnsi, whichSync } from "../../utils.js";
+import { CLI_TIMEOUT_MS } from "../../config.js";
+
+export class KiroProvider extends BaseProvider {
+	readonly name = "kiro" as const;
+	readonly displayName = "Kiro Plan";
+
+	hasCredentials(deps: Dependencies): boolean {
+		return Boolean(whichSync("kiro-cli", deps));
+	}
+
+	async fetchUsage(deps: Dependencies): Promise<UsageSnapshot> {
+		const kiroBinary = whichSync("kiro-cli", deps);
+		if (!kiroBinary) {
+			return this.emptySnapshot(noCli("kiro-cli"));
+		}
+
+		try {
+			// Check if logged in
+			try {
+				deps.execFileSync(kiroBinary, ["whoami"], {
+					encoding: "utf-8",
+					timeout: API_TIMEOUT_MS,
+					stdio: ["ignore", "pipe", "pipe"],
+				});
+			} catch {
+				return this.emptySnapshot(notLoggedIn());
+			}
+
+			// Get usage
+			const output = deps.execFileSync(kiroBinary, ["chat", "--no-interactive", "/usage"], {
+				encoding: "utf-8",
+				timeout: CLI_TIMEOUT_MS,
+				env: { ...deps.env, TERM: "xterm-256color" },
+				stdio: ["ignore", "pipe", "pipe"],
+			});
+
+			const stripped = stripAnsi(output);
+			const windows: RateWindow[] = [];
+
+			// Parse credits percentage from "████...█ X%"
+			let creditsPercent = 0;
+			const percentMatch = stripped.match(/█+\s*(\d+)%/);
+			if (percentMatch) {
+				creditsPercent = parseInt(percentMatch[1], 10);
+			}
+
+			// Parse credits used/total from "(X.XX of Y covered in plan)"
+			const creditsMatch = stripped.match(/\((\d+\.?\d*)\s+of\s+(\d+)\s+covered/);
+			if (creditsMatch && !percentMatch) {
+				const creditsUsed = parseFloat(creditsMatch[1]);
+				const creditsTotal = parseFloat(creditsMatch[2]);
+				if (creditsTotal > 0) {
+					creditsPercent = (creditsUsed / creditsTotal) * 100;
+				}
+			}
+
+			// Parse reset date from "resets on 01/01"
+			let resetsAt: Date | undefined;
+			const resetMatch = stripped.match(/resets on (\d{2}\/\d{2})/);
+			if (resetMatch) {
+				const [month, day] = resetMatch[1].split("/").map(Number);
+				const now = new Date();
+				const year = now.getFullYear();
+				resetsAt = new Date(year, month - 1, day);
+				if (resetsAt < now) resetsAt.setFullYear(year + 1);
+			}
+
+			windows.push({
+				label: "Credits",
+				usedPercent: creditsPercent,
+				resetDescription: resetsAt ? formatReset(resetsAt) : undefined,
+				resetAt: resetsAt?.toISOString(),
+			});
+
+			return this.snapshot({ windows });
+		} catch {
+			return this.emptySnapshot(fetchFailed());
+		}
+	}
+
+	// Kiro doesn't have a public status page
+}
+
+const API_TIMEOUT_MS = 5000;

package/src/providers/impl/zai.ts

@@ -0,0 +1,120 @@
+/**
+ * z.ai usage provider
+ */
+
+import * as path from "node:path";
+import type { Dependencies, RateWindow, UsageSnapshot } from "../../types.js";
+import { BaseProvider } from "../../provider.js";
+import { noCredentials, fetchFailed, httpError, apiError } from "../../errors.js";
+import { formatReset, createTimeoutController } from "../../utils.js";
+import { API_TIMEOUT_MS } from "../../config.js";
+
+/**
+ * Load z.ai API key from environment or auth.json
+ */
+function loadZaiApiKey(deps: Dependencies): string | undefined {
+	// Try environment variable first
+	if (deps.env.ZAI_API_KEY) {
+		return deps.env.ZAI_API_KEY;
+	}
+	if (deps.env.Z_AI_API_KEY) {
+		return deps.env.Z_AI_API_KEY;
+	}
+
+	// Try pi auth.json
+	const authPath = path.join(deps.homedir(), ".pi", "agent", "auth.json");
+	try {
+		if (deps.fileExists(authPath)) {
+			const auth = JSON.parse(deps.readFile(authPath) ?? "{}");
+			return auth["z-ai"]?.access || auth["z-ai"]?.key || auth["zai"]?.access || auth["zai"]?.key;
+		}
+	} catch {
+		// Ignore parse errors
+	}
+
+	return undefined;
+}
+
+export class ZaiProvider extends BaseProvider {
+	readonly name = "zai" as const;
+	readonly displayName = "z.ai Plan";
+
+	hasCredentials(deps: Dependencies): boolean {
+		return Boolean(loadZaiApiKey(deps));
+	}
+
+	async fetchUsage(deps: Dependencies): Promise<UsageSnapshot> {
+		const apiKey = loadZaiApiKey(deps);
+		if (!apiKey) {
+			return this.emptySnapshot(noCredentials());
+		}
+
+		const { controller, clear } = createTimeoutController(API_TIMEOUT_MS);
+
+		try {
+			const res = await deps.fetch("https://api.z.ai/api/monitor/usage/quota/limit", {
+				method: "GET",
+				headers: {
+					Authorization: `Bearer ${apiKey}`,
+					Accept: "application/json",
+				},
+				signal: controller.signal,
+			});
+			clear();
+
+			if (!res.ok) {
+				return this.emptySnapshot(httpError(res.status));
+			}
+
+			const data = (await res.json()) as {
+				success?: boolean;
+				code?: number;
+				msg?: string;
+				data?: {
+					limits?: Array<{
+						type?: string;
+						unit?: number;
+						number?: number;
+						percentage?: number;
+						nextResetTime?: string;
+					}>;
+				};
+			};
+
+			if (!data.success || data.code !== 200) {
+				return this.emptySnapshot(apiError(data.msg || "API error"));
+			}
+
+			const windows: RateWindow[] = [];
+			const limits = data.data?.limits || [];
+
+			for (const limit of limits) {
+				const percent = limit.percentage || 0;
+				const nextReset = limit.nextResetTime ? new Date(limit.nextResetTime) : undefined;
+
+				if (limit.type === "TOKENS_LIMIT") {
+					windows.push({
+						label: "Tokens",
+						usedPercent: percent,
+						resetDescription: nextReset ? formatReset(nextReset) : undefined,
+						resetAt: nextReset?.toISOString(),
+					});
+				} else if (limit.type === "TIME_LIMIT") {
+					windows.push({
+						label: "Monthly",
+						usedPercent: percent,
+						resetDescription: nextReset ? formatReset(nextReset) : undefined,
+						resetAt: nextReset?.toISOString(),
+					});
+				}
+			}
+
+			return this.snapshot({ windows });
+		} catch {
+			clear();
+			return this.emptySnapshot(fetchFailed());
+		}
+	}
+
+	// z.ai doesn't have a public status page
+}

package/src/providers/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Provider registry exports.
+ */
+
+export * from "./registry.js";