@cortexkit/opencode-openai-auth 1.0.4 → 1.1.0

package/src/tui-compiled/raw/shared/2dce6e9613993329-quota-manager.js

@@ -0,0 +1,473 @@
+import { createHash } from "node:crypto";
+import { acquireRefreshFileLock } from "./ec971142548df90e-index.js";
+import { buildQuotaOperationError, quotaBackoffActive } from "./134b008900698fe0-backoff.js";
+import { PRIMARY, SECONDARY } from "./85512cc5263ba259-provider.js";
+import { isTombstoned } from "./4593a4d71edf69fd-tombstone.js";
+const nativeSetTimeout = globalThis.setTimeout, DEFAULT_QUOTA_CHECK_INTERVAL_MINUTES = 5;
+function getQuotaCheckIntervalMs(storage) {
+  const minutes = storage?.quota?.checkIntervalMinutes ?? DEFAULT_QUOTA_CHECK_INTERVAL_MINUTES;
+  return Math.max(1, minutes) * 60000;
+}
+function quotaEnabled(storage) {
+  return storage?.quota?.enabled !== !1;
+}
+export function quotaWindowResetIsPast(window, now) {
+  if (!window?.resetsAt)
+    return !1;
+  const resetTime = Date.parse(window.resetsAt);
+  return Number.isFinite(resetTime) && resetTime <= now;
+}
+export function resolveMidStreamRateLimitResetAt(quota, window, now, defaultMs, explicitResetAt) {
+  if (explicitResetAt !== void 0 && Number.isFinite(explicitResetAt) && explicitResetAt > now)
+    return explicitResetAt;
+  const named = window === PRIMARY ? quota?.primary : window === SECONDARY ? quota?.secondary : void 0, namedReset = named?.resetsAt ? Date.parse(named.resetsAt) : NaN;
+  if (Number.isFinite(namedReset) && namedReset > now)
+    return namedReset;
+  return now + defaultMs;
+}
+function normalizeThresholds(storage) {
+  const configured = storage?.quota?.minimumRemaining || {};
+  return {
+    primary: configured.primary ?? configured["5h"] ?? 15,
+    secondary: configured.secondary ?? configured["1w"] ?? 10
+  };
+}
+function getQuotaNextRefreshAt(quota, storage, now) {
+  if (!quotaEnabled(storage))
+    return now + getQuotaCheckIntervalMs(storage);
+  const thresholds = normalizeThresholds(storage), blockedResetTimes = [];
+  for (const key of ["primary", "secondary"]) {
+    const window = quota?.[key];
+    if (!window)
+      continue;
+    if (window.remainingPercent >= thresholds[key])
+      continue;
+    const resetTime = window.resetsAt ? Date.parse(window.resetsAt) : Number.NaN;
+    if (!Number.isFinite(resetTime) || resetTime <= now)
+      return now + getQuotaCheckIntervalMs(storage);
+    blockedResetTimes.push(resetTime);
+  }
+  if (!blockedResetTimes.length)
+    return now + getQuotaCheckIntervalMs(storage);
+  return Math.min(...blockedResetTimes) + 60000;
+}
+function getPersistedMainQuota(storage) {
+  if (!storage?.quota?.mainQuota || !storage.quota.mainQuotaCheckedAt)
+    return null;
+  return {
+    quota: storage.quota.mainQuota,
+    checkedAt: storage.quota.mainQuotaCheckedAt,
+    tokenFingerprint: storage.quota.mainQuotaToken
+  };
+}
+function getQuotaRefreshEveryNRequests(storage) {
+  const n = storage?.quota?.refreshEveryNRequests;
+  return typeof n === "number" && Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+export function tokenFingerprint(token) {
+  return createHash("sha256").update(token).digest("hex").slice(0, 16);
+}
+
+export class QuotaManager {
+  main = null;
+  mainTokenFp = null;
+  mainQuotaAccountId = null;
+  fallbacks = new Map;
+  fallbackTokenFps = new Map;
+  inflightMain = null;
+  inflightMainFp = null;
+  inflightFallbacks = new Map;
+  mainLastApiError = void 0;
+  fallbackApiErrors = new Map;
+  fallbackErrorTokenFps = new Map;
+  rateLimitedUntilMap = new Map;
+  apiGate = Promise.resolve();
+  lastApiCallAt = 0;
+  storage;
+  fetchImpl;
+  now;
+  fetchQuotaFn;
+  onMainQuotaFetched;
+  onApiError;
+  configPath;
+  constructor(opts) {
+    this.storage = opts.storage;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+    this.configPath = opts.configPath;
+    this.now = opts.now ?? Date.now;
+    this.fetchQuotaFn = opts.fetchQuotaFn;
+    this.onMainQuotaFetched = opts.onMainQuotaFetched;
+    this.onApiError = opts.onApiError;
+    this.seedMainFromStorage(opts.storage);
+    this.seedMainBackoffFromStorage(opts.storage);
+  }
+  getMain(accessToken) {
+    if (accessToken && this.main && this.mainTokenFp && this.mainTokenFp !== tokenFingerprint(accessToken)) {
+      this.main = null;
+      this.mainTokenFp = null;
+    }
+    return this.main;
+  }
+  getFallback(accountId, accessToken) {
+    const entry = this.fallbacks.get(accountId) ?? null;
+    if (!accessToken || !entry)
+      return entry;
+    if (this.fallbackTokenFps.get(accountId) !== tokenFingerprint(accessToken)) {
+      this.fallbacks.delete(accountId);
+      this.fallbackTokenFps.delete(accountId);
+      return null;
+    }
+    return entry;
+  }
+  getAllFallbacks() {
+    return this.fallbacks;
+  }
+  setMain(accessToken, entry, accountId, completeSnapshot = !1) {
+    if (!completeSnapshot && !hasAnyQuotaWindow(entry.quota))
+      return;
+    this.mainTokenFp = tokenFingerprint(accessToken);
+    if (accountId && this.mainQuotaAccountId && this.mainQuotaAccountId !== accountId)
+      this.clearRateLimited("main");
+    if (accountId)
+      this.mainQuotaAccountId = accountId;
+    this.main = entry;
+    if (quotaLooksHealthy(entry.quota))
+      this.clearRateLimited("main");
+  }
+  peekMainForPolicy(accountId) {
+    if (accountId && this.mainQuotaAccountId && this.mainQuotaAccountId !== accountId)
+      return null;
+    return this.main;
+  }
+  peekFallbackForPolicy(accountId, identity) {
+    const entry = this.fallbacks.get(accountId) ?? null;
+    if (identity && entry?.accountId && entry.accountId !== identity)
+      return null;
+    return entry;
+  }
+  setFallback(accountId, entry, accessToken, completeSnapshot = !1, identity) {
+    if (!completeSnapshot && !hasAnyQuotaWindow(entry.quota))
+      return;
+    const previousIdentity = this.fallbacks.get(accountId)?.accountId;
+    if (identity && previousIdentity && identity !== previousIdentity)
+      this.clearRateLimited(accountId);
+    const boundIdentity = identity ?? previousIdentity;
+    this.fallbacks.set(accountId, { ...entry, accountId: boundIdentity });
+    if (accessToken)
+      this.fallbackTokenFps.set(accountId, tokenFingerprint(accessToken));
+    else
+      this.fallbackTokenFps.delete(accountId);
+    if (quotaLooksHealthy(entry.quota))
+      this.clearRateLimited(accountId);
+  }
+  markRateLimited(accountId, resetAtMs) {
+    const existing = this.rateLimitedUntilMap.get(accountId);
+    if (existing !== void 0 && existing > resetAtMs)
+      return;
+    this.rateLimitedUntilMap.set(accountId, resetAtMs);
+  }
+  isRateLimited(accountId) {
+    const until = this.rateLimitedUntilMap.get(accountId);
+    return until !== void 0 && this.now() < until;
+  }
+  rateLimitedUntil(accountId) {
+    return this.rateLimitedUntilMap.get(accountId);
+  }
+  clearRateLimited(accountId) {
+    this.rateLimitedUntilMap.delete(accountId);
+  }
+  async refreshMain(accessToken) {
+    const fp = tokenFingerprint(accessToken);
+    if (this.mainTokenFp && this.mainTokenFp !== fp) {
+      this.main = null;
+      this.mainTokenFp = null;
+    }
+    if (this.inflightMain && this.inflightMainFp === fp)
+      return this.inflightMain;
+    if (this.isBackedOff()) {
+      if (this.main)
+        return this.main.quota;
+      throw Error("Quota API rate-limited \u2014 try again later");
+    }
+    this.inflightMainFp = fp;
+    this.inflightMain = this._fetchMain(accessToken);
+    return this.inflightMain;
+  }
+  async refreshFallback(accountId, accessToken) {
+    const inflightKey = QuotaManager.fallbackInflightKey(accountId, accessToken), inflight = this.inflightFallbacks.get(inflightKey);
+    if (inflight)
+      return inflight;
+    if (this.isFallbackBackedOff(accountId, accessToken)) {
+      const cached = this.getFallback(accountId, accessToken);
+      if (cached)
+        return cached.quota;
+      throw Error("Quota API rate-limited \u2014 try again later");
+    }
+    const promise = this._fetchFallback(accountId, accessToken);
+    this.inflightFallbacks.set(inflightKey, promise);
+    return promise;
+  }
+  async refreshAllFallbacks(accounts) {
+    const now = this.now();
+    for (const account of accounts) {
+      if (account.enabled === !1)
+        continue;
+      if (isTombstoned(account) || !account.access)
+        continue;
+      const cached = this.getFallback(account.id, account.access);
+      if (cached && now < cached.refreshAfter)
+        continue;
+      try {
+        await this.refreshFallback(account.id, account.access);
+      } catch {}
+    }
+  }
+  refreshMainInBackground(accessToken) {
+    const fp = tokenFingerprint(accessToken);
+    if (this.inflightMain && this.inflightMainFp === fp)
+      return;
+    if (this.isBackedOff())
+      return;
+    this.refreshMain(accessToken).catch(() => {});
+  }
+  isMainStale() {
+    if (!this.main)
+      return !0;
+    return this.now() >= this.main.refreshAfter;
+  }
+  isFallbackStale(accountId, accessToken) {
+    const entry = this.getFallback(accountId, accessToken);
+    if (!entry)
+      return !0;
+    return this.now() >= entry.refreshAfter;
+  }
+  shouldRefreshOnRequestCount(requestCount) {
+    const everyN = getQuotaRefreshEveryNRequests(this.storage);
+    if (everyN <= 0)
+      return !1;
+    return requestCount > 0 && requestCount % everyN === 0;
+  }
+  needsRefresh(requestCount) {
+    return this.isMainStale() || this.shouldRefreshOnRequestCount(requestCount);
+  }
+  updateStorage(storage) {
+    this.storage = storage;
+    this.seedMainFromStorage(storage);
+    this.seedMainBackoffFromStorage(storage);
+  }
+  seedMainFromStorage(storage, accessToken) {
+    const persisted = getPersistedMainQuota(storage);
+    if (!persisted)
+      return;
+    const accessTokenFp = accessToken ? tokenFingerprint(accessToken) : null;
+    if (accessTokenFp && persisted.tokenFingerprint && persisted.tokenFingerprint !== accessTokenFp)
+      return;
+    const entry = {
+      quota: persisted.quota,
+      refreshAfter: getQuotaNextRefreshAt(persisted.quota, storage, persisted.checkedAt),
+      checkedAt: persisted.checkedAt
+    };
+    if (this.main && this.main.checkedAt >= entry.checkedAt && (!accessTokenFp || !this.mainTokenFp || this.mainTokenFp === accessTokenFp))
+      return;
+    this.main = entry;
+    this.mainTokenFp = persisted.tokenFingerprint ?? null;
+    if (storage?.mainAccountId) {
+      if (this.mainQuotaAccountId && this.mainQuotaAccountId !== storage.mainAccountId)
+        this.clearRateLimited("main");
+      this.mainQuotaAccountId = storage.mainAccountId;
+    }
+  }
+  seedMainBackoffFromStorage(storage) {
+    const persistedError = storage?.quota?.mainLastQuotaApiError;
+    this.mainLastApiError = persistedError && quotaBackoffActive(persistedError, this.now()) ? persistedError : void 0;
+  }
+  seedFallbacksFromAccounts(accounts) {
+    const checkInterval = getQuotaCheckIntervalMs(this.storage);
+    for (const account of accounts) {
+      if (account.enabled === !1)
+        continue;
+      if (!account.quota)
+        continue;
+      const checkedAt = Math.max(account.quota.primary?.checkedAt ?? 0, account.quota.secondary?.checkedAt ?? 0);
+      if (checkedAt <= 0)
+        continue;
+      const existing = this.getFallback(account.id, account.access);
+      if (existing && existing.checkedAt >= checkedAt)
+        continue;
+      this.setFallback(account.id, {
+        quota: account.quota,
+        refreshAfter: checkedAt + checkInterval,
+        checkedAt
+      }, account.access, !1, account.accountId);
+    }
+  }
+  isBackedOff() {
+    return quotaBackoffActive(this.mainLastApiError, this.now());
+  }
+  isFallbackBackedOff(accountId, accessToken) {
+    if (accessToken) {
+      if (this.fallbackErrorTokenFps.get(accountId) !== tokenFingerprint(accessToken))
+        return !1;
+    }
+    return quotaBackoffActive(this.fallbackApiErrors.get(accountId), this.now());
+  }
+  getLastApiError() {
+    return this.mainLastApiError;
+  }
+  static API_CALL_GAP_MS = 1000;
+  static fallbackInflightKey(accountId, accessToken) {
+    return JSON.stringify([accountId, tokenFingerprint(accessToken)]);
+  }
+  static quotaLockName(accountId) {
+    return `opencode-fallback-quota-refresh-${accountId.replace(/[^a-zA-Z0-9._-]+/g, "-") || "account"}`;
+  }
+  _enqueueApiFetch(fn) {
+    const gatedFn = async () => {
+      const elapsed = this.now() - this.lastApiCallAt;
+      if (elapsed < QuotaManager.API_CALL_GAP_MS)
+        await new Promise((r) => {
+          const id = nativeSetTimeout(r, QuotaManager.API_CALL_GAP_MS - elapsed);
+          if (typeof id === "object" && "unref" in id)
+            id.unref();
+        });
+      this.lastApiCallAt = this.now();
+      return fn();
+    }, queued = this.apiGate.then(gatedFn, gatedFn);
+    this.apiGate = queued.catch(() => {});
+    return queued;
+  }
+  async _fetchMain(accessToken) {
+    const thisFetchFp = tokenFingerprint(accessToken);
+    return this._enqueueApiFetch(async () => {
+      try {
+        if (this.isBackedOff()) {
+          if (this.main)
+            return this.main.quota;
+          throw Error("Quota API rate-limited \u2014 try again later");
+        }
+        const fileLock = await acquireRefreshFileLock({
+          name: "opencode-main-quota-refresh",
+          ttlMs: 30000,
+          path: this.configPath
+        });
+        if (!fileLock) {
+          const cached = this.main;
+          if (cached && this.now() < cached.refreshAfter)
+            return cached.quota;
+          throw Error("Quota refresh is already in progress");
+        }
+        try {
+          const fetchStartedAt = this.now(), quota = await this._fetchQuota(accessToken), now = this.now();
+          this.mainTokenFp = tokenFingerprint(accessToken);
+          this.main = {
+            quota,
+            refreshAfter: getQuotaNextRefreshAt(quota, this.storage, now),
+            checkedAt: now
+          };
+          if (quotaLooksHealthy(quota))
+            this.clearRateLimited("main");
+          this.mainLastApiError = void 0;
+          this.onMainQuotaFetched?.(quota, now, this.mainTokenFp, fetchStartedAt);
+          return quota;
+        } catch (error) {
+          this._handleMainFetchError(error);
+          throw error;
+        } finally {
+          await fileLock.release();
+        }
+      } finally {
+        if (this.inflightMainFp === thisFetchFp) {
+          this.inflightMain = null;
+          this.inflightMainFp = null;
+        }
+      }
+    });
+  }
+  async _fetchFallback(accountId, accessToken) {
+    return this._enqueueApiFetch(async () => {
+      try {
+        if (this.isFallbackBackedOff(accountId, accessToken)) {
+          const cached = this.getFallback(accountId, accessToken);
+          if (cached)
+            return cached.quota;
+          throw Error("Quota API rate-limited \u2014 try again later");
+        }
+        const fileLock = await acquireRefreshFileLock({
+          name: QuotaManager.quotaLockName(accountId),
+          ttlMs: 30000,
+          path: this.configPath
+        });
+        if (!fileLock) {
+          const cached = this.getFallback(accountId, accessToken);
+          if (cached && this.now() < cached.refreshAfter)
+            return cached.quota;
+          throw Error("Quota refresh is already in progress");
+        }
+        try {
+          const quota = await this._fetchQuota(accessToken), now = this.now();
+          this.setFallback(accountId, {
+            quota,
+            refreshAfter: now + getQuotaCheckIntervalMs(this.storage),
+            checkedAt: now
+          }, accessToken, !0);
+          this.fallbackApiErrors.delete(accountId);
+          this.fallbackErrorTokenFps.delete(accountId);
+          return quota;
+        } finally {
+          await fileLock.release();
+        }
+      } catch (error) {
+        this._handleFallbackFetchError(accountId, accessToken, error);
+        throw error;
+      } finally {
+        this.inflightFallbacks.delete(QuotaManager.fallbackInflightKey(accountId, accessToken));
+      }
+    });
+  }
+  async _fetchQuota(accessToken) {
+    if (!this.fetchQuotaFn)
+      throw Error("Quota fetch not available \u2014 no fetchQuotaFn injected (push-only mode)");
+    return this.fetchQuotaFn({
+      accessToken,
+      fetchImpl: this.fetchImpl,
+      now: this.now
+    });
+  }
+  static isAuthError(error) {
+    return error?.status === 401;
+  }
+  _handleMainFetchError(error) {
+    if (QuotaManager.isAuthError(error))
+      return;
+    this.mainLastApiError = buildQuotaOperationError({
+      error,
+      now: this.now(),
+      previous: this.mainLastApiError
+    });
+    this.onApiError?.(this.mainLastApiError);
+  }
+  _handleFallbackFetchError(accountId, accessToken, error) {
+    if (QuotaManager.isAuthError(error))
+      return;
+    const tokenFp = tokenFingerprint(accessToken), previous = this.fallbackErrorTokenFps.get(accountId) === tokenFp ? this.fallbackApiErrors.get(accountId) : void 0;
+    this.fallbackApiErrors.set(accountId, buildQuotaOperationError({
+      error,
+      now: this.now(),
+      previous
+    }));
+    this.fallbackErrorTokenFps.set(accountId, tokenFp);
+  }
+}
+function hasAnyQuotaWindow(quota) {
+  return Boolean(quota.primary || quota.secondary);
+}
+function quotaLooksHealthy(quota) {
+  const { primary, secondary } = quota;
+  if (!primary && !secondary)
+    return !1;
+  if (primary && primary.usedPercent >= 100)
+    return !1;
+  if (secondary && secondary.usedPercent >= 100)
+    return !1;
+  return !0;
+}