sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/codexQuota.js

@@ -0,0 +1,564 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { getActiveCodexAccount, getCodexMonitoringHomes, resolveSidekickCodexHome, } from './codexProfiles';
+import { readQuotaSnapshot, writeQuotaSnapshot } from './quotaSnapshots';
+import { FIVE_HOUR_WINDOW_MS, SEVEN_DAY_WINDOW_MS, withQuotaProjections } from './quota';
+import { CodexProvider } from './providers/codex';
+import { walkRolloutFiles } from './providers/rolloutWalker';
+import { isAggregateCodexLimit } from './types/codex';
+const DEFAULT_TAIL_BYTES = 2 * 1024 * 1024;
+const DEFAULT_MAX_SESSION_FILES = 50;
+const CHATGPT_USAGE_URL = 'https://chatgpt.com/backend-api/wham/usage';
+const CHATGPT_RESET_CREDITS_URL = 'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits';
+function timestampMs(value, fallbackMs = 0) {
+    if (!value)
+        return fallbackMs;
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? ms : fallbackMs;
+}
+// Codex can report slightly different percentages for the same reset window
+// across recent sessions. Prefer the aggregate plan family ("codex") over
+// model/feature-specific families (which can read 0% while the plan is busy),
+// then newer reset windows, then the highest observed same-window utilization so
+// local fallbacks do not under-report quota usage.
+function isPreferredQuotaHit(candidate, current) {
+    if (!current)
+        return true;
+    // Family rank first: an aggregate hit always outranks a model-specific one, so a
+    // freshly-used per-model family (e.g. codex_bengalfox at 0%) can never mask the plan quota.
+    const candidateAggregate = isAggregateCodexLimit(candidate.quota.limitId);
+    const currentAggregate = isAggregateCodexLimit(current.quota.limitId);
+    if (candidateAggregate !== currentAggregate)
+        return candidateAggregate;
+    const candidatePrimaryReset = timestampMs(candidate.quota.fiveHour.resetsAt);
+    const currentPrimaryReset = timestampMs(current.quota.fiveHour.resetsAt);
+    if (candidatePrimaryReset !== currentPrimaryReset)
+        return candidatePrimaryReset > currentPrimaryReset;
+    const candidateSecondaryReset = timestampMs(candidate.quota.sevenDay.resetsAt);
+    const currentSecondaryReset = timestampMs(current.quota.sevenDay.resetsAt);
+    if (candidateSecondaryReset !== currentSecondaryReset)
+        return candidateSecondaryReset > currentSecondaryReset;
+    const candidateUtilization = candidate.quota.fiveHour.utilization + candidate.quota.sevenDay.utilization;
+    const currentUtilization = current.quota.fiveHour.utilization + current.quota.sevenDay.utilization;
+    if (candidateUtilization !== currentUtilization)
+        return candidateUtilization > currentUtilization;
+    const candidateMs = timestampMs(candidate.quota.capturedAt, candidate.mtimeMs);
+    const currentMs = timestampMs(current.quota.capturedAt, current.mtimeMs);
+    if (candidateMs !== currentMs)
+        return candidateMs > currentMs;
+    return candidate.mtimeMs > current.mtimeMs;
+}
+function normalizePercent(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function windowMinutesToMs(value, fallbackMs) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0
+        ? value * 60_000
+        : fallbackMs;
+}
+function timestampToIso(seconds) {
+    if (typeof seconds !== 'number' || !Number.isFinite(seconds) || seconds <= 0) {
+        return '';
+    }
+    return new Date(seconds * 1000).toISOString();
+}
+function accountEmail(account) {
+    return account?.email ?? account?.metadata?.email;
+}
+/** Stamp a Codex quota sample with its runtime provider, projections, and account identity. */
+export function enrichCodexQuota(state, account) {
+    const withProjections = withQuotaProjections(state);
+    return {
+        ...withProjections,
+        runtimeProvider: 'codex',
+        providerId: 'codex',
+        accountLabel: account?.label,
+        accountDetail: accountEmail(account),
+    };
+}
+function unavailableCodexQuota(error, account, meta = {}) {
+    return enrichCodexQuota({
+        fiveHour: { utilization: 0, resetsAt: '' },
+        sevenDay: { utilization: 0, resetsAt: '' },
+        available: false,
+        error,
+        providerId: 'codex',
+        fiveHourLabel: 'Primary',
+        sevenDayLabel: 'Secondary',
+        ...meta,
+    }, account);
+}
+function parseRetryAfterMs(retryAfter) {
+    if (!retryAfter)
+        return undefined;
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return Math.round(seconds * 1000);
+    }
+    const retryAt = Date.parse(retryAfter);
+    if (Number.isNaN(retryAt))
+        return undefined;
+    return Math.max(retryAt - Date.now(), 0);
+}
+function firstString(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function normalizeCredits(credits) {
+    if (!credits)
+        return undefined;
+    return {
+        hasCredits: credits.has_credits ?? credits.hasCredits,
+        unlimited: credits.unlimited,
+        balance: credits.balance ?? undefined,
+    };
+}
+function normalizeCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function normalizeResetCreditsPayload(payload, capturedAt) {
+    const credits = Array.isArray(payload.credits)
+        ? payload.credits.flatMap((credit) => {
+            const status = firstString(credit.status);
+            const expiresAt = firstString(credit.expires_at);
+            if (!status || !expiresAt)
+                return [];
+            return [
+                {
+                    title: firstString(credit.title),
+                    status,
+                    resetType: firstString(credit.reset_type),
+                    expiresAt,
+                    grantedAt: firstString(credit.granted_at),
+                },
+            ];
+        })
+        : [];
+    return {
+        availableCount: normalizeCount(payload.available_count),
+        totalEarnedCount: typeof payload.total_earned_count === 'number' && Number.isFinite(payload.total_earned_count)
+            ? payload.total_earned_count
+            : undefined,
+        credits,
+        source: 'api',
+        capturedAt,
+    };
+}
+function normalizeRateLimitReachedType(value) {
+    if (typeof value === 'string')
+        return value;
+    return firstString(value?.kind);
+}
+function normalizeApiWindow(window) {
+    if (!window)
+        return undefined;
+    const windowMinutes = typeof window.window_minutes === 'number' || window.window_minutes === null
+        ? window.window_minutes
+        : typeof window.limit_window_seconds === 'number'
+            ? Math.round(window.limit_window_seconds / 60)
+            : undefined;
+    const resetsAt = typeof window.resets_at === 'number' || window.resets_at === null
+        ? window.resets_at
+        : window.reset_at;
+    return {
+        used_percent: normalizePercent(window.used_percent),
+        window_minutes: windowMinutes,
+        resets_at: resetsAt,
+    };
+}
+function rateLimitsFromUsagePayload(payload) {
+    if (payload.primary || payload.secondary) {
+        return {
+            limit_id: payload.limit_id ?? 'codex',
+            limit_name: payload.limit_name ?? null,
+            primary: payload.primary,
+            secondary: payload.secondary,
+            credits: normalizeCredits(payload.credits),
+            plan_type: payload.plan_type ?? undefined,
+            rate_limit_reached_type: normalizeRateLimitReachedType(payload.rate_limit_reached_type),
+        };
+    }
+    const preferred = payload.rate_limit;
+    return {
+        limit_id: 'codex',
+        limit_name: null,
+        primary: normalizeApiWindow(preferred?.primary_window),
+        secondary: normalizeApiWindow(preferred?.secondary_window),
+        credits: normalizeCredits(payload.credits),
+        plan_type: payload.plan_type ?? undefined,
+        rate_limit_reached_type: normalizeRateLimitReachedType(payload.rate_limit_reached_type),
+    };
+}
+export function quotaFromCodexRateLimits(rateLimits, source = 'session', capturedAt = new Date().toISOString()) {
+    const primary = rateLimits?.primary;
+    const secondary = rateLimits?.secondary;
+    if (!primary && !secondary)
+        return null;
+    return withQuotaProjections({
+        fiveHour: primary
+            ? {
+                utilization: normalizePercent(primary.used_percent),
+                resetsAt: timestampToIso(primary.resets_at),
+            }
+            : { utilization: 0, resetsAt: '' },
+        sevenDay: secondary
+            ? {
+                utilization: normalizePercent(secondary.used_percent),
+                resetsAt: timestampToIso(secondary.resets_at),
+            }
+            : { utilization: 0, resetsAt: '' },
+        available: true,
+        providerId: 'codex',
+        source,
+        capturedAt,
+        stale: source === 'cache',
+        fiveHourLabel: 'Primary',
+        sevenDayLabel: 'Secondary',
+        limitId: rateLimits?.limit_id,
+        limitName: rateLimits?.limit_name ?? undefined,
+        credits: rateLimits?.credits,
+        planType: rateLimits?.plan_type,
+        rateLimitReachedType: rateLimits?.rate_limit_reached_type,
+    }, {
+        fiveHourWindowMs: windowMinutesToMs(primary?.window_minutes, FIVE_HOUR_WINDOW_MS),
+        sevenDayWindowMs: windowMinutesToMs(secondary?.window_minutes, SEVEN_DAY_WINDOW_MS),
+        capturedAt,
+    });
+}
+export function readLatestCodexQuotaFromRollouts(sessionPaths, options = {}) {
+    return readLatestCodexQuotaHitFromRollouts(sessionPaths, options)?.quota ?? null;
+}
+function readLatestCodexQuotaHitFromRollouts(sessionPaths, options = {}) {
+    const maxSessionFiles = options.maxSessionFiles ?? DEFAULT_MAX_SESSION_FILES;
+    const maxTailBytes = options.maxTailBytes ?? DEFAULT_TAIL_BYTES;
+    let latest = null;
+    for (const sessionPath of sessionPaths.slice(0, maxSessionFiles)) {
+        const hit = readLatestQuotaFromRollout(sessionPath, maxTailBytes, options.source ?? 'session');
+        if (hit && isPreferredQuotaHit(hit, latest)) {
+            latest = hit;
+        }
+    }
+    return latest;
+}
+/**
+ * The newest account-level rollouts, one capped walk across the monitored
+ * homes. `limit` bounds the walk itself, so a large history is never fully
+ * enumerated or stat'ed just to tail a handful of files.
+ */
+function findAccountRolloutFiles(codexHome, limit) {
+    const homes = codexHome ? [codexHome] : getCodexMonitoringHomes();
+    return walkRolloutFiles(homes.map((home) => path.join(home, 'sessions')), { limit }).map((file) => file.path);
+}
+export function resolveCodexQuotaFromLocalSources(options = {}) {
+    const account = options.activeAccount !== undefined ? options.activeAccount : getActiveCodexAccount();
+    const readSnapshot = options.readSnapshot ?? readQuotaSnapshot;
+    const writeSnapshot = options.writeSnapshot ?? writeQuotaSnapshot;
+    const maxTailBytes = options.maxTailBytes ?? DEFAULT_TAIL_BYTES;
+    const maxSessionFiles = options.maxSessionFiles ?? DEFAULT_MAX_SESSION_FILES;
+    let ownProvider = false;
+    const provider = options.provider ??
+        (() => {
+            ownProvider = true;
+            return new CodexProvider();
+        })();
+    try {
+        const candidates = [];
+        if (options.workspacePath) {
+            const workspaceSessions = provider.findAllSessions(options.workspacePath);
+            const workspaceHit = readLatestCodexQuotaHitFromRollouts(workspaceSessions, {
+                maxTailBytes,
+                maxSessionFiles,
+            });
+            if (workspaceHit)
+                candidates.push(workspaceHit);
+        }
+        const accountSessions = findAccountRolloutFiles(options.codexHome, maxSessionFiles);
+        const accountHit = readLatestCodexQuotaHitFromRollouts(accountSessions, {
+            maxTailBytes,
+            maxSessionFiles,
+        });
+        if (accountHit)
+            candidates.push(accountHit);
+        const latestHit = candidates.reduce((latest, candidate) => (isPreferredQuotaHit(candidate, latest) ? candidate : latest), null);
+        if (latestHit) {
+            if (account)
+                writeSnapshot('codex', account.id, latestHit.quota);
+            return enrichCodexQuota(latestHit.quota, account);
+        }
+        const cached = account ? readSnapshot('codex', account.id) : null;
+        if (cached) {
+            return enrichCodexQuota({
+                ...cached,
+                providerId: 'codex',
+                source: 'cache',
+                stale: true,
+                fiveHourLabel: cached.fiveHourLabel ?? 'Primary',
+                sevenDayLabel: cached.sevenDayLabel ?? 'Secondary',
+            }, account);
+        }
+    }
+    finally {
+        if (ownProvider)
+            provider.dispose();
+    }
+    return null;
+}
+export async function resolveCodexQuota(options = {}) {
+    const source = options.source ?? 'local';
+    const account = options.activeAccount !== undefined ? options.activeAccount : getActiveCodexAccount();
+    const writeSnapshot = options.writeSnapshot ?? writeQuotaSnapshot;
+    if (source === 'api') {
+        const apiQuota = await fetchCodexQuotaFromApi(options);
+        if (apiQuota.available) {
+            if (account)
+                writeSnapshot('codex', account.id, apiQuota);
+            return enrichCodexQuota(apiQuota, account);
+        }
+        const fallback = resolveCodexQuotaFromLocalSources(options);
+        return fallback ?? enrichCodexQuota(apiQuota, account);
+    }
+    const local = resolveCodexQuotaFromLocalSources(options);
+    if (local)
+        return local;
+    if (source === 'auto') {
+        const apiQuota = await fetchCodexQuotaFromApi(options);
+        if (apiQuota.available && account) {
+            writeSnapshot('codex', account.id, apiQuota);
+        }
+        return enrichCodexQuota(apiQuota, account);
+    }
+    return unavailableCodexQuota(account
+        ? `No Codex rate-limit data is available for "${account.label ?? account.id}".`
+        : 'No Codex rate-limit data is available.', account, { source: 'session' });
+}
+export async function fetchCodexQuotaFromApi(options = {}) {
+    const capturedAt = options.capturedAt ?? new Date().toISOString();
+    const auth = options.accessToken != null
+        ? { accessToken: options.accessToken, accountId: options.accountId }
+        : readCodexAuth(options.codexHome ?? resolveSidekickCodexHome());
+    const accessToken = auth?.accessToken;
+    if (!accessToken) {
+        return {
+            fiveHour: { utilization: 0, resetsAt: '' },
+            sevenDay: { utilization: 0, resetsAt: '' },
+            available: false,
+            error: 'Codex API refresh requires a ChatGPT login.',
+            failureKind: 'auth',
+            providerId: 'codex',
+            source: 'api',
+            capturedAt,
+            fiveHourLabel: 'Primary',
+            sevenDayLabel: 'Secondary',
+        };
+    }
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    if (options.signal?.aborted)
+        controller.abort();
+    else
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 10_000);
+    timeout.unref();
+    try {
+        const fetchImpl = options.fetchImpl ?? fetch;
+        const response = await fetchImpl(options.usageUrl ?? CHATGPT_USAGE_URL, {
+            method: 'GET',
+            signal: controller.signal,
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                Accept: 'application/json',
+            },
+        });
+        if (!response.ok) {
+            return {
+                fiveHour: { utilization: 0, resetsAt: '' },
+                sevenDay: { utilization: 0, resetsAt: '' },
+                available: false,
+                error: `Codex usage API error: ${response.status}`,
+                failureKind: response.status === 401 || response.status === 403
+                    ? 'auth'
+                    : response.status === 429
+                        ? 'rate_limit'
+                        : response.status >= 500 && response.status <= 599
+                            ? 'server'
+                            : 'unknown',
+                httpStatus: response.status,
+                retryAfterMs: response.status === 429
+                    ? parseRetryAfterMs(response.headers.get('retry-after'))
+                    : undefined,
+                providerId: 'codex',
+                source: 'api',
+                capturedAt,
+                fiveHourLabel: 'Primary',
+                sevenDayLabel: 'Secondary',
+            };
+        }
+        const payload = (await response.json());
+        const quota = quotaFromCodexRateLimits(rateLimitsFromUsagePayload(payload), 'api', capturedAt);
+        if (!quota) {
+            return {
+                fiveHour: { utilization: 0, resetsAt: '' },
+                sevenDay: { utilization: 0, resetsAt: '' },
+                available: false,
+                error: 'Codex usage API returned no rate-limit windows.',
+                failureKind: 'unknown',
+                providerId: 'codex',
+                source: 'api',
+                capturedAt,
+                fiveHourLabel: 'Primary',
+                sevenDayLabel: 'Secondary',
+            };
+        }
+        const resetCredits = await fetchCodexResetCreditsFromApi({
+            ...options,
+            accessToken,
+            accountId: auth?.accountId,
+            capturedAt,
+            signal: controller.signal,
+        });
+        if (resetCredits) {
+            quota.resetCredits = resetCredits;
+        }
+        return quota;
+    }
+    catch {
+        return {
+            fiveHour: { utilization: 0, resetsAt: '' },
+            sevenDay: { utilization: 0, resetsAt: '' },
+            available: false,
+            error: 'Codex usage API network error',
+            failureKind: 'network',
+            providerId: 'codex',
+            source: 'api',
+            capturedAt,
+            fiveHourLabel: 'Primary',
+            sevenDayLabel: 'Secondary',
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+        options.signal?.removeEventListener('abort', onAbort);
+    }
+}
+export async function fetchCodexResetCreditsFromApi(options = {}) {
+    const capturedAt = options.capturedAt ?? new Date().toISOString();
+    const auth = options.accessToken != null
+        ? { accessToken: options.accessToken, accountId: options.accountId }
+        : readCodexAuth(options.codexHome ?? resolveSidekickCodexHome());
+    const accessToken = auth?.accessToken;
+    if (!accessToken)
+        return undefined;
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    if (options.signal?.aborted)
+        controller.abort();
+    else
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 10_000);
+    timeout.unref();
+    try {
+        const fetchImpl = options.fetchImpl ?? fetch;
+        const headers = {
+            Authorization: `Bearer ${accessToken}`,
+            originator: 'Codex Desktop',
+            'OAI-Product-Sku': 'CODEX',
+            Accept: 'application/json',
+        };
+        if (auth?.accountId) {
+            headers['ChatGPT-Account-ID'] = auth.accountId;
+        }
+        const response = await fetchImpl(options.resetCreditsUrl ?? CHATGPT_RESET_CREDITS_URL, {
+            method: 'GET',
+            headers,
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return undefined;
+        return normalizeResetCreditsPayload((await response.json()), capturedAt);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        clearTimeout(timeout);
+        options.signal?.removeEventListener('abort', onAbort);
+    }
+}
+function readCodexAuth(codexHome) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(codexHome, 'auth.json'), 'utf8'));
+        if (parsed.OPENAI_API_KEY || parsed.auth_mode === 'api_key')
+            return null;
+        const accessToken = parsed.tokens?.access_token;
+        if (!accessToken)
+            return null;
+        return {
+            accessToken,
+            accountId: parsed.tokens?.account_id,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readLatestQuotaFromRollout(sessionPath, maxTailBytes, source) {
+    let fd = null;
+    try {
+        const stat = fs.statSync(sessionPath);
+        if (!stat.isFile() || stat.size <= 0)
+            return null;
+        const start = Math.max(0, stat.size - maxTailBytes);
+        const bytesToRead = stat.size - start;
+        const buffer = Buffer.alloc(bytesToRead);
+        fd = fs.openSync(sessionPath, 'r');
+        const bytesRead = fs.readSync(fd, buffer, 0, bytesToRead, start);
+        fs.closeSync(fd);
+        fd = null;
+        let text = buffer.toString('utf8', 0, bytesRead);
+        if (start > 0) {
+            const firstNewline = text.indexOf('\n');
+            text = firstNewline >= 0 ? text.slice(firstNewline + 1) : '';
+        }
+        // Scan from the end for the latest aggregate ("codex") rate-limit sample, which
+        // is what the plan quota represents. Keep the latest sample of any family as a
+        // fallback so a model-only session still surfaces something.
+        const lines = text.split('\n');
+        let fallback = null;
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (!line || !line.includes('rate_limits'))
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.type !== 'event_msg' || parsed.payload?.type !== 'token_count')
+                    continue;
+                const quota = quotaFromCodexRateLimits(parsed.payload.rate_limits, source, parsed.timestamp ?? new Date(stat.mtime).toISOString());
+                if (!quota)
+                    continue;
+                const hit = { quota, filePath: sessionPath, mtimeMs: stat.mtime.getTime() };
+                if (isAggregateCodexLimit(quota.limitId))
+                    return hit;
+                if (!fallback)
+                    fallback = hit;
+            }
+            catch {
+                // Ignore malformed or partial lines.
+            }
+        }
+        if (fallback)
+            return fallback;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    return null;
+}