@eiei114/pi-sub-core 1.5.1

package/src/paths.ts

@@ -0,0 +1,55 @@
+/**
+ * Shared path helpers for sub-core storage.
+ */
+
+import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SETTINGS_FILE_NAME = "pi-sub-core-settings.json";
+const CACHE_DIR_NAME = "cache";
+const CACHE_NAMESPACE_DIR = "sub-core";
+const CACHE_FILE_NAME = "cache.json";
+const CACHE_LOCK_FILE_NAME = "cache.lock";
+const LEGACY_AGENT_CACHE_FILE_NAME = "pi-sub-core-cache.json";
+const LEGACY_AGENT_LOCK_FILE_NAME = "pi-sub-core-cache.lock";
+
+export function getExtensionDir(): string {
+	return join(dirname(fileURLToPath(import.meta.url)), "..");
+}
+
+export function getCacheDir(): string {
+	return join(getAgentDir(), CACHE_DIR_NAME, CACHE_NAMESPACE_DIR);
+}
+
+export function getCachePath(): string {
+	return join(getCacheDir(), CACHE_FILE_NAME);
+}
+
+export function getCacheLockPath(): string {
+	return join(getCacheDir(), CACHE_LOCK_FILE_NAME);
+}
+
+export function getLegacyCachePath(): string {
+	return join(getExtensionDir(), "cache.json");
+}
+
+export function getLegacyCacheLockPath(): string {
+	return join(getExtensionDir(), "cache.lock");
+}
+
+export function getLegacyAgentCachePath(): string {
+	return join(getAgentDir(), LEGACY_AGENT_CACHE_FILE_NAME);
+}
+
+export function getLegacyAgentCacheLockPath(): string {
+	return join(getAgentDir(), LEGACY_AGENT_LOCK_FILE_NAME);
+}
+
+export function getSettingsPath(): string {
+	return join(getAgentDir(), SETTINGS_FILE_NAME);
+}
+
+export function getLegacySettingsPath(): string {
+	return join(getExtensionDir(), "settings.json");
+}

package/src/provider.ts

@@ -0,0 +1,66 @@
+/**
+ * Provider interface and registry
+ */
+
+import type { Dependencies, ProviderName, ProviderStatus, UsageSnapshot } from "./types.js";
+
+/**
+ * Interface for a usage provider
+ */
+export interface UsageProvider {
+	readonly name: ProviderName;
+	readonly displayName: string;
+
+	/**
+	 * Fetch current usage data for this provider
+	 */
+	fetchUsage(deps: Dependencies): Promise<UsageSnapshot>;
+
+	/**
+	 * Fetch current status for this provider (optional)
+	 */
+	fetchStatus?(deps: Dependencies): Promise<ProviderStatus>;
+
+	/**
+	 * Check if credentials are available (optional)
+	 */
+	hasCredentials?(deps: Dependencies): boolean;
+}
+
+/**
+ * Base class for providers with common functionality
+ */
+export abstract class BaseProvider implements UsageProvider {
+	abstract readonly name: ProviderName;
+	abstract readonly displayName: string;
+
+	abstract fetchUsage(deps: Dependencies): Promise<UsageSnapshot>;
+
+	hasCredentials(_deps: Dependencies): boolean {
+		return true;
+	}
+
+	/**
+	 * Create an empty snapshot with an error
+	 */
+	protected emptySnapshot(error?: import("./types.js").UsageError): UsageSnapshot {
+		return {
+			provider: this.name,
+			displayName: this.displayName,
+			windows: [],
+			error,
+		};
+	}
+
+	/**
+	 * Create a snapshot with usage data
+	 */
+	protected snapshot(data: Partial<Omit<UsageSnapshot, "provider" | "displayName">>): UsageSnapshot {
+		return {
+			provider: this.name,
+			displayName: this.displayName,
+			windows: [],
+			...data,
+		};
+	}
+}

package/src/providers/detection.ts

@@ -0,0 +1,51 @@
+/**
+ * Provider detection helpers.
+ */
+
+import type { ProviderName } from "../types.js";
+import { PROVIDERS } from "../types.js";
+import { PROVIDER_METADATA } from "./metadata.js";
+
+interface ProviderDetectionHint {
+	provider: ProviderName;
+	providerTokens: string[];
+	modelTokens: string[];
+}
+
+const PROVIDER_DETECTION_HINTS: ProviderDetectionHint[] = PROVIDERS.map((provider) => {
+	const detection = PROVIDER_METADATA[provider].detection ?? { providerTokens: [], modelTokens: [] };
+	return {
+		provider,
+		providerTokens: detection.providerTokens,
+		modelTokens: detection.modelTokens,
+	};
+});
+
+/**
+ * Detect the provider from model metadata.
+ */
+export function detectProviderFromModel(
+	model: { provider?: string; id?: string } | undefined
+): ProviderName | undefined {
+	if (!model) return undefined;
+	const providerValue = model.provider?.toLowerCase() || "";
+	const idValue = model.id?.toLowerCase() || "";
+
+	if (providerValue.includes("antigravity") || idValue.includes("antigravity")) {
+		return "antigravity";
+	}
+
+	for (const hint of PROVIDER_DETECTION_HINTS) {
+		if (hint.providerTokens.some((token) => providerValue.includes(token))) {
+			return hint.provider;
+		}
+	}
+
+	for (const hint of PROVIDER_DETECTION_HINTS) {
+		if (hint.modelTokens.some((token) => idValue.includes(token))) {
+			return hint.provider;
+		}
+	}
+
+	return undefined;
+}

package/src/providers/impl/anthropic.ts

@@ -0,0 +1,174 @@
+/**
+ * Anthropic/Claude 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";
+import { getSettings } from "../../settings.js";
+
+/**
+ * Load Claude API token from various sources
+ */
+function loadClaudeToken(deps: Dependencies): string | undefined {
+	// Explicit override via env var (useful in CI / menu bar apps)
+	const envToken = deps.env.ANTHROPIC_OAUTH_TOKEN?.trim();
+	if (envToken) return envToken;
+
+	// Try pi auth.json next
+	const piAuthPath = path.join(deps.homedir(), ".pi", "agent", "auth.json");
+	try {
+		if (deps.fileExists(piAuthPath)) {
+			const data = JSON.parse(deps.readFile(piAuthPath) ?? "{}");
+			if (data.anthropic?.access) return data.anthropic.access;
+		}
+	} catch {
+		// Ignore parse errors
+	}
+
+	// Try macOS Keychain (Claude Code credentials)
+	try {
+		const keychainData = deps.execFileSync(
+			"security",
+			["find-generic-password", "-s", "Claude Code-credentials", "-w"],
+			{ encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+		).trim();
+		if (keychainData) {
+			const parsed = JSON.parse(keychainData);
+			const scopes = parsed.claudeAiOauth?.scopes || [];
+			if (scopes.includes("user:profile") && parsed.claudeAiOauth?.accessToken) {
+				return parsed.claudeAiOauth.accessToken;
+			}
+		}
+	} catch {
+		// Keychain access failed
+	}
+
+	return undefined;
+}
+
+type ExtraUsageFormat = {
+	symbol: string;
+	decimalSeparator: "." | ",";
+};
+
+function getExtraUsageFormat(): ExtraUsageFormat {
+	const settings = getSettings();
+	const providerSettings = settings.providers.anthropic;
+	return {
+		symbol: providerSettings.extraUsageCurrencySymbol?.trim() ?? "",
+		decimalSeparator: providerSettings.extraUsageDecimalSeparator === "," ? "," : ".",
+	};
+}
+
+function formatExtraUsageCredits(credits: number, format: ExtraUsageFormat): string {
+	const amount = (credits / 100).toFixed(2);
+	const formatted = format.decimalSeparator === "," ? amount.replace(".", ",") : amount;
+	return format.symbol ? `${format.symbol}${formatted}` : formatted;
+}
+
+
+export class AnthropicProvider extends BaseProvider {
+	readonly name = "anthropic" as const;
+	readonly displayName = "Claude Plan";
+
+	hasCredentials(deps: Dependencies): boolean {
+		return Boolean(loadClaudeToken(deps));
+	}
+
+	async fetchUsage(deps: Dependencies): Promise<UsageSnapshot> {
+		const token = loadClaudeToken(deps);
+		if (!token) {
+			return this.emptySnapshot(noCredentials());
+		}
+
+		const { controller, clear } = createTimeoutController(API_TIMEOUT_MS);
+
+		try {
+			const res = await deps.fetch("https://api.anthropic.com/api/oauth/usage", {
+				headers: {
+					Authorization: `Bearer ${token}`,
+					"anthropic-beta": "oauth-2025-04-20",
+				},
+				signal: controller.signal,
+			});
+			clear();
+
+			if (!res.ok) {
+				return this.emptySnapshot(httpError(res.status));
+			}
+
+			const data = (await res.json()) as {
+				five_hour?: { utilization?: number; resets_at?: string };
+				seven_day?: { utilization?: number; resets_at?: string };
+				extra_usage?: {
+					is_enabled?: boolean;
+					used_credits?: number;
+					monthly_limit?: number;
+					utilization?: number;
+				};
+			};
+
+			const windows: RateWindow[] = [];
+
+			if (data.five_hour?.utilization !== undefined) {
+				const resetAt = data.five_hour.resets_at ? new Date(data.five_hour.resets_at) : undefined;
+				windows.push({
+					label: "5h",
+					usedPercent: data.five_hour.utilization,
+					resetDescription: resetAt ? formatReset(resetAt) : undefined,
+					resetAt: resetAt?.toISOString(),
+				});
+			}
+
+			if (data.seven_day?.utilization !== undefined) {
+				const resetAt = data.seven_day.resets_at ? new Date(data.seven_day.resets_at) : undefined;
+				windows.push({
+					label: "Week",
+					usedPercent: data.seven_day.utilization,
+					resetDescription: resetAt ? formatReset(resetAt) : undefined,
+					resetAt: resetAt?.toISOString(),
+				});
+			}
+
+			// Extra usage
+			const extraUsageEnabled = data.extra_usage?.is_enabled === true;
+			const fiveHourUsage = data.five_hour?.utilization ?? 0;
+
+			if (extraUsageEnabled) {
+				const extra = data.extra_usage!;
+				const usedCredits = extra.used_credits || 0;
+				const monthlyLimit = extra.monthly_limit;
+				const utilization = extra.utilization || 0;
+				const format = getExtraUsageFormat();
+				// "active" when 5h >= 99%, otherwise "on"
+				const extraStatus = fiveHourUsage >= 99 ? "active" : "on";
+				let label: string;
+				if (monthlyLimit && monthlyLimit > 0) {
+					label = `Extra [${extraStatus}] ${formatExtraUsageCredits(usedCredits, format)}/${formatExtraUsageCredits(monthlyLimit, format)}`;
+				} else {
+					label = `Extra [${extraStatus}] ${formatExtraUsageCredits(usedCredits, format)}`;
+				}
+
+				windows.push({
+					label,
+					usedPercent: utilization,
+					resetDescription: extraStatus === "active" ? "__ACTIVE__" : undefined,
+				});
+			}
+
+			return this.snapshot({
+				windows,
+				extraUsageEnabled,
+				fiveHourUsage,
+			});
+		} catch {
+			clear();
+			return this.emptySnapshot(fetchFailed());
+		}
+	}
+
+}

package/src/providers/impl/antigravity.ts

@@ -0,0 +1,226 @@
+/**
+ * Google Antigravity 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, formatReset } from "../../utils.js";
+import { API_TIMEOUT_MS } from "../../config.js";
+
+const ANTIGRAVITY_ENDPOINTS = [
+	"https://daily-cloudcode-pa.sandbox.googleapis.com",
+	"https://cloudcode-pa.googleapis.com",
+] as const;
+
+const ANTIGRAVITY_HEADERS = {
+	"User-Agent": "antigravity/1.11.5 darwin/arm64",
+	"X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+	"Client-Metadata": JSON.stringify({
+		ideType: "IDE_UNSPECIFIED",
+		platform: "PLATFORM_UNSPECIFIED",
+		pluginType: "GEMINI",
+	}),
+};
+
+const ANTIGRAVITY_HIDDEN_MODELS = new Set(["tab_flash_lite_preview"]);
+
+interface AntigravityAuth {
+	access?: string;
+	accessToken?: string;
+	token?: string;
+	key?: string;
+	projectId?: string;
+	project?: string;
+}
+
+interface CloudCodeQuotaResponse {
+	models?: Record<string, {
+		displayName?: string;
+		model?: string;
+		isInternal?: boolean;
+		quotaInfo?: {
+			remainingFraction?: number;
+			limit?: string;
+			resetTime?: string;
+		};
+	}>;
+}
+
+interface ParsedModelQuota {
+	name: string;
+	remainingFraction: number;
+	resetAt?: Date;
+}
+
+/**
+ * Load Antigravity access token from auth.json
+ */
+function loadAntigravityAuth(deps: Dependencies): AntigravityAuth | undefined {
+	// Explicit override via env var
+	const envProjectId = (deps.env.GOOGLE_ANTIGRAVITY_PROJECT_ID || deps.env.GOOGLE_ANTIGRAVITY_PROJECT)?.trim();
+	const envToken = (deps.env.GOOGLE_ANTIGRAVITY_OAUTH_TOKEN || deps.env.ANTIGRAVITY_OAUTH_TOKEN)?.trim();
+	if (envToken) {
+		return { token: envToken, projectId: envProjectId || undefined };
+	}
+
+	// Also support passing pi-ai style JSON api key: { token, projectId }
+	const envApiKey = (deps.env.GOOGLE_ANTIGRAVITY_API_KEY || deps.env.ANTIGRAVITY_API_KEY)?.trim();
+	if (envApiKey) {
+		try {
+			const parsed = JSON.parse(envApiKey) as { token?: string; projectId?: string };
+			if (parsed?.token) {
+				return { token: parsed.token, projectId: parsed.projectId || envProjectId || undefined };
+			}
+		} catch {
+			// not JSON
+		}
+		return { token: envApiKey, projectId: envProjectId || undefined };
+	}
+
+	const piAuthPath = path.join(deps.homedir(), ".pi", "agent", "auth.json");
+	try {
+		if (deps.fileExists(piAuthPath)) {
+			const data = JSON.parse(deps.readFile(piAuthPath) ?? "{}");
+			const entry = data["google-antigravity"];
+			if (!entry) return undefined;
+			if (typeof entry === "string") {
+				return { token: entry };
+			}
+			return {
+				access: entry.access,
+				accessToken: entry.accessToken,
+				token: entry.token,
+				key: entry.key,
+				projectId: entry.projectId ?? entry.project,
+			};
+		}
+	} catch {
+		// Ignore parse errors
+	}
+
+	return undefined;
+}
+
+function resolveAntigravityToken(auth: AntigravityAuth | undefined): string | undefined {
+	return auth?.access ?? auth?.accessToken ?? auth?.token ?? auth?.key;
+}
+
+function parseResetTime(value?: string): Date | undefined {
+	if (!value) return undefined;
+	const date = new Date(value);
+	if (Number.isNaN(date.getTime())) return undefined;
+	return date;
+}
+
+function toUsedPercent(remainingFraction: number): number {
+	const fraction = Number.isFinite(remainingFraction) ? remainingFraction : 1;
+	const used = (1 - fraction) * 100;
+	return Math.max(0, Math.min(100, used));
+}
+
+async function fetchAntigravityQuota(
+	deps: Dependencies,
+	endpoint: string,
+	token: string,
+	projectId?: string
+): Promise<{ data?: CloudCodeQuotaResponse; status?: number }> {
+	const { controller, clear } = createTimeoutController(API_TIMEOUT_MS);
+	try {
+		const payload = projectId ? { project: projectId } : {};
+		const res = await deps.fetch(`${endpoint}/v1internal:fetchAvailableModels`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json",
+				...ANTIGRAVITY_HEADERS,
+			},
+			body: JSON.stringify(payload),
+			signal: controller.signal,
+		});
+		clear();
+		if (!res.ok) return { status: res.status };
+		const data = (await res.json()) as CloudCodeQuotaResponse;
+		return { data };
+	} catch {
+		clear();
+		return {};
+	}
+}
+
+export class AntigravityProvider extends BaseProvider {
+	readonly name = "antigravity" as const;
+	readonly displayName = "Antigravity";
+
+	hasCredentials(deps: Dependencies): boolean {
+		return Boolean(resolveAntigravityToken(loadAntigravityAuth(deps)));
+	}
+
+	async fetchUsage(deps: Dependencies): Promise<UsageSnapshot> {
+		const auth = loadAntigravityAuth(deps);
+		const token = resolveAntigravityToken(auth);
+		if (!token) {
+			return this.emptySnapshot(noCredentials());
+		}
+
+		let data: CloudCodeQuotaResponse | undefined;
+		let lastStatus: number | undefined;
+		for (const endpoint of ANTIGRAVITY_ENDPOINTS) {
+			const result = await fetchAntigravityQuota(deps, endpoint, token, auth?.projectId);
+			if (result.data) {
+				data = result.data;
+				break;
+			}
+			if (result.status) {
+				lastStatus = result.status;
+			}
+		}
+
+		if (!data) {
+			return lastStatus ? this.emptySnapshot(httpError(lastStatus)) : this.emptySnapshot(fetchFailed());
+		}
+
+		const modelByName = new Map<string, ParsedModelQuota>();
+		for (const [modelId, model] of Object.entries(data.models ?? {})) {
+			if (model.isInternal) continue;
+			if (modelId && ANTIGRAVITY_HIDDEN_MODELS.has(modelId.toLowerCase())) continue;
+			const name = model.displayName ?? modelId ?? model.model ?? "unknown";
+			if (!name) continue;
+			if (ANTIGRAVITY_HIDDEN_MODELS.has(name.toLowerCase())) continue;
+			const remainingFraction = model.quotaInfo?.remainingFraction ?? 1;
+			const resetAt = parseResetTime(model.quotaInfo?.resetTime);
+			const existing = modelByName.get(name);
+			if (!existing) {
+				modelByName.set(name, { name, remainingFraction, resetAt });
+				continue;
+			}
+			let next = existing;
+			if (remainingFraction < existing.remainingFraction) {
+				next = { name, remainingFraction, resetAt };
+			} else if (remainingFraction === existing.remainingFraction && resetAt) {
+				if (!existing.resetAt || resetAt.getTime() < existing.resetAt.getTime()) {
+					next = { ...existing, resetAt };
+				}
+			} else if (!existing.resetAt && resetAt) {
+				next = { ...existing, resetAt };
+			}
+			if (next !== existing) {
+				modelByName.set(name, next);
+			}
+		}
+
+		const parsedModels = Array.from(modelByName.values()).sort((a, b) => a.name.localeCompare(b.name));
+
+		const buildWindow = (label: string, remainingFraction: number, resetAt?: Date): RateWindow => ({
+			label,
+			usedPercent: toUsedPercent(remainingFraction),
+			resetDescription: resetAt ? formatReset(resetAt) : undefined,
+			resetAt: resetAt?.toISOString(),
+		});
+
+		const windows = parsedModels.map((model) => buildWindow(model.name, model.remainingFraction, model.resetAt));
+
+		return this.snapshot({ windows });
+	}
+}