@cortexkit/opencode-openai-auth 0.7.2 → 0.9.0

package/dist/core/provider.d.ts

@@ -1,70 +0,0 @@
-/**
- * Provider injection seam — shared types and the 2 Codex provider fns.
- *
- * Both fns are constructor-injected into FallbackAccountManager and
- * QuotaManager so the generic core never imports provider specifics
- * directly.
- */
-import type { OAuthQuotaSnapshot } from './accounts.ts';
-declare const log: {
-    error: (m: string, d?: unknown) => void;
-    warn: (m: string, d?: unknown) => void;
-    info: (m: string, d?: unknown) => void;
-    debug: (m: string, d?: unknown) => void;
-    trace: (m: string, d?: unknown) => void;
-};
-type QuotaLogger = Pick<typeof log, 'debug' | 'warn'>;
-export type QuotaWindowName = string;
-export declare const PRIMARY: QuotaWindowName;
-export declare const SECONDARY: QuotaWindowName;
-export interface ProviderHttpError extends Error {
-    status?: number;
-    retryAfter?: number;
-    /** True when this error originated from a token-refresh call (not a quota fetch). */
-    isRefreshError?: boolean;
-}
-export type ProviderRefreshFn = (input: {
-    refreshToken: string;
-    fetchImpl: typeof fetch;
-    now: () => number;
-}) => Promise<{
-    access: string;
-    refresh: string;
-    expires: number;
-    expiresIn: number;
-}>;
-export type ProviderQuotaFn = (input: {
-    accessToken: string;
-    fetchImpl: typeof fetch;
-    now: () => number;
-}) => Promise<OAuthQuotaSnapshot>;
-export declare const CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
-export declare const CODEX_ISSUER = "https://auth.openai.com";
-/**
- * Core Codex OAuth refresh — the single entry point for refreshing an
- * OpenAI OAuth token.  Used by both the legacy refreshAccessToken in
- * index.ts AND the FallbackAccountManager (via constructor injection).
- *
- * Throws a ProviderHttpError carrying `.status` (from the HTTP response)
- * and `.retryAfter` (parsed from Retry-After) so backoff machinery can
- * duck-type them without instanceof checks.
- */
-export declare function codexRefreshFn(input: {
-    refreshToken: string;
-    fetchImpl: typeof fetch;
-    now: () => number;
-}): Promise<{
-    access: string;
-    refresh: string;
-    expires: number;
-    expiresIn: number;
-}>;
-export declare function whamUsageFn(input: {
-    accessToken: string;
-    fetchImpl: typeof fetch;
-    now: () => number;
-    accountId?: string;
-    accountKey?: string;
-    logger?: QuotaLogger;
-}): Promise<OAuthQuotaSnapshot>;
-export {};

package/dist/core/quota-manager.d.ts

@@ -1,192 +0,0 @@
-/**
- * Unified quota cache and API gateway.
- *
- * Single source of truth for main + fallback quota state. All consumers
- * share one QuotaManager instance so they see the same in-memory cache.
- * Handles deduplication, rate-limiting (429 backoff), and staleness.
- *
- * Adapted from anthropic-auth — provider-specific quota fetch injected via
- * fetchQuotaFn instead of hard-importing fetchOAuthQuotaSnapshot.
- */
-import type { AccountOperationError, AccountQuotaWindow, AccountStorage, OAuthAccount, OAuthQuotaSnapshot } from './accounts.ts';
-import { type ProviderQuotaFn } from './provider.ts';
-export type { ProviderQuotaFn };
-export declare function quotaWindowResetIsPast(window: AccountQuotaWindow | undefined, now: number): boolean;
-/**
- * Resolve when a WS-exhausted account becomes usable. Admission errors can
- * carry the provider's authoritative reset; response.failed frames do not, so
- * those fall back to the named window in the last-known quota snapshot. Never
- * borrow the other window's reset — an unrelated window can blackhole the
- * account long past its actual limit. The bounded default self-corrects when a
- * later request reports exhaustion again.
- */
-export declare function resolveMidStreamRateLimitResetAt(quota: OAuthQuotaSnapshot | undefined, window: string, now: number, defaultMs: number, explicitResetAt?: number): number;
-/**
- * Stable, non-reversible fingerprint of an access token. Used to detect a
- * main-account switch so a different account's persisted/cached quota is never
- * reused. Not a secret — a truncated SHA-256, safe to persist alongside quota.
- */
-export declare function tokenFingerprint(token: string): string;
-export type QuotaEntry = {
-    quota: OAuthQuotaSnapshot;
-    refreshAfter: number;
-    checkedAt: number;
-    accountId?: string;
-};
-export type QuotaManagerOptions = {
-    storage: AccountStorage | null;
-    fetchImpl?: typeof fetch;
-    now?: () => number;
-    /** Injected quota-fetch function — replaces the hard-imported Anthropic fetchOAuthQuotaSnapshot */
-    fetchQuotaFn?: ProviderQuotaFn;
-    onMainQuotaFetched?: (quota: OAuthQuotaSnapshot, checkedAt: number, fingerprint: string, fetchStartedAt: number) => void;
-    onApiError?: (error: AccountOperationError) => void;
-};
-export declare class QuotaManager {
-    private main;
-    private mainTokenFp;
-    private mainQuotaAccountId;
-    private fallbacks;
-    private fallbackTokenFps;
-    private inflightMain;
-    private inflightMainFp;
-    private inflightFallbacks;
-    private mainLastApiError;
-    private fallbackApiErrors;
-    private fallbackErrorTokenFps;
-    private rateLimitedUntilMap;
-    private apiGate;
-    private lastApiCallAt;
-    private storage;
-    private readonly fetchImpl;
-    private readonly now;
-    private readonly fetchQuotaFn;
-    private readonly onMainQuotaFetched;
-    private readonly onApiError;
-    constructor(opts: QuotaManagerOptions);
-    /**
-     * Cached main quota entry. Pass the live access token to enforce token
-     * binding: if the cached entry was produced by a different token (main
-     * account switched), it is dropped and null is returned so the caller
-     * refetches for the current account. Called without a token (e.g. for
-     * display) it returns whatever is cached.
-     */
-    getMain(accessToken?: string): QuotaEntry | null;
-    /**
-     * Cached fallback quota entry. Pass the live access token to enforce token
-     * binding: if the entry was produced by a different token (account re-login),
-     * it is dropped and null is returned so the caller refetches.
-     */
-    getFallback(accountId: string, accessToken?: string): QuotaEntry | null;
-    getAllFallbacks(): Map<string, QuotaEntry>;
-    setMain(accessToken: string, entry: QuotaEntry, accountId?: string, completeSnapshot?: boolean): void;
-    /**
-     * Non-invalidating read of the cached main quota for POLICY decisions
-     * (killswitch). Unlike getMain(token), a token mismatch does NOT drop the
-     * cache — an access-token refresh is a same-account event and must not turn a
-     * known-exhausted account into "unknown" (which would fail open and spend).
-     *
-     * Pass the live ChatGPT accountId to still drop on a genuine account SWITCH:
-     * if the cached entry's account identity is known and differs, return null so
-     * the killswitch treats it as unknown rather than judging account A by account
-     * B's quota. When identity is unknown on either side, the cached snapshot is
-     * returned (best-effort) — the same fail-open-on-unknown stance as elsewhere.
-     */
-    peekMainForPolicy(accountId?: string): QuotaEntry | null;
-    /**
-     * Non-invalidating read of a cached fallback quota for POLICY decisions
-     * (killswitch, admission). Keyed by the stable internal account id, so a
-     * token refresh for the same account does not drop it (getFallback(id, token)
-     * would).
-     *
-     * Pass the live ChatGPT identity to still drop on a genuine re-login: if the
-     * cached entry's identity is known and differs, return null so the previous
-     * identity's (possibly exhausted) quota is never judged against its
-     * replacement. Unknown on either side fails open, matching peekMainForPolicy.
-     */
-    peekFallbackForPolicy(accountId: string, identity?: string): QuotaEntry | null;
-    setFallback(accountId: string, entry: QuotaEntry, accessToken?: string, completeSnapshot?: boolean, identity?: string): void;
-    /**
-     * Mark accountId ('main' or a fallback id) rate-limited until resetAtMs.
-     * Keeps the LATER reset: skips only when an existing mark is strictly
-     * later than resetAtMs, so an equal-reset re-mark still applies (idempotent)
-     * instead of being silently dropped by a stale `>=` comparison.
-     */
-    markRateLimited(accountId: string, resetAtMs: number): void;
-    /** True iff accountId has a mark whose reset has not yet passed. */
-    isRateLimited(accountId: string): boolean;
-    /**
-     * Raw stored reset for accountId's mark, or undefined if none. Unlike
-     * isRateLimited, this does NOT apply read-time expiry — callers on the
-     * block path already know the mark is live (isRateLimited just returned
-     * true) and want its exact reset estimate for a Retry-After computation.
-     */
-    rateLimitedUntil(accountId: string): number | undefined;
-    /** Explicit early clear — read-time expiry in isRateLimited is primary. */
-    clearRateLimited(accountId: string): void;
-    refreshMain(accessToken: string): Promise<OAuthQuotaSnapshot>;
-    refreshFallback(accountId: string, accessToken: string): Promise<OAuthQuotaSnapshot>;
-    refreshAllFallbacks(accounts: OAuthAccount[]): Promise<void>;
-    /**
-     * Fire-and-forget refresh. Does not await, swallows errors.
-     */
-    refreshMainInBackground(accessToken: string): void;
-    isMainStale(): boolean;
-    isFallbackStale(accountId: string, accessToken?: string): boolean;
-    shouldRefreshOnRequestCount(requestCount: number): boolean;
-    /**
-     * Combined check: should a refresh happen right now?
-     * True if main is stale by time OR triggered by request count.
-     */
-    needsRefresh(requestCount: number): boolean;
-    updateStorage(storage: AccountStorage | null): void;
-    /**
-     * Seed/update the main quota cache from persisted state. This is deliberately
-     * callable after every disk load so another plugin process's fresh quota write
-     * can stop this process from showing "checking…" or making a redundant quota
-     * API call.
-     */
-    seedMainFromStorage(storage: AccountStorage | null, accessToken?: string): void;
-    private seedMainBackoffFromStorage;
-    /**
-     * Seed fallback cache entries from persisted account.quota data.
-     * Updates older in-memory entries so a fresh quota write from another plugin
-     * process prevents redundant checks and stale sidebar writes.
-     */
-    seedFallbacksFromAccounts(accounts: OAuthAccount[]): void;
-    /**
-     * Whether the MAIN quota API is currently in backoff. Scoped to the main
-     * account — a fallback account's 429 never reports here.
-     */
-    isBackedOff(): boolean;
-    /**
-     * Whether a specific fallback account's quota API is in backoff.
-     */
-    isFallbackBackedOff(accountId: string, accessToken?: string): boolean;
-    getLastApiError(): AccountOperationError | undefined;
-    /** Minimum gap between consecutive quota API calls (ms). */
-    private static readonly API_CALL_GAP_MS;
-    private static fallbackInflightKey;
-    private static quotaLockName;
-    /**
-     * Serialize API calls through a shared gate so only one
-     * quota API request runs at a time, with a minimum gap
-     * between calls. Prevents concurrent and rapid-fire calls
-     * from triggering rate limits.
-     */
-    private _enqueueApiFetch;
-    private _fetchMain;
-    private _fetchFallback;
-    /** Route through injected fetchQuotaFn, or throw if unset. */
-    private _fetchQuota;
-    private static isAuthError;
-    /** Main quota failure: arms main-only backoff and persists via onApiError. */
-    private _handleMainFetchError;
-    /**
-     * Fallback quota failure: arms backoff for THIS account only. Never touches
-     * main backoff state and never calls onApiError (which persists the main
-     * quota error) — the per-account error is recorded by the caller via the
-     * account's lastQuotaRefreshError.
-     */
-    private _handleFallbackFetchError;
-}

package/dist/core/refresh-all-quota.d.ts

@@ -1,86 +0,0 @@
-import { type SidebarState } from '../sidebar-state';
-import type { FallbackAccountManager, isOAuthAccount, loadAccounts } from './accounts';
-import type { whamUsageFn } from './provider';
-import type { QuotaManager } from './quota-manager';
-declare const log: {
-    error: (m: string, d?: unknown) => void;
-    warn: (m: string, d?: unknown) => void;
-    info: (m: string, d?: unknown) => void;
-    debug: (m: string, d?: unknown) => void;
-    trace: (m: string, d?: unknown) => void;
-};
-type QuotaLogger = Pick<typeof log, 'debug' | 'warn'>;
-export interface RefreshAllQuotaDeps {
-    getAuth: () => Promise<{
-        type: string;
-        access?: string;
-        refresh?: string;
-        expires?: number;
-    }>;
-    codexRefreshFn: (input: {
-        refreshToken: string;
-        fetchImpl: typeof fetch;
-        now: () => number;
-    }) => Promise<{
-        access: string;
-        refresh: string;
-        expires: number;
-    }>;
-    refreshMainWithLease: () => Promise<{
-        access: string;
-        refresh: string;
-        expires: number;
-    }>;
-    fallbackManager: FallbackAccountManager;
-    quotaManager: QuotaManager;
-    loadAccounts: typeof loadAccounts;
-    writeSidebarState: (qm: QuotaManager, store: Awaited<ReturnType<typeof loadAccounts>>) => Promise<void>;
-    client: {
-        auth: {
-            set: (input: {
-                path: {
-                    id: string;
-                };
-                body: {
-                    type: string;
-                    access?: string;
-                    refresh: string;
-                    expires?: number;
-                };
-            }) => Promise<unknown>;
-        };
-    };
-    fetchImpl: typeof fetch;
-    now: () => number;
-    configPath: string;
-    storageMainAccountId: string | undefined;
-    isOAuthAccountFn: typeof isOAuthAccount;
-    whamFn?: typeof whamUsageFn;
-    respectBackoff?: boolean;
-    logger?: QuotaLogger;
-    skipFresherThanMs?: number;
-    readSidebarState?: () => Promise<SidebarState>;
-}
-export interface RefreshAllQuotaOptions {
-    accountKey?: string;
-}
-export interface RefreshAllQuotaOptions {
-    accountKey?: string;
-}
-export interface RefreshAllQuotaResult {
-    account: string;
-    ok: boolean;
-    error?: string;
-    /**
-     * The account cannot recover on its own: the provider has rejected its
-     * credentials, so no amount of retrying will help until the operator re-adds
-     * it.
-     *
-     * Carried as a flag rather than left for the caller to infer from `error`,
-     * because sniffing an error string for a user-facing decision breaks the
-     * moment the wording changes.
-     */
-    permanent?: boolean;
-}
-export declare function refreshAllQuota(deps: RefreshAllQuotaDeps, options?: RefreshAllQuotaOptions): Promise<RefreshAllQuotaResult[]>;
-export {};

package/dist/core/refresh-file-lock.d.ts

@@ -1,12 +0,0 @@
-export declare function isLostMarkerRaceError(error: unknown): boolean;
-export declare function acquireRefreshFileLock(options: {
-    name: string;
-    ttlMs: number;
-    path?: string;
-    now?: () => number;
-    renew?: boolean;
-    renewIntervalMs?: number;
-    onStep?: (step: 'stale-marker-stat' | 'stale-marker-claimed' | 'stale-lock-confirmed' | 'eviction-marker-acquired' | 'renewal-owner-confirmed' | 'renewal-marker-unavailable' | 'renewal-write-fenced' | 'renewal-write-ready' | 'relinquish-read' | 'renewal-finished' | 'release-owner-confirmed') => void | Promise<void>;
-}): Promise<{
-    release: () => Promise<void>;
-} | null>;

package/dist/core/reset-credits.d.ts

@@ -1,116 +0,0 @@
-import { type loadAccounts, type mutateAccounts, type OAuthQuotaSnapshot, type ResetAccountState, type ResetInFlight } from './accounts.ts';
-export interface ResetCredit {
-    id: string;
-    status: string;
-    grantedAt?: string;
-    expiresAt: string;
-    resetType?: string;
-    isSupportedByPlan: boolean;
-}
-export interface ResetCreditList {
-    credits: ResetCredit[];
-    availableCount?: number;
-}
-export type ResetConsumeKind = 'reset' | 'already_redeemed' | 'nothing_to_reset' | 'no_credit' | 'http_error' | 'ambiguous';
-export interface ResetConsumeOutcome {
-    kind: ResetConsumeKind;
-    raw: unknown;
-    status?: number;
-}
-export type ResetPrecondition = {
-    ok: true;
-} | {
-    ok: false;
-    reason: 'not exhausted';
-};
-export interface ResetStateDeps {
-    configPath: string;
-    mutateAccountsFn: typeof mutateAccounts;
-    loadAccountsFn: typeof loadAccounts;
-    now: () => number;
-    randomUUID: () => string;
-}
-export interface ResetResolvedTarget {
-    accountKey: string;
-    label: string;
-    accessToken: string;
-    chatgptAccountId?: string;
-}
-export interface RunResetCreditDeps extends ResetStateDeps {
-    fetchImpl: typeof fetch;
-    resolveTarget(accountKey: string): Promise<ResetResolvedTarget>;
-    fetchUsage(target: ResetResolvedTarget): Promise<OAuthQuotaSnapshot>;
-    hasActiveRateLimitMark(accountKey: string): boolean;
-}
-export interface RunResetCreditInput {
-    accountKey: string;
-    expectedChatgptAccountId: string;
-    retry: boolean;
-}
-export type ResetRedemptionErrorKind = 'invalid_account_key' | 'identity_mismatch' | 'cooldown_active' | 'expired_unreconciled' | 'retry_without_inflight' | 'not_exhausted' | 'no_eligible_credit';
-export declare class ResetRedemptionError extends Error {
-    readonly kind: ResetRedemptionErrorKind;
-    readonly cooldownUntil?: number;
-    constructor(kind: ResetRedemptionErrorKind, message: string, cooldownUntil?: number);
-}
-export interface ResetLocalAmbiguousOutcome {
-    kind: 'ambiguous_local';
-    raw: {
-        reason: 'corrupt_in_flight';
-    };
-}
-export type ResetRedemptionOutcome = ResetConsumeOutcome | ResetLocalAmbiguousOutcome;
-export type ResetSelectedCredit = ResetCredit | {
-    id: string;
-};
-export interface RunResetCreditResult {
-    target: ResetResolvedTarget;
-    selectedCredit: ResetSelectedCredit | undefined;
-    beforeState: ResetAccountState | undefined;
-    outcome: ResetRedemptionOutcome;
-    retrySafety: string;
-    finalizeStateWriteFailed?: boolean;
-}
-interface ResetClaim {
-    inFlight: ResetInFlight;
-    selectedCredit: ResetSelectedCredit;
-}
-type ResetStateDecision = {
-    kind: 'fresh';
-    beforeState: ResetAccountState | undefined;
-} | {
-    kind: 'claim';
-    beforeState: ResetAccountState | undefined;
-    claim: ResetClaim;
-} | {
-    kind: 'expired_unreconciled';
-    beforeState: ResetAccountState | undefined;
-    claim: ResetClaim;
-} | {
-    kind: 'cooldown';
-    beforeState: ResetAccountState | undefined;
-    cooldownUntil: number;
-} | {
-    kind: 'corrupt';
-    beforeState: ResetAccountState | undefined;
-};
-export type ResetCreditErrorKind = 'http_error' | 'invalid_response';
-export declare class ResetCreditError extends Error {
-    readonly kind: ResetCreditErrorKind;
-    readonly status?: number;
-    constructor(kind: ResetCreditErrorKind, message: string, status?: number);
-}
-export declare function claimResetAttempt(deps: ResetStateDeps, accountKey: string, credits: readonly ResetCredit[]): Promise<ResetStateDecision>;
-export declare function finalizeResetAttempt(deps: ResetStateDeps, accountKey: string, completing: ResetInFlight, outcome: ResetConsumeOutcome): Promise<void>;
-export declare function resetWindowIsExhausted(window: {
-    usedPercent: number;
-    resetsAt?: string;
-} | undefined, now: number): boolean;
-export declare function evaluateResetPrecondition(quota: OAuthQuotaSnapshot, hasActiveRateLimitMark: boolean, now: number): ResetPrecondition;
-export declare function listResetCredits(fetchImpl: typeof fetch, token: string, accountId?: string): Promise<ResetCreditList>;
-export declare function selectCreditToSpend(credits: readonly ResetCredit[]): ResetCredit | undefined;
-export declare function isResetCreditEligible(credit: ResetCredit): boolean;
-export declare function countEligibleResetCredits(credits: readonly ResetCredit[]): number;
-export declare function consumeResetCredit(fetchImpl: typeof fetch, token: string, accountId: string | undefined, creditId: string, redeemRequestId: string): Promise<ResetConsumeOutcome>;
-export declare function runResetCreditRedemption(deps: RunResetCreditDeps, input: RunResetCreditInput): Promise<RunResetCreditResult>;
-export {};

package/dist/core/sticky-routing.d.ts

@@ -1,43 +0,0 @@
-import { type AccountQuota, type QuotaWindow, type QuotaWindowKey } from '../sidebar-state';
-export declare const QUOTA_STALENESS_MS: number;
-export declare const MIN_RESET_HOURS: number;
-export declare const MIN_WEIGHT = 0.000001;
-export declare function snapshotCheckedAt(quota: AccountQuota | null | undefined, entryCheckedAt?: number): number | undefined;
-export type StickyBreakDecision = {
-    action: 'retain';
-    reason: 'unknown' | 'stale' | 'healthy' | 'transient';
-} | {
-    action: 'migrate';
-    reason: 'exhausted' | 'permanent' | 'killswitch';
-    windowKey?: QuotaWindowKey;
-    resetsAt?: string;
-};
-export declare function decideStickyBreak(input: {
-    quota: AccountQuota | null | undefined;
-    quotaCheckedAt?: number;
-    status?: number;
-    now: number;
-    killswitchPasses?: boolean;
-}): StickyBreakDecision;
-export declare function sustainableWindowWeight(window: Pick<QuotaWindow, 'remainingPercent' | 'resetsAt'>, reservePercent: number, now: number): number;
-export interface StickySelectionCandidate {
-    accountId: string;
-    quota: AccountQuota | null | undefined;
-    quotaCheckedAt?: number;
-    reservePercent: Record<QuotaWindowKey, number>;
-    configuredOrder: number;
-    resetCreditsApplicable?: number;
-    killswitchPasses?: boolean;
-}
-export interface StickySelectionInput {
-    candidates: readonly StickySelectionCandidate[];
-    pendingBytes: ReadonlyMap<string, number>;
-    requestBytes: number;
-    now: number;
-    onEmptyWeightedSet?: () => void;
-}
-export declare function selectStickyCandidate(input: StickySelectionInput): {
-    accountId: string;
-    quotaCheckedAt?: number;
-    source: 'weighted' | 'mode-fallback';
-} | undefined;

package/dist/dump.d.ts

@@ -1,20 +0,0 @@
-export declare const DUMP_SESSION_HEADER = "x-cortexkit-openai-auth-dump-session";
-type DumpHeaders = ConstructorParameters<typeof Headers>[0];
-type DumpTransport = 'http' | 'websocket';
-declare const DUMP_PHASES: readonly ['http', 'prewarm', 'main'];
-type DumpPhase = (typeof DUMP_PHASES)[number];
-export declare function dumpCodexRequest(input: {
-    sessionID?: string | null;
-    transport: DumpTransport;
-    phase: DumpPhase;
-    bodyText: string;
-    accountId?: string;
-    url?: string;
-    method?: string;
-    headers?: DumpHeaders;
-    status?: number;
-    error?: string;
-}): Promise<void>;
-export declare function dumpDiagnostic(event: Record<string, unknown>): Promise<void>;
-export declare function resetDumpStateForTest(): void;
-export {};

package/dist/hosted-web-search.d.ts

@@ -1,5 +0,0 @@
-import { type ToolDefinition } from '@opencode-ai/plugin';
-export declare const HostedWebSearchTool: ToolDefinition;
-export declare function translateHostedWebSearchEvent(event: Record<string, unknown>): Record<string, unknown> | undefined;
-export declare function translateHostedWebSearchResponse(response: Response): Response;
-export declare function rewriteHostedWebSearchReplay(body: Record<string, unknown>): boolean;

package/dist/index-87145jkw.js

@@ -1,2 +0,0 @@
-function K(k){if(k==null||k==="")return;let q=typeof k==="number"?k:Number(k);if(Number.isFinite(q)){let B=q<100000000000?q*1000:q,G=new Date(B);return Number.isNaN(G.getTime())?void 0:G.toISOString()}let z=new Date(k);return Number.isNaN(z.getTime())?void 0:z.toISOString()}function L(k){let q=Number(k);return Number.isFinite(q)&&q>0?q:void 0}function X(k){return typeof k==="number"&&Number.isFinite(k)&&k>=0?k:void 0}function Y(k,q){let z=k.get(q);if(z===null||z.trim()==="")return;let B=Number(z);if(!Number.isFinite(B)||B<0||B>100)return;let G=q.slice(0,-13),J=L(k.get(`${G}-window-minutes`)),V=K(k.get(`${G}-reset-at`)??void 0);if(B===0&&k.get(`${G}-window-minutes`)==="0"&&!V)return;return{usedPercent:B,remainingPercent:100-B,resetsAt:V,checkedAt:Date.now(),...J!==void 0?{windowMinutes:J}:{}}}var O=["x-codex-primary-used-percent","x-codex-secondary-used-percent"];function Q(k,q){let z=k.get(q);if(z===null)return"absent";if(z.trim()==="")return"invalid";let B=Number(z);return Number.isFinite(B)&&B>=0&&B<=100?"valid":"invalid"}function g(k){if(O.some((G)=>Q(k,G)==="invalid"))return{};let q={},z=Y(k,"x-codex-primary-used-percent");if(z)q.primary=z;let B=Y(k,"x-codex-secondary-used-percent");if(B)q.secondary=B;return q}function I(k){let q=O.map((z)=>Q(k,z));return q.includes("valid")&&!q.includes("invalid")}function Z(k){if(!k)return;if(!Number.isFinite(k.used_percent)||k.used_percent<0||k.used_percent>100)return;let q=L(k.window_minutes),z=K(k.reset_at);if(k.used_percent===0&&q===void 0&&!z)return;return{usedPercent:k.used_percent,remainingPercent:100-k.used_percent,resetsAt:z,checkedAt:Date.now(),...q!==void 0?{windowMinutes:q}:{}}}function f(k){let q={},z=Z(k.rate_limits?.primary);if(z)q.primary=z;let B=Z(k.rate_limits?.secondary);if(B)q.secondary=B;return q}function $(k){if(!k)return;if(!Number.isFinite(k.used_percent)||k.used_percent<0||k.used_percent>100)return;let q=L(k.limit_window_seconds),z=K(k.reset_at);if(k.used_percent===0&&q===void 0&&!z)return;return{usedPercent:k.used_percent,remainingPercent:100-k.used_percent,resetsAt:z,checkedAt:Date.now(),...q!==void 0?{windowMinutes:q/60}:{}}}function x(k){let q={},z=$(k.rate_limit?.primary_window);if(z)q.primary=z;let B=$(k.rate_limit?.secondary_window);if(B)q.secondary=B;let G=X(k.rate_limit_reset_credits?.available_count);if(G!==void 0)q.resetCreditsAvailable=G;let J=X(k.rate_limit_reset_credits?.applicable_available_count);if(J!==void 0)q.resetCreditsApplicable=J;return q}
-export{K as c,g as d,I as e,f,x as g};

package/dist/index-8f1200qx.js

@@ -1,6 +0,0 @@
-import{realpathSync as k}from"node:fs";import{homedir as i}from"node:os";import{basename as P,dirname as m,join as D,resolve as w}from"node:path";var d="openai-auth.json",r="openai-auth-state.json";function t(){if(process.env.OPENCODE_CONFIG_DIR?.trim())return process.env.OPENCODE_CONFIG_DIR.trim();return D(process.env.XDG_CONFIG_HOME||D(i(),".config"),"opencode")}function C(){return process.env.OPENCODE_OPENAI_AUTH_FILE?.trim()||D(t(),d)}function e(B){return P(B)===d?D(m(B),r):`${B}.state.json`}function q(B,Q){let J=w(B);return Q==="win32"||Q==="darwin"?J.toLowerCase():J}function f(B){try{return k.native(B)}catch{try{return D(k.native(m(B)),P(B))}catch{return}}}function o(B,Q,J=process.platform){if(q(B,J)===q(Q,J))return!0;let j=f(B),W=f(Q);return j!==void 0&&W!==void 0&&q(j,J)===q(W,J)}function ZB(B=C()){let Q=process.env.OPENCODE_OPENAI_AUTH_STATE_FILE?.trim();if(Q){if(o(B,Q))throw Error(`OPENCODE_OPENAI_AUTH_STATE_FILE resolves to the config path (${w(B)}). Set OPENCODE_OPENAI_AUTH_STATE_FILE to a different file.`);return Q}return e(B)}import{randomUUID as y}from"node:crypto";import{mkdir as h,readFile as F,rename as BB,rm as x,stat as l,writeFile as L}from"node:fs/promises";import{dirname as GB,join as p}from"node:path";var HB=globalThis.setTimeout.bind(globalThis),JB=globalThis.clearTimeout.bind(globalThis);function KB(B){let Q=B?.code;return Q==="ENOENT"||Q==="EINVAL"||Q==="ENOTDIR"}async function DB(B){let J=`${B.path??C()}.${B.name}.lock`,j=p(J,"owner.json"),W=y(),Z=B.now??Date.now,X=null,$=!1,N=null,z=`${J}.evicting`,A=p(z,"owner.json"),I=y(),c=5000,O=8;async function b(){try{return JSON.parse(await F(J,"utf8"))}catch(G){if(G.code!=="EISDIR")throw G;return JSON.parse(await F(j,"utf8"))}}async function s(){await L(J,`${JSON.stringify({ownerId:W,expiresAt:Z()+B.ttlMs})}
-`,{encoding:"utf8",mode:384})}async function _(){try{return await L(J,`${JSON.stringify({ownerId:W,expiresAt:Z()+B.ttlMs})}
-`,{encoding:"utf8",mode:384,flag:"wx"}),!0}catch(G){let H=G.code;if(H==="EEXIST"||H==="EISDIR")return!1;if(H==="ENOENT"){await h(GB(J),{recursive:!0});try{return await L(J,`${JSON.stringify({ownerId:W,expiresAt:Z()+B.ttlMs})}
-`,{encoding:"utf8",mode:384,flag:"wx"}),!0}catch(K){let R=K.code;if(R==="EEXIST"||R==="EISDIR")return!1;throw K}}throw G}}async function U(){await new Promise((G)=>setTimeout(G,Math.floor(Math.random()*4)))}async function T(){try{let G=await b();return Number(G?.expiresAt)>Z()}catch{try{return(await l(J)).mtimeMs+B.ttlMs>Z()}catch{return!1}}}async function Y(){try{return JSON.parse(await F(A,"utf8"))?.ownerId===I}catch{return!1}}async function S(){if(await Y())await x(z,{recursive:!0,force:!0}).catch(()=>{})}async function M(){await h(z);try{await L(A,`${JSON.stringify({ownerId:I,createdAt:Z()})}
-`,{encoding:"utf8",mode:384,flag:"wx"})}catch(G){if(KB(G))return!1;throw await S(),G}if(B.onStep)await B.onStep("eviction-marker-acquired");return!0}async function g(){let G;try{G=await l(z)}catch(K){if(K.code==="ENOENT")return"missing";throw K}if(G.mtimeMs+c>Z())return"fresh";if(B.onStep)await B.onStep("stale-marker-stat");let H=`${z}.${y()}`;try{await BB(z,H)}catch(K){if(K.code==="ENOENT")return"missing";throw K}if(B.onStep)await B.onStep("stale-marker-claimed");return await x(H,{recursive:!0,force:!0}).catch(()=>{}),"recovered"}async function E(G){try{if(!await M())return!1}catch(H){if(H.code==="EEXIST")return!1;throw H}try{await G()}finally{await S()}return!0}async function a(){for(let G=0;G<O;G++){if(B.onStep)await B.onStep("relinquish-read");let H;try{H=await b()}catch{return}if(H?.ownerId!==W)return;try{await x(J,{recursive:!0,force:!0});return}catch{await U()}}}function u(){if(!B.renew||$)return;let G=B.renewIntervalMs??Math.max(1000,Math.floor(B.ttlMs/3));if(X=HB(()=>{let H=(async()=>{let K=!$;try{if(!await E(async()=>{let v=await b(),n=Z();if($||v?.ownerId!==W){K=!1;return}if(Number(v?.expiresAt)<=n){K=!1;return}if(B.onStep)await B.onStep("renewal-owner-confirmed");if($){K=!1;return}if(!await Y())return;if(B.onStep)await B.onStep("renewal-write-fenced");if($){K=!1;return}if(!await Y())return;if(B.onStep)await B.onStep("renewal-write-ready");if(await s(),!await Y()){K=!1,await a();return}})&&B.onStep)await B.onStep("renewal-marker-unavailable")}catch{}finally{if(B.onStep)try{await B.onStep("renewal-finished")}catch{}if(K&&!$)u()}})();N=H,H.finally(()=>{if(N===H)N=null})},G),"unref"in X)X.unref()}let V=await _();if(!V)for(let G=0;G<O;G++){if(V=await _(),V)break;if(await T())return null;try{if(!await M()){await U();continue}}catch(H){if(H.code!=="EEXIST")throw H;if(await g()==="fresh")return null;await U();continue}try{if(await T())return null;if(!await Y())return null;if(B.onStep)await B.onStep("stale-lock-confirmed");if(!await Y())return null;if(await x(J,{recursive:!0,force:!0}).catch(()=>{}),!await Y())return null;if(V=await _(),!V)return null;if(!await Y())return await x(J,{recursive:!0,force:!0}).catch(()=>{}),V=!1,null;break}finally{await S()}}if(!V)return null;return u(),{release:async()=>{if($=!0,X)JB(X),X=null;await N;for(let G=0;G<O;G++){try{if(await E(async()=>{if((await b())?.ownerId!==W)return;if(B.onStep)await B.onStep("release-owner-confirmed");if(!await Y())return;await x(J,{recursive:!0,force:!0}).catch(()=>{})}))return;await g()}catch{return}await U()}}}}
-export{C as ua,ZB as va,DB as wa};