opencode-quotas 0.0.1

package/src/interfaces.ts

@@ -0,0 +1,258 @@
+export interface QuotaData {
+    id: string; // Unique identifier (e.g., "codex-primary", "ag-flash")
+    providerName: string; // Display name
+    used: number;
+    limit: number | null;
+    unit: string;
+
+    /**
+     * Reset time description (e.g. "in 2h 41m" or "at 12:00").
+     */
+    reset?: string;
+
+    /**
+     * Predicted time until limit is reached (e.g. "in 12m (predicted)").
+     */
+    predictedReset?: string;
+
+    /**
+     * Window or period description (e.g. "5h window" or "Monthly").
+     */
+    window?: string;
+
+    /**
+     * Extra information or alerts (e.g. "!!" or "unlimited").
+     */
+    info?: string;
+
+    /**
+     * @deprecated Use reset, window, info instead.
+     */
+    details?: string;
+}
+
+export type QuotaColumn =
+    | "name"
+    | "bar"
+    | "percent"
+    | "value"
+    | "reset"
+    | "window"
+    | "info"
+    | "status"
+    | "ettl";
+
+export interface QuotaConfig {
+    displayMode: QuotaDisplayMode;
+    progressBar?: ProgressBarConfig;
+    table?: {
+        /**
+         * Columns to display in the quota table.
+         * Defaults to a smart selection based on data.
+         */
+        columns?: QuotaColumn[];
+        /**
+         * Whether to render the table header row (column labels)
+         */
+        header?: boolean;
+    };
+    /**
+     * Whether to show quotas in the chat footer automatically.
+     * Defaults to true.
+     */
+    footer?: boolean;
+    /**
+     * Whether to show the plugin title/header (bold line) in the footer.
+     * Defaults to true.
+     */
+    showFooterTitle?: boolean;
+    /**
+     * List of quota IDs to hide from display.
+     */
+    disabled?: string[];
+    /**
+     * Only show quotas relevant to the current model (best-effort matching).
+     */
+    filterByCurrentModel?: boolean;
+    /**
+     * Enable debug logging to ~/.local/share/opencode/quotas-debug.log
+     */
+    debug?: boolean;
+    /**
+     * Optional aggregation groups.
+     */
+    aggregatedGroups?: AggregatedGroup[];
+    /**
+     * Max history age in hours. Defaults to 24.
+     */
+    historyMaxAgeHours?: number;
+    /**
+     * Polling interval in milliseconds. Defaults to 60000 (1 minute).
+     */
+    pollingInterval?: number;
+    /**
+     * Short time window for regression to capture spikes (minutes). Defaults to 5.
+     */
+    predictionShortWindowMinutes?: number;
+    /**
+     * Whether to show quotas that did not match any aggregation group.
+     * Defaults to true.
+     */
+    showUnaggregated?: boolean;
+}
+
+export type AggregationStrategy =
+    | "most_critical" // Predicted time-to-limit (requires history)
+    | "min" // Lowest percentage used
+    | "max" // Highest percentage used
+    | "mean" // Average percentage used
+    | "median"; // Median percentage used
+
+export interface AggregatedGroup {
+    /**
+     * Unique ID for the resulting group (e.g., "ag-flash", "codex-smart").
+     */
+    id: string;
+    /**
+     * Display name (e.g., "Antigravity Flash", "Codex Usage").
+     */
+    name: string;
+    /**
+     * Explicit IDs of quotas to include in this group.
+     * Use this for precise control over which quotas are aggregated.
+     */
+    sources?: string[];
+    /**
+     * Regex/Glob patterns to match against raw quota IDs or provider names.
+     * The provider will return raw quotas with IDs like "ag-raw-gemini-1-5-flash".
+     * Patterns are matched case-insensitively.
+     */
+    patterns?: string[];
+    /**
+     * Optional: Limit pattern matching to a specific provider ID.
+     * If set, only quotas from this provider will be considered for pattern matching.
+     */
+    providerId?: string;
+    /**
+     * Aggregation strategy. Defaults to "most_critical".
+     */
+    strategy?: AggregationStrategy;
+    /**
+     * Time window for regression (default: 60 minutes).
+     */
+    predictionWindowMinutes?: number;
+    /**
+     * Short time window for spikes (default: 5 minutes).
+     */
+    predictionShortWindowMinutes?: number;
+}
+
+export interface HistoryPoint {
+    timestamp: number;
+    used: number;
+    limit: number | null;
+}
+
+export interface IHistoryService {
+    init(): Promise<void>;
+    append(snapshot: QuotaData[]): Promise<void>;
+    getHistory(quotaId: string, windowMs: number): HistoryPoint[];
+    setMaxAge(hours: number): void;
+    pruneAll(): Promise<void>;
+}
+
+export interface IQuotaProvider {
+    id: string;
+    fetchQuota(): Promise<QuotaData[]>;
+}
+
+export interface IQuotaRegistry {
+    register(provider: IQuotaProvider): void;
+    getAll(): IQuotaProvider[];
+}
+
+/**
+ * Interface for prediction engines that calculate time-to-limit.
+ */
+export interface IPredictionEngine {
+    /**
+     * Predicts time to limit in milliseconds using historical usage data.
+     * @param quotaId - The quota identifier to predict for
+     * @param windowMinutes - The long time window for regression (default: 60)
+     * @param shortWindowMinutes - The short time window for capturing spikes
+     * @returns Time to limit in milliseconds, or Infinity if usage is stable/decreasing
+     */
+    predictTimeToLimit(
+        quotaId: string,
+        windowMinutes?: number,
+        shortWindowMinutes?: number,
+    ): number;
+}
+
+/**
+ * Interface for aggregation services that combine multiple quotas.
+ */
+export interface IAggregationService {
+    /**
+     * Aggregates quotas using the most critical (shortest time-to-limit) strategy.
+     */
+    aggregateMostCritical(
+        quotas: QuotaData[],
+        windowMinutes?: number,
+        shortWindowMinutes?: number,
+    ): QuotaData | null;
+
+    /**
+     * Aggregates quotas by selecting the one with highest usage ratio.
+     */
+    aggregateMax(quotas: QuotaData[]): QuotaData;
+
+    /**
+     * Aggregates quotas by selecting the one with lowest usage ratio.
+     */
+    aggregateMin(quotas: QuotaData[]): QuotaData;
+
+    /**
+     * Aggregates quotas by averaging their usage ratios.
+     */
+    aggregateAverage(
+        quotas: QuotaData[],
+        name: string,
+        id: string,
+        strategy: "mean" | "median",
+    ): QuotaData;
+}
+
+export type QuotaDisplayMode = "simple" | "detailed" | "hidden";
+
+export type AnsiColor =
+    | "red"
+    | "green"
+    | "yellow"
+    | "blue"
+    | "magenta"
+    | "cyan"
+    | "white"
+    | "gray"
+    | "bold"
+    | "dim"
+    | "reset";
+
+export interface GradientLevel {
+    threshold: number; // 0 to 1 (e.g., 0.8 for 80%)
+    color: AnsiColor;
+}
+
+export interface ProgressBarConfig {
+    width?: number;
+    filledChar?: string;
+    emptyChar?: string;
+    show?: "used" | "available";
+    /**
+     * Enable ANSI colors. Defaults to false.
+     */
+    color?: boolean;
+    // Define color levels. The bar will use the color of the first level
+    // whose threshold is greater than or equal to the current usage ratio.
+    gradients?: GradientLevel[];
+}

package/src/logger.ts

@@ -0,0 +1,55 @@
+import { appendFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { DEBUG_LOG_FILE } from "./utils/paths";
+import { inspect } from "node:util";
+
+export class Logger {
+    private static instance: Logger;
+    private debugEnabled: boolean = false;
+    private logPath: string;
+
+    private constructor() {
+        this.logPath = DEBUG_LOG_FILE();
+        if (process.env.OPENCODE_QUOTAS_DEBUG === "1") {
+            this.debugEnabled = true;
+        }
+    }
+
+    public static getInstance(): Logger {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+
+    public setDebug(enabled: boolean): void {
+        this.debugEnabled = enabled;
+    }
+
+    public debug(msg: string, data?: any): void {
+        this.log(msg, data, true);
+    }
+
+    public info(msg: string, data?: any): void {
+        this.log(msg, data, false);
+    }
+
+    public error(msg: string, data?: any): void {
+        this.log(msg, data, false);
+    }
+
+    private log(msg: string, data: any, requiresDebug: boolean): void {
+        if (requiresDebug && !this.debugEnabled) return;
+
+        const timestamp = new Date().toISOString();
+        const payload = data
+            ? ` ${inspect(data, { depth: null, colors: false, breakLength: Infinity })}`
+            : "";
+        const logLine = `[${timestamp}] ${msg}${payload}`;
+
+        appendFile(this.logPath, logLine + "\n").catch(() => {});
+    }
+}
+
+export const logger = Logger.getInstance();

package/src/plugin-state.ts

@@ -0,0 +1,65 @@
+const PLUGIN_STATE_KEY = "__OPENCODE_QUOTA_PLUGIN_STATE__";
+
+type PluginStateGlobal = {
+    [PLUGIN_STATE_KEY]?: PluginState;
+};
+
+/**
+ * Singleton state manager for the quota plugin.
+ * Uses globalThis to ensure only one instance exists across all plugin instantiations.
+ */
+export class PluginState {
+    private static readonly MAX_TRACKED_MESSAGES = 1000;
+    private processedMessages: string[] = [];
+    private processedSet = new Set<string>();
+    private locks = new Map<string, Promise<void>>();
+
+    isProcessed(messageId: string): boolean {
+        return this.processedSet.has(messageId);
+    }
+
+    markProcessed(messageId: string): void {
+        if (this.processedSet.has(messageId)) return;
+
+        this.processedSet.add(messageId);
+        this.processedMessages.push(messageId);
+
+        while (this.processedMessages.length > PluginState.MAX_TRACKED_MESSAGES) {
+            const oldest = this.processedMessages.shift();
+            if (oldest) this.processedSet.delete(oldest);
+        }
+    }
+
+    async acquireLock(messageId: string): Promise<() => void> {
+        const existingLock = this.locks.get(messageId) || Promise.resolve();
+        
+        let resolveLock: () => void;
+        const nextLock = new Promise<void>((resolve) => {
+            resolveLock = resolve;
+        });
+
+        this.locks.set(messageId, nextLock);
+
+        await existingLock;
+
+        return () => {
+            resolveLock();
+            if (this.locks.get(messageId) === nextLock) {
+                this.locks.delete(messageId);
+            }
+        };
+    }
+}
+
+/**
+ * Returns the global singleton PluginState instance.
+ * This ensures all plugin instantiations share the same state,
+ * preventing duplicate injection when the plugin is loaded multiple times.
+ */
+export function getPluginState(): PluginState {
+    const globalRef = globalThis as PluginStateGlobal;
+    if (!globalRef[PLUGIN_STATE_KEY]) {
+        globalRef[PLUGIN_STATE_KEY] = new PluginState();
+    }
+    return globalRef[PLUGIN_STATE_KEY];
+}

package/src/providers/antigravity/auth.ts

@@ -0,0 +1,163 @@
+import { readFile } from "node:fs/promises";
+import { ANTIGRAVITY_ACCOUNTS_FILE } from "../../utils/paths";
+
+/**
+ * PUBLIC OAUTH CREDENTIALS - INTENTIONALLY COMMITTED
+ * 
+ * These are "Installed Application" credentials for Google's Native App OAuth flow.
+ * Per Google's documentation, the client_secret for native applications is NOT
+ * considered confidential. Security relies solely on the user's refresh_token
+ * stored locally in ~/.config/opencode/antigravity-accounts.json.
+ * 
+ * See: https://developers.google.com/identity/protocols/oauth2/native-app
+ */
+const ANTIGRAVITY_CLIENT_ID =
+  "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com"; // gitleaks:allow
+const ANTIGRAVITY_CLIENT_SECRET = "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"; // gitleaks:allow
+const TOKEN_URL = "https://oauth2.googleapis.com/token";
+
+interface StoredAccount {
+  email: string;
+  refreshToken: string;
+  projectId?: string;
+  managedProjectId?: string;
+  addedAt: number;
+  lastUsed: number;
+}
+
+interface AccountsFile {
+  version: number;
+  accounts: StoredAccount[];
+  activeIndex: number;
+}
+
+interface TokenResponse {
+  access_token: string;
+  expires_in: number;
+  token_type: string;
+}
+
+export interface CloudAuthCredentials {
+  accessToken: string;
+  projectId?: string;
+  email: string;
+}
+
+interface CachedCredential extends CloudAuthCredentials {
+  expiresAt: number;
+}
+
+let cachedCredential: CachedCredential | null = null;
+
+function getAccountsFilePath(): string {
+  return ANTIGRAVITY_ACCOUNTS_FILE();
+}
+
+async function loadAccounts(): Promise<AccountsFile> {
+  const accountsPath = getAccountsFilePath();
+
+  try {
+    const content = await readFile(accountsPath, "utf-8");
+    const data = JSON.parse(content) as AccountsFile;
+
+    if (!data.accounts || data.accounts.length === 0) {
+      throw new Error("No accounts found in antigravity-accounts.json");
+    }
+
+    return data;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      throw new Error(
+        "Antigravity accounts file not found.\n" +
+          "Run 'opencode auth login' first to authenticate with Google.",
+      );
+    }
+    throw error;
+  }
+}
+
+export async function hasCloudCredentials(): Promise<boolean> {
+  try {
+    await loadAccounts();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function refreshAccessToken(refreshToken: string): Promise<{ accessToken: string; expiresAt: number }> {
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: new URLSearchParams({
+      client_id: ANTIGRAVITY_CLIENT_ID,
+      client_secret: ANTIGRAVITY_CLIENT_SECRET,
+      refresh_token: refreshToken,
+      grant_type: "refresh_token",
+    }).toString(),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    if (errorText.toLowerCase().includes("invalid_grant")) {
+      throw new Error(
+        "Refresh token is invalid or expired. Run 'opencode auth login' to re-authenticate.",
+      );
+    }
+    throw new Error(`Token refresh failed: ${response.status} - ${errorText}`);
+  }
+
+  const data = (await response.json()) as TokenResponse;
+  return {
+    accessToken: data.access_token,
+    expiresAt: Date.now() + data.expires_in * 1000,
+  };
+}
+
+export async function getCloudCredentials(): Promise<CloudAuthCredentials> {
+  const accountsFile = await loadAccounts();
+  const activeAccount =
+    accountsFile.accounts[accountsFile.activeIndex] ?? accountsFile.accounts[0];
+
+  if (!activeAccount) {
+    throw new Error("No active account found in antigravity-accounts.json");
+  }
+
+  // Check cache (5 min buffer)
+  const fiveMinutesInMs = 5 * 60 * 1000;
+  if (
+    cachedCredential &&
+    cachedCredential.email === activeAccount.email &&
+    cachedCredential.expiresAt > Date.now() + fiveMinutesInMs
+  ) {
+    return {
+      accessToken: cachedCredential.accessToken,
+      projectId: cachedCredential.projectId,
+      email: cachedCredential.email,
+    };
+  }
+
+  const { accessToken, expiresAt } = await refreshAccessToken(activeAccount.refreshToken);
+  
+  cachedCredential = {
+    accessToken,
+    projectId: activeAccount.projectId,
+    email: activeAccount.email,
+    expiresAt,
+  };
+
+  return {
+    accessToken,
+    projectId: activeAccount.projectId,
+    email: activeAccount.email,
+  };
+}
+
+/**
+ * Reset the credential cache. Internal use only (primarily for tests).
+ */
+export function resetCredentialCache(): void {
+    cachedCredential = null;
+}

package/src/providers/antigravity/index.ts

@@ -0,0 +1 @@
+export * from "./provider";