antigravity-auth 1.6.0 → 1.7.0

package/dist/src/hooks/auto-update-checker/checker.js

@@ -1,233 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { PACKAGE_NAME, NPM_REGISTRY_URL, NPM_FETCH_TIMEOUT, INSTALLED_PACKAGE_JSON, USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC, } from "./constants";
-import { logAutoUpdate } from "./logging";
-export function isLocalDevMode(directory) {
-    return getLocalDevPath(directory) !== null;
-}
-function stripJsonComments(json) {
-    return json
-        .replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => (g ? "" : m))
-        .replace(/,(\s*[}\]])/g, "$1");
-}
-function getConfigPaths(directory) {
-    return [
-        path.join(directory, ".opencode", "opencode.json"),
-        path.join(directory, ".opencode", "opencode.jsonc"),
-        path.join(directory, ".opencode.json"),
-        USER_OPENCODE_CONFIG,
-        USER_OPENCODE_CONFIG_JSONC,
-    ];
-}
-export function getLocalDevPath(directory) {
-    for (const configPath of getConfigPaths(directory)) {
-        try {
-            if (!fs.existsSync(configPath))
-                continue;
-            const content = fs.readFileSync(configPath, "utf-8");
-            const config = JSON.parse(stripJsonComments(content));
-            const plugins = config.plugin ?? [];
-            for (const entry of plugins) {
-                if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME)) {
-                    try {
-                        return fileURLToPath(entry);
-                    }
-                    catch {
-                        return entry.replace("file://", "");
-                    }
-                }
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
-}
-function findPackageJsonUp(startPath) {
-    try {
-        const stat = fs.statSync(startPath);
-        let dir = stat.isDirectory() ? startPath : path.dirname(startPath);
-        for (let i = 0; i < 10; i++) {
-            const pkgPath = path.join(dir, "package.json");
-            if (fs.existsSync(pkgPath)) {
-                try {
-                    const content = fs.readFileSync(pkgPath, "utf-8");
-                    const pkg = JSON.parse(content);
-                    if (pkg.name === PACKAGE_NAME)
-                        return pkgPath;
-                }
-                catch {
-                    continue;
-                }
-            }
-            const parent = path.dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-    }
-    catch {
-        return null;
-    }
-    return null;
-}
-export function getLocalDevVersion(directory) {
-    const localPath = getLocalDevPath(directory);
-    if (!localPath)
-        return null;
-    try {
-        const pkgPath = findPackageJsonUp(localPath);
-        if (!pkgPath)
-            return null;
-        const content = fs.readFileSync(pkgPath, "utf-8");
-        const pkg = JSON.parse(content);
-        return pkg.version ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-export function findPluginEntry(directory) {
-    for (const configPath of getConfigPaths(directory)) {
-        try {
-            if (!fs.existsSync(configPath))
-                continue;
-            const content = fs.readFileSync(configPath, "utf-8");
-            const config = JSON.parse(stripJsonComments(content));
-            const plugins = config.plugin ?? [];
-            for (const entry of plugins) {
-                if (entry === PACKAGE_NAME) {
-                    return { entry, isPinned: false, pinnedVersion: null, configPath };
-                }
-                if (entry.startsWith(`${PACKAGE_NAME}@`)) {
-                    const pinnedVersion = entry.slice(PACKAGE_NAME.length + 1);
-                    const isPinned = pinnedVersion !== "latest";
-                    return { entry, isPinned, pinnedVersion: isPinned ? pinnedVersion : null, configPath };
-                }
-                if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME)) {
-                    return { entry, isPinned: false, pinnedVersion: null, configPath };
-                }
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
-}
-export function getCachedVersion() {
-    try {
-        if (fs.existsSync(INSTALLED_PACKAGE_JSON)) {
-            const content = fs.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
-            const pkg = JSON.parse(content);
-            if (pkg.version)
-                return pkg.version;
-        }
-    }
-    catch {
-        return null;
-    }
-    try {
-        const currentDir = path.dirname(fileURLToPath(import.meta.url));
-        const pkgPath = findPackageJsonUp(currentDir);
-        if (pkgPath) {
-            const content = fs.readFileSync(pkgPath, "utf-8");
-            const pkg = JSON.parse(content);
-            if (pkg.version)
-                return pkg.version;
-        }
-    }
-    catch (err) {
-        logAutoUpdate(`Failed to resolve version from current directory: ${err}`);
-    }
-    return null;
-}
-export function updatePinnedVersion(configPath, oldEntry, newVersion) {
-    try {
-        const content = fs.readFileSync(configPath, "utf-8");
-        const newEntry = `${PACKAGE_NAME}@${newVersion}`;
-        const pluginMatch = content.match(/"plugin"\s*:\s*\[/);
-        if (!pluginMatch || pluginMatch.index === undefined) {
-            logAutoUpdate(`No "plugin" array found in ${configPath}`);
-            return false;
-        }
-        const startIdx = pluginMatch.index + pluginMatch[0].length;
-        let bracketCount = 1;
-        let endIdx = startIdx;
-        for (let i = startIdx; i < content.length && bracketCount > 0; i++) {
-            if (content[i] === "[")
-                bracketCount++;
-            else if (content[i] === "]")
-                bracketCount--;
-            endIdx = i;
-        }
-        const before = content.slice(0, startIdx);
-        const pluginArrayContent = content.slice(startIdx, endIdx);
-        const after = content.slice(endIdx);
-        const escapedOldEntry = oldEntry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const regex = new RegExp(`["']${escapedOldEntry}["']`);
-        if (!regex.test(pluginArrayContent)) {
-            logAutoUpdate(`Entry "${oldEntry}" not found in plugin array of ${configPath}`);
-            return false;
-        }
-        const updatedPluginArray = pluginArrayContent.replace(regex, `"${newEntry}"`);
-        const updatedContent = before + updatedPluginArray + after;
-        if (updatedContent === content) {
-            logAutoUpdate(`No changes made to ${configPath}`);
-            return false;
-        }
-        fs.writeFileSync(configPath, updatedContent, "utf-8");
-        logAutoUpdate(`Updated ${configPath}: ${oldEntry} → ${newEntry}`);
-        return true;
-    }
-    catch (err) {
-        console.error(`[auto-update-checker] Failed to update config file ${configPath}:`, err);
-        return false;
-    }
-}
-export async function getLatestVersion() {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
-    try {
-        const response = await fetch(NPM_REGISTRY_URL, {
-            signal: controller.signal,
-            headers: { Accept: "application/json" },
-        });
-        if (!response.ok)
-            return null;
-        const data = (await response.json());
-        return data.latest ?? null;
-    }
-    catch {
-        return null;
-    }
-    finally {
-        clearTimeout(timeoutId);
-    }
-}
-export async function checkForUpdate(directory) {
-    if (isLocalDevMode(directory)) {
-        logAutoUpdate("Local dev mode detected, skipping update check");
-        return { needsUpdate: false, currentVersion: null, latestVersion: null, isLocalDev: true, isPinned: false };
-    }
-    const pluginInfo = findPluginEntry(directory);
-    if (!pluginInfo) {
-        logAutoUpdate("Plugin not found in config");
-        return { needsUpdate: false, currentVersion: null, latestVersion: null, isLocalDev: false, isPinned: false };
-    }
-    const currentVersion = getCachedVersion() ?? pluginInfo.pinnedVersion;
-    if (!currentVersion) {
-        logAutoUpdate("No version found (cached or pinned)");
-        return { needsUpdate: false, currentVersion: null, latestVersion: null, isLocalDev: false, isPinned: pluginInfo.isPinned };
-    }
-    const latestVersion = await getLatestVersion();
-    if (!latestVersion) {
-        logAutoUpdate("Failed to fetch latest version");
-        return { needsUpdate: false, currentVersion, latestVersion: null, isLocalDev: false, isPinned: pluginInfo.isPinned };
-    }
-    const needsUpdate = currentVersion !== latestVersion;
-    logAutoUpdate(`Current: ${currentVersion}, Latest: ${latestVersion}, NeedsUpdate: ${needsUpdate}`);
-    return { needsUpdate, currentVersion, latestVersion, isLocalDev: false, isPinned: pluginInfo.isPinned };
-}

package/dist/src/hooks/auto-update-checker/constants.d.ts

@@ -1,8 +0,0 @@
-export declare const PACKAGE_NAME = "opencode-antigravity-auth";
-export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/opencode-antigravity-auth/dist-tags";
-export declare const NPM_FETCH_TIMEOUT = 5000;
-export declare const CACHE_DIR: string;
-export declare const INSTALLED_PACKAGE_JSON: string;
-export declare const USER_CONFIG_DIR: string;
-export declare const USER_OPENCODE_CONFIG: string;
-export declare const USER_OPENCODE_CONFIG_JSONC: string;

package/dist/src/hooks/auto-update-checker/constants.js

@@ -1,22 +0,0 @@
-import * as path from "node:path";
-import * as os from "node:os";
-export const PACKAGE_NAME = "opencode-antigravity-auth";
-export const NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
-export const NPM_FETCH_TIMEOUT = 5000;
-function getCacheDir() {
-    if (process.platform === "win32") {
-        return path.join(process.env.LOCALAPPDATA ?? os.homedir(), "opencode");
-    }
-    return path.join(os.homedir(), ".cache", "opencode");
-}
-export const CACHE_DIR = getCacheDir();
-export const INSTALLED_PACKAGE_JSON = path.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
-function getUserConfigDir() {
-    if (process.platform === "win32") {
-        return process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
-    }
-    return process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
-}
-export const USER_CONFIG_DIR = getUserConfigDir();
-export const USER_OPENCODE_CONFIG = path.join(USER_CONFIG_DIR, "opencode", "opencode.json");
-export const USER_OPENCODE_CONFIG_JSONC = path.join(USER_CONFIG_DIR, "opencode", "opencode.jsonc");

package/dist/src/hooks/auto-update-checker/index.d.ts

@@ -1,33 +0,0 @@
-import type { AutoUpdateCheckerOptions } from "./types";
-interface PluginClient {
-    tui: {
-        showToast(options: {
-            body: {
-                title?: string;
-                message: string;
-                variant: "info" | "warning" | "success" | "error";
-                duration?: number;
-            };
-        }): Promise<unknown>;
-    };
-}
-interface SessionCreatedEvent {
-    type: "session.created";
-    properties?: {
-        info?: {
-            parentID?: string;
-        };
-    };
-}
-type PluginEvent = SessionCreatedEvent | {
-    type: string;
-    properties?: unknown;
-};
-export declare function createAutoUpdateCheckerHook(client: PluginClient, directory: string, options?: AutoUpdateCheckerOptions): {
-    event: ({ event }: {
-        event: PluginEvent;
-    }) => void;
-};
-export type { UpdateCheckResult, AutoUpdateCheckerOptions } from "./types";
-export { checkForUpdate, getCachedVersion, getLatestVersion } from "./checker";
-export { invalidatePackage, invalidateCache } from "./cache";

package/dist/src/hooks/auto-update-checker/index.js

@@ -1,121 +0,0 @@
-import { getCachedVersion, getLocalDevVersion, findPluginEntry, getLatestVersion, updatePinnedVersion } from "./checker";
-import { invalidatePackage } from "./cache";
-import { PACKAGE_NAME } from "./constants";
-import { logAutoUpdate } from "./logging";
-export function createAutoUpdateCheckerHook(client, directory, options = {}) {
-    const { showStartupToast = true, autoUpdate = true } = options;
-    let hasChecked = false;
-    return {
-        event: ({ event }) => {
-            if (event.type !== "session.created")
-                return;
-            if (hasChecked)
-                return;
-            const props = event.properties;
-            if (props?.info?.parentID)
-                return;
-            hasChecked = true;
-            setTimeout(() => {
-                const localDevVersion = getLocalDevVersion(directory);
-                if (localDevVersion) {
-                    if (showStartupToast) {
-                        showLocalDevToast(client, localDevVersion).catch(() => { });
-                    }
-                    logAutoUpdate("Local development mode");
-                    return;
-                }
-                runBackgroundUpdateCheck(client, directory, autoUpdate).catch((err) => {
-                    logAutoUpdate(`Background update check failed: ${err}`);
-                });
-            }, 0);
-        },
-    };
-}
-async function runBackgroundUpdateCheck(client, directory, autoUpdate) {
-    const pluginInfo = findPluginEntry(directory);
-    if (!pluginInfo) {
-        logAutoUpdate("Plugin not found in config");
-        return;
-    }
-    const cachedVersion = getCachedVersion();
-    const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
-    if (!currentVersion) {
-        logAutoUpdate("No version found (cached or pinned)");
-        return;
-    }
-    if (currentVersion.includes('-')) {
-        logAutoUpdate(`Prerelease version (${currentVersion}), skipping auto-update`);
-        return;
-    }
-    const latestVersion = await getLatestVersion();
-    if (!latestVersion) {
-        logAutoUpdate("Failed to fetch latest version");
-        return;
-    }
-    if (currentVersion === latestVersion) {
-        logAutoUpdate("Already on latest version");
-        return;
-    }
-    logAutoUpdate(`Update available: ${currentVersion} → ${latestVersion}`);
-    if (!autoUpdate) {
-        await showUpdateAvailableToast(client, latestVersion);
-        logAutoUpdate("Auto-update disabled, notification only");
-        return;
-    }
-    if (pluginInfo.isPinned) {
-        const updated = updatePinnedVersion(pluginInfo.configPath, pluginInfo.entry, latestVersion);
-        if (updated) {
-            invalidatePackage(PACKAGE_NAME);
-            await showAutoUpdatedToast(client, currentVersion, latestVersion);
-            logAutoUpdate(`Config updated: ${pluginInfo.entry} → ${PACKAGE_NAME}@${latestVersion}`);
-        }
-        else {
-            await showUpdateAvailableToast(client, latestVersion);
-        }
-    }
-    else {
-        invalidatePackage(PACKAGE_NAME);
-        await showUpdateAvailableToast(client, latestVersion);
-    }
-}
-async function showUpdateAvailableToast(client, latestVersion) {
-    await client.tui
-        .showToast({
-        body: {
-            title: `Antigravity Auth Update`,
-            message: `v${latestVersion} available. Restart OpenCode to apply.`,
-            variant: "info",
-            duration: 8000,
-        },
-    })
-        .catch(() => { });
-    logAutoUpdate(`Update available toast shown: v${latestVersion}`);
-}
-async function showAutoUpdatedToast(client, oldVersion, newVersion) {
-    await client.tui
-        .showToast({
-        body: {
-            title: `Antigravity Auth Updated!`,
-            message: `v${oldVersion} → v${newVersion}\nRestart OpenCode to apply.`,
-            variant: "success",
-            duration: 8000,
-        },
-    })
-        .catch(() => { });
-    logAutoUpdate(`Auto-updated toast shown: v${oldVersion} → v${newVersion}`);
-}
-async function showLocalDevToast(client, version) {
-    await client.tui
-        .showToast({
-        body: {
-            title: `Antigravity Auth ${version} (dev)`,
-            message: "Running in local development mode.",
-            variant: "warning",
-            duration: 5000,
-        },
-    })
-        .catch(() => { });
-    logAutoUpdate(`Local dev toast shown: v${version}`);
-}
-export { checkForUpdate, getCachedVersion, getLatestVersion } from "./checker";
-export { invalidatePackage, invalidateCache } from "./cache";

package/dist/src/hooks/auto-update-checker/logging.d.ts

@@ -1,2 +0,0 @@
-export declare function formatAutoUpdateLogMessage(message: string): string;
-export declare function logAutoUpdate(message: string): void;

package/dist/src/hooks/auto-update-checker/logging.js

@@ -1,8 +0,0 @@
-import { debugLogToFile } from "../../plugin/debug";
-const AUTO_UPDATE_LOG_PREFIX = "[auto-update-checker]";
-export function formatAutoUpdateLogMessage(message) {
-    return `${AUTO_UPDATE_LOG_PREFIX} ${message}`;
-}
-export function logAutoUpdate(message) {
-    debugLogToFile(formatAutoUpdateLogMessage(message));
-}

package/dist/src/hooks/auto-update-checker/types.d.ts

@@ -1,24 +0,0 @@
-export interface NpmDistTags {
-    latest: string;
-    [key: string]: string;
-}
-export interface OpencodeConfig {
-    plugin?: string[];
-    [key: string]: unknown;
-}
-export interface PackageJson {
-    version: string;
-    name?: string;
-    [key: string]: unknown;
-}
-export interface UpdateCheckResult {
-    needsUpdate: boolean;
-    currentVersion: string | null;
-    latestVersion: string | null;
-    isLocalDev: boolean;
-    isPinned: boolean;
-}
-export interface AutoUpdateCheckerOptions {
-    showStartupToast?: boolean;
-    autoUpdate?: boolean;
-}

package/dist/src/hooks/auto-update-checker/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/index.d.ts

@@ -1,6 +0,0 @@
-import { AntigravityCLIOAuthPlugin, GoogleOAuthPlugin } from "../opencode/plugin";
-export { AntigravityCLIOAuthPlugin, GoogleOAuthPlugin };
-export { authorizeAntigravity, exchangeAntigravity, } from "./antigravity/oauth";
-export type { AntigravityAuthorization, AntigravityTokenExchangeResult, } from "./antigravity/oauth";
-export default AntigravityCLIOAuthPlugin;
-export declare const server: ({ client, directory }: import("./plugin/types").PluginContext) => Promise<import("./plugin/types").PluginResult>;

package/dist/src/index.js

@@ -1,5 +0,0 @@
-import { AntigravityCLIOAuthPlugin, GoogleOAuthPlugin } from "../opencode/plugin";
-export { AntigravityCLIOAuthPlugin, GoogleOAuthPlugin };
-export { authorizeAntigravity, exchangeAntigravity, } from "./antigravity/oauth";
-export default AntigravityCLIOAuthPlugin;
-export const server = AntigravityCLIOAuthPlugin;

package/dist/src/plugin/accounts.d.ts

@@ -1,173 +0,0 @@
-import { type AccountStorageV4, type AccountMetadataV3, type RateLimitStateV3, type ModelFamily, type HeaderStyle, type CooldownReason } from "./storage";
-import type { OAuthAuthDetails, RefreshParts } from "./types";
-import type { AccountSelectionStrategy } from "./config/schema";
-import { type Fingerprint, type FingerprintVersion } from "./fingerprint";
-import type { QuotaGroup, QuotaGroupSummary } from "./quota";
-export type { ModelFamily, HeaderStyle, CooldownReason } from "./storage";
-export type { AccountSelectionStrategy } from "./config/schema";
-export type RateLimitReason = "QUOTA_EXHAUSTED" | "RATE_LIMIT_EXCEEDED" | "MODEL_CAPACITY_EXHAUSTED" | "SERVER_ERROR" | "UNKNOWN";
-export interface RateLimitBackoffResult {
-    backoffMs: number;
-    reason: RateLimitReason;
-}
-export declare function parseRateLimitReason(reason: string | undefined, message: string | undefined, status?: number): RateLimitReason;
-export declare function calculateBackoffMs(reason: RateLimitReason, consecutiveFailures: number, retryAfterMs?: number | null): number;
-export type BaseQuotaKey = "claude" | "gemini-antigravity" | "gemini-cli";
-export type QuotaKey = BaseQuotaKey | `${BaseQuotaKey}:${string}`;
-export interface ManagedAccount {
-    index: number;
-    email?: string;
-    addedAt: number;
-    lastUsed: number;
-    parts: RefreshParts;
-    access?: string;
-    expires?: number;
-    enabled: boolean;
-    proxies?: string[];
-    rateLimitResetTimes: RateLimitStateV3;
-    lastSwitchReason?: "rate-limit" | "initial" | "rotation";
-    coolingDownUntil?: number;
-    cooldownReason?: CooldownReason;
-    touchedForQuota: Record<string, number>;
-    consecutiveFailures?: number;
-    /** Timestamp of last failure for TTL-based reset of consecutiveFailures */
-    lastFailureTime?: number;
-    /** Per-account device fingerprint for rate limit mitigation */
-    fingerprint?: import("./fingerprint").Fingerprint;
-    /** History of previous fingerprints for this account */
-    fingerprintHistory?: FingerprintVersion[];
-    /** Cached quota data from last checkAccountsQuota() call */
-    cachedQuota?: Partial<Record<QuotaGroup, QuotaGroupSummary>>;
-    cachedQuotaUpdatedAt?: number;
-    verificationRequired?: boolean;
-    verificationRequiredAt?: number;
-    verificationRequiredReason?: string;
-    verificationUrl?: string;
-}
-/**
- * Resolve the quota group for soft quota checks.
- *
- * When a model string is available, we can precisely determine the quota group.
- * When model is null/undefined, we fall back based on family:
- * - Claude → "claude" quota group
- * - Gemini → "gemini-pro" (conservative fallback; may misclassify flash models)
- *
- * @param family - The model family ("claude" | "gemini")
- * @param model - Optional model string for precise resolution
- * @returns The QuotaGroup to use for soft quota checks
- */
-export declare function resolveQuotaGroup(family: ModelFamily, model?: string | null): QuotaGroup;
-export declare function computeSoftQuotaCacheTtlMs(ttlConfig: "auto" | number, refreshIntervalMinutes: number): number;
-/**
- * In-memory multi-account manager with sticky account selection.
- *
- * Uses the same account until it hits a rate limit (429), then switches.
- * Rate limits are tracked per-model-family (claude/gemini) so an account
- * rate-limited for Claude can still be used for Gemini.
- *
- * Source of truth for the pool is `antigravity-accounts.json`.
- */
-export declare class AccountManager {
-    private accounts;
-    private cursor;
-    private currentAccountIndexByFamily;
-    private sessionOffsetApplied;
-    private lastToastAccountIndex;
-    private lastToastTime;
-    private savePending;
-    private saveTimeout;
-    private savePromiseResolvers;
-    static loadFromDisk(authFallback?: OAuthAuthDetails): Promise<AccountManager>;
-    constructor(authFallback?: OAuthAuthDetails, stored?: AccountStorageV4 | null);
-    getAccountCount(): number;
-    getTotalAccountCount(): number;
-    getEnabledAccounts(): ManagedAccount[];
-    getAccountsSnapshot(): ManagedAccount[];
-    getCurrentAccountForFamily(family: ModelFamily): ManagedAccount | null;
-    markSwitched(account: ManagedAccount, reason: "rate-limit" | "initial" | "rotation", family: ModelFamily): void;
-    /**
-     * Check if we should show an account switch toast.
-     * Debounces repeated toasts for the same account.
-     */
-    shouldShowAccountToast(accountIndex: number, debounceMs?: number): boolean;
-    markToastShown(accountIndex: number): void;
-    getCurrentOrNextForFamily(family: ModelFamily, model?: string | null, strategy?: AccountSelectionStrategy, headerStyle?: HeaderStyle, pidOffsetEnabled?: boolean, softQuotaThresholdPercent?: number, softQuotaCacheTtlMs?: number): ManagedAccount | null;
-    getNextForFamily(family: ModelFamily, model?: string | null, headerStyle?: HeaderStyle, softQuotaThresholdPercent?: number, softQuotaCacheTtlMs?: number): ManagedAccount | null;
-    markRateLimited(account: ManagedAccount, retryAfterMs: number, family: ModelFamily, headerStyle?: HeaderStyle, model?: string | null): void;
-    /**
-     * Mark an account as used after a successful API request.
-     * This updates the lastUsed timestamp for freshness calculations.
-     * Should be called AFTER request completion, not during account selection.
-     */
-    markAccountUsed(accountIndex: number): void;
-    markRateLimitedWithReason(account: ManagedAccount, family: ModelFamily, headerStyle: HeaderStyle, model?: string | null, reason?: RateLimitReason, retryAfterMs?: number, ttlMs?: number): number;
-    markRequestSuccess(account: ManagedAccount): void;
-    clearAllRateLimitsForFamily(family: ModelFamily, model?: string | null): void;
-    shouldTryOptimisticReset(family: ModelFamily, model?: string | null): boolean;
-    markAccountCoolingDown(account: ManagedAccount, cooldownMs: number, reason: CooldownReason): void;
-    isAccountCoolingDown(account: ManagedAccount): boolean;
-    clearAccountCooldown(account: ManagedAccount): void;
-    getAccountCooldownReason(account: ManagedAccount): CooldownReason | undefined;
-    markTouchedForQuota(account: ManagedAccount, quotaKey: string): void;
-    isFreshForQuota(account: ManagedAccount, quotaKey: string): boolean;
-    getFreshAccountsForQuota(quotaKey: string, family: ModelFamily, model?: string | null): ManagedAccount[];
-    isRateLimitedForHeaderStyle(account: ManagedAccount, family: ModelFamily, headerStyle: HeaderStyle, model?: string | null): boolean;
-    getAvailableHeaderStyle(account: ManagedAccount, family: ModelFamily, model?: string | null): HeaderStyle | null;
-    /**
-     * Check if any OTHER account has antigravity quota available for the given family/model.
-     *
-     * Used to determine whether to switch accounts vs fall back to gemini-cli:
-     * - If true: Switch to another account (preserve antigravity priority)
-     * - If false: All accounts exhausted antigravity, safe to fall back to gemini-cli
-     *
-     * @param currentAccountIndex - Index of the current account (will be excluded from check)
-     * @param family - Model family ("gemini" or "claude")
-     * @param model - Optional model name for model-specific rate limits
-     * @returns true if any other enabled, non-cooling-down account has antigravity available
-     */
-    hasOtherAccountWithAntigravityAvailable(currentAccountIndex: number, family: ModelFamily, model?: string | null): boolean;
-    setAccountEnabled(accountIndex: number, enabled: boolean): boolean;
-    markAccountVerificationRequired(accountIndex: number, reason?: string, verifyUrl?: string): boolean;
-    clearAccountVerificationRequired(accountIndex: number, enableAccount?: boolean): boolean;
-    removeAccountByIndex(accountIndex: number): boolean;
-    removeAccount(account: ManagedAccount): boolean;
-    updateFromAuth(account: ManagedAccount, auth: OAuthAuthDetails): void;
-    toAuthDetails(account: ManagedAccount): OAuthAuthDetails;
-    getMinWaitTimeForFamily(family: ModelFamily, model?: string | null, headerStyle?: HeaderStyle, strict?: boolean): number;
-    getAccounts(): ManagedAccount[];
-    saveToDisk(): Promise<void>;
-    requestSaveToDisk(): void;
-    flushSaveToDisk(): Promise<void>;
-    private executeSave;
-    /**
-     * Regenerate fingerprint for an account, saving the old one to history.
-     * @param accountIndex - Index of the account to regenerate fingerprint for
-     * @returns The new fingerprint, or null if account not found
-     */
-    regenerateAccountFingerprint(accountIndex: number): Fingerprint | null;
-    /**
-     * Restore a fingerprint from history for an account.
-     * @param accountIndex - Index of the account
-     * @param historyIndex - Index in the fingerprint history to restore from (0 = most recent)
-     * @returns The restored fingerprint, or null if account/history not found
-     */
-    restoreAccountFingerprint(accountIndex: number, historyIndex: number): Fingerprint | null;
-    /**
-     * Get fingerprint history for an account.
-     * @param accountIndex - Index of the account
-     * @returns Array of fingerprint versions, or empty array if not found
-     */
-    getAccountFingerprintHistory(accountIndex: number): FingerprintVersion[];
-    updateQuotaCache(accountIndex: number, quotaGroups: Partial<Record<QuotaGroup, QuotaGroupSummary>>): void;
-    isAccountOverSoftQuota(account: ManagedAccount, family: ModelFamily, thresholdPercent: number, cacheTtlMs: number, model?: string | null): boolean;
-    getAccountsForQuotaCheck(): AccountMetadataV3[];
-    getOldestQuotaCacheAge(): number | null;
-    areAllAccountsOverSoftQuota(family: ModelFamily, thresholdPercent: number, cacheTtlMs: number, model?: string | null): boolean;
-    /**
-     * Get minimum wait time until any account's soft quota resets.
-     * Returns 0 if any account is available (not over threshold).
-     * Returns the minimum resetTime across all over-threshold accounts.
-     * Returns null if no resetTime data is available.
-     */
-    getMinWaitTimeForSoftQuota(family: ModelFamily, thresholdPercent: number, cacheTtlMs: number, model?: string | null): number | null;
-}