@kaitranntt/ccs 7.52.2 → 7.53.0-dev.2

package/dist/cliproxy/quota-fetcher.js

@@ -35,14 +35,11 @@ const path = __importStar(require("node:path"));
 const config_generator_1 = require("./config-generator");
 const account_manager_1 = require("./account-manager");
 const auth_utils_1 = require("./auth-utils");
+const proxy_target_resolver_1 = require("./proxy-target-resolver");
 /** Google Cloud Code API endpoints */
 const ANTIGRAVITY_API_BASE = 'https://cloudcode-pa.googleapis.com';
 const ANTIGRAVITY_API_VERSION = 'v1internal';
-/** Google OAuth token endpoint */
-const GOOGLE_TOKEN_URL = 'https://oauth2.googleapis.com/token';
-/** Antigravity OAuth credentials (from CLIProxyAPIPlus - public in open-source code) */
-const ANTIGRAVITY_CLIENT_ID = '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com';
-const ANTIGRAVITY_CLIENT_SECRET = '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';
+const MANAGEMENT_API_TIMEOUT_MS = 5000;
 /** Headers for loadCodeAssist (matches CLIProxyAPI antigravity.go) */
 const LOADCODEASSIST_HEADERS = {
     'Content-Type': 'application/json',
@@ -55,61 +52,221 @@ const FETCHMODELS_HEADERS = {
     'Content-Type': 'application/json',
     'User-Agent': 'antigravity/1.104.0 darwin/arm64',
 };
-/**
- * Refresh access token using refresh_token via Google OAuth
- * This allows CCS to get fresh tokens independently of CLIProxyAPI
- */
-async function refreshAccessToken(refreshToken, verbose = false) {
-    if (verbose)
-        console.error('[i] Refreshing access token...');
+function safeParseJson(bodyText) {
+    try {
+        return JSON.parse(bodyText);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeErrorDetail(bodyText) {
+    const normalized = bodyText.trim();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized.length <= 400) {
+        return normalized;
+    }
+    return `${normalized.slice(0, 397)}...`;
+}
+function buildAntigravityFailure(status, bodyText) {
+    const detail = normalizeErrorDetail(bodyText || '');
+    if (status === 401) {
+        return {
+            httpStatus: 401,
+            error: 'Token expired or invalid',
+            errorCode: 'reauth_required',
+            actionHint: 'Re-authenticate this account. If CLIProxy is running, retry after the proxy finishes refreshing the token.',
+            needsReauth: true,
+            errorDetail: detail,
+        };
+    }
+    if (status === 403) {
+        return {
+            httpStatus: 403,
+            error: 'Access forbidden',
+            errorCode: 'quota_api_forbidden',
+            actionHint: 'This account does not have Gemini Code Assist quota access.',
+            isForbidden: true,
+            errorDetail: detail,
+        };
+    }
+    if (status === 429) {
+        return {
+            httpStatus: 429,
+            error: 'Rate limited - try again later',
+            errorCode: 'rate_limited',
+            actionHint: 'Retry later. This looks temporary.',
+            retryable: true,
+            errorDetail: detail,
+        };
+    }
+    if (status === 408) {
+        return {
+            httpStatus: 408,
+            error: 'Request timeout',
+            errorCode: 'network_timeout',
+            actionHint: 'Retry later. This looks temporary.',
+            retryable: true,
+            errorDetail: detail,
+        };
+    }
+    if (typeof status === 'number' && status >= 500) {
+        return {
+            httpStatus: status,
+            error: `API error: ${status}`,
+            errorCode: 'provider_unavailable',
+            actionHint: 'Retry later. The provider appears unavailable.',
+            retryable: true,
+            errorDetail: detail,
+        };
+    }
+    if (typeof status === 'number' && status >= 400) {
+        return {
+            httpStatus: status,
+            error: `API error: ${status}`,
+            errorCode: 'quota_request_failed',
+            errorDetail: detail,
+        };
+    }
+    return {
+        error: 'Quota request failed',
+        errorCode: 'quota_request_failed',
+        errorDetail: detail,
+    };
+}
+async function readManagedResponse(response, viaManagement) {
+    const bodyText = await response.text();
+    return {
+        status: response.status,
+        bodyText,
+        json: safeParseJson(bodyText),
+        viaManagement,
+    };
+}
+function isAntigravityAuthFileForAccount(file, accountId) {
+    const provider = (file.provider || file.type || '').trim().toLowerCase();
+    if (provider !== 'antigravity' && provider !== 'agy') {
+        return false;
+    }
+    const normalizedAccount = accountId.trim().toLowerCase();
+    const normalizedEmail = file.email?.trim().toLowerCase();
+    if (normalizedEmail && normalizedEmail === normalizedAccount) {
+        return true;
+    }
+    const normalizedName = file.name?.trim().toLowerCase();
+    if (!normalizedName) {
+        return false;
+    }
+    const sanitizedAccount = (0, auth_utils_1.sanitizeEmail)(accountId).toLowerCase();
+    return (normalizedName === `antigravity-${sanitizedAccount}.json` ||
+        normalizedName === `agy-${sanitizedAccount}.json`);
+}
+async function findManagedAntigravityAuthIndex(accountId) {
+    const target = (0, proxy_target_resolver_1.getProxyTarget)();
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const timeoutId = setTimeout(() => controller.abort(), MANAGEMENT_API_TIMEOUT_MS);
     try {
-        const response = await fetch(GOOGLE_TOKEN_URL, {
+        const response = await fetch((0, proxy_target_resolver_1.buildProxyUrl)(target, '/v0/management/auth-files'), {
+            signal: controller.signal,
+            headers: (0, proxy_target_resolver_1.buildManagementHeaders)(target),
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            return null;
+        }
+        const data = (await response.json());
+        const match = data.files?.find((file) => isAntigravityAuthFileForAccount(file, accountId));
+        return match?.auth_index ?? null;
+    }
+    catch {
+        clearTimeout(timeoutId);
+        return null;
+    }
+}
+async function performManagedAntigravityRequest(accountId, url, headers, body) {
+    const authIndex = await findManagedAntigravityAuthIndex(accountId);
+    if (authIndex === null || authIndex === undefined) {
+        return null;
+    }
+    const target = (0, proxy_target_resolver_1.getProxyTarget)();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), MANAGEMENT_API_TIMEOUT_MS);
+    try {
+        const response = await fetch((0, proxy_target_resolver_1.buildProxyUrl)(target, '/v0/management/api-call'), {
+            method: 'POST',
+            signal: controller.signal,
+            headers: (0, proxy_target_resolver_1.buildManagementHeaders)(target, {
+                'Content-Type': 'application/json',
+            }),
+            body: JSON.stringify({
+                auth_index: authIndex,
+                method: 'POST',
+                url,
+                header: {
+                    ...headers,
+                    Authorization: 'Bearer $TOKEN$',
+                },
+                data: body,
+            }),
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            return null;
+        }
+        const apiResponse = (await response.json());
+        const bodyText = typeof apiResponse.body === 'string' ? apiResponse.body : '';
+        return {
+            status: typeof apiResponse.status_code === 'number' ? apiResponse.status_code : 500,
+            bodyText,
+            json: safeParseJson(bodyText),
+            viaManagement: true,
+        };
+    }
+    catch {
+        clearTimeout(timeoutId);
+        return null;
+    }
+}
+async function performAntigravityRequest(accountId, accessToken, url, headers, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), MANAGEMENT_API_TIMEOUT_MS);
+    try {
+        const response = await fetch(url, {
             method: 'POST',
             signal: controller.signal,
             headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
+                ...headers,
+                Authorization: `Bearer ${accessToken}`,
             },
-            body: new URLSearchParams({
-                grant_type: 'refresh_token',
-                refresh_token: refreshToken,
-                client_id: ANTIGRAVITY_CLIENT_ID,
-                client_secret: ANTIGRAVITY_CLIENT_SECRET,
-            }).toString(),
+            body,
         });
         clearTimeout(timeoutId);
-        if (verbose)
-            console.error(`[i] Token refresh status: ${response.status}`);
-        const data = (await response.json());
-        if (!response.ok || data.error) {
-            const error = data.error_description || data.error || `OAuth error: ${response.status}`;
-            if (verbose)
-                console.error(`[!] Token refresh failed: ${error}`);
-            return {
-                accessToken: null,
-                error,
-            };
+        const directResult = await readManagedResponse(response, false);
+        if (directResult.status !== 401) {
+            return directResult;
         }
-        if (!data.access_token) {
-            if (verbose)
-                console.error('[!] Token refresh failed: No access_token in response');
-            return { accessToken: null, error: 'No access_token in response' };
-        }
-        if (verbose)
-            console.error('[i] Token refresh: success');
-        return { accessToken: data.access_token };
+        const managedResult = await performManagedAntigravityRequest(accountId, url, headers, body);
+        return managedResult ?? directResult;
     }
     catch (err) {
         clearTimeout(timeoutId);
-        const errorMsg = err instanceof Error && err.name === 'AbortError'
-            ? 'Token refresh timeout'
-            : err instanceof Error
-                ? err.message
-                : 'Unknown error';
-        if (verbose)
-            console.error(`[!] Token refresh failed: ${errorMsg}`);
-        return { accessToken: null, error: errorMsg };
+        if (err instanceof Error && err.name === 'AbortError') {
+            return {
+                status: 408,
+                bodyText: '',
+                json: null,
+                viaManagement: false,
+            };
+        }
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        return {
+            status: 503,
+            bodyText: message,
+            json: null,
+            viaManagement: false,
+        };
     }
 }
 /**
@@ -198,173 +355,111 @@ function mapTierString(tierStr) {
  * Get project ID and tier via loadCodeAssist endpoint
  * Uses paidTier.id for accurate tier detection (g1-ultra-tier, g1-pro-tier)
  */
-async function getProjectId(accessToken) {
+async function getProjectId(accountId, accessToken) {
     const url = `${ANTIGRAVITY_API_BASE}/${ANTIGRAVITY_API_VERSION}:loadCodeAssist`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 5000);
-    try {
-        const response = await fetch(url, {
-            method: 'POST',
-            signal: controller.signal,
-            headers: {
-                ...LOADCODEASSIST_HEADERS,
-                Authorization: `Bearer ${accessToken}`,
-            },
-            body: JSON.stringify({
-                metadata: {
-                    ideType: 'IDE_UNSPECIFIED',
-                    platform: 'PLATFORM_UNSPECIFIED',
-                    pluginType: 'GEMINI',
-                },
-            }),
-        });
-        clearTimeout(timeoutId);
-        if (!response.ok) {
-            // Return specific error based on status
-            if (response.status === 401) {
-                return { projectId: null, error: 'Token expired or invalid' };
-            }
-            if (response.status === 403) {
-                return { projectId: null, error: 'Access forbidden' };
-            }
-            return { projectId: null, error: `API error: ${response.status}` };
-        }
-        const data = (await response.json());
-        // Extract project ID from response
-        let projectId;
-        if (typeof data.cloudaicompanionProject === 'string') {
-            projectId = data.cloudaicompanionProject;
-        }
-        else if (typeof data.cloudaicompanionProject === 'object') {
-            projectId = data.cloudaicompanionProject?.id;
-        }
-        if (!projectId?.trim()) {
-            // Account authenticated but not provisioned - user needs to sign in via Antigravity app
-            return {
-                projectId: null,
-                error: 'Sign in to Antigravity app to activate quota.',
-                isUnprovisioned: true,
-            };
-        }
-        // Extract tier - paidTier reflects actual subscription status, takes priority
-        // API returns: paidTier.id = "g1-ultra-tier" or "g1-pro-tier"
-        // allowedTiers/currentTier often return "standard-tier" which is not useful
-        const tierStr = data.paidTier?.id || data.currentTier?.id;
-        const tier = mapTierString(tierStr);
-        return { projectId: projectId.trim(), tier };
+    const body = JSON.stringify({
+        metadata: {
+            ideType: 'IDE_UNSPECIFIED',
+            platform: 'PLATFORM_UNSPECIFIED',
+            pluginType: 'GEMINI',
+        },
+    });
+    const response = await performAntigravityRequest(accountId, accessToken, url, LOADCODEASSIST_HEADERS, body);
+    if (response.status < 200 || response.status >= 300) {
+        return {
+            projectId: null,
+            ...buildAntigravityFailure(response.status, response.bodyText),
+        };
     }
-    catch (err) {
-        clearTimeout(timeoutId);
-        if (err instanceof Error && err.name === 'AbortError') {
-            return { projectId: null, error: 'Request timeout' };
-        }
-        return { projectId: null, error: err instanceof Error ? err.message : 'Unknown error' };
+    const data = response.json;
+    if (!data) {
+        return {
+            projectId: null,
+            error: 'Invalid quota response from provider',
+            errorCode: 'provider_unavailable',
+            retryable: true,
+        };
+    }
+    // Extract project ID from response
+    let projectId;
+    if (typeof data.cloudaicompanionProject === 'string') {
+        projectId = data.cloudaicompanionProject;
+    }
+    else if (typeof data.cloudaicompanionProject === 'object') {
+        projectId = data.cloudaicompanionProject?.id;
     }
+    if (!projectId?.trim()) {
+        return {
+            projectId: null,
+            error: 'Sign in to Antigravity app to activate quota.',
+            errorCode: 'account_unprovisioned',
+            actionHint: 'Complete sign-in in the Antigravity app, then retry quota refresh.',
+            isUnprovisioned: true,
+        };
+    }
+    // Extract tier - paidTier reflects actual subscription status, takes priority
+    const tierStr = data.paidTier?.id || data.currentTier?.id;
+    const tier = mapTierString(tierStr);
+    return { projectId: projectId.trim(), tier };
 }
 /**
  * Fetch available models with quota info
  * Note: projectId is kept for potential future use but not sent in body
  * (CLIProxyAPI sends empty {} body for this endpoint)
  */
-async function fetchAvailableModels(accessToken, _projectId) {
+async function fetchAvailableModels(accountId, accessToken, _projectId) {
     const url = `${ANTIGRAVITY_API_BASE}/${ANTIGRAVITY_API_VERSION}:fetchAvailableModels`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 5000);
-    try {
-        // Match CLIProxyAPI exactly: empty body, minimal headers
-        const response = await fetch(url, {
-            method: 'POST',
-            signal: controller.signal,
-            headers: {
-                ...FETCHMODELS_HEADERS,
-                Authorization: `Bearer ${accessToken}`,
-            },
-            body: JSON.stringify({}),
-        });
-        clearTimeout(timeoutId);
-        if (response.status === 403) {
-            // 403 = account lacks Gemini Code Assist access (not same as quota exhausted)
-            // Keep success=false with isForbidden flag for UI to show distinct "403" badge
-            return {
-                success: false,
-                models: [],
-                lastUpdated: Date.now(),
-                isForbidden: true,
-                error: '403 Forbidden - No Gemini Code Assist access',
-            };
-        }
-        if (response.status === 401) {
-            return {
-                success: false,
-                models: [],
-                lastUpdated: Date.now(),
-                error: 'Access token expired or invalid',
-            };
-        }
-        if (response.status === 429) {
-            return {
-                success: false,
-                models: [],
-                lastUpdated: Date.now(),
-                error: 'Rate limited - try again later',
-            };
-        }
-        if (!response.ok) {
-            return {
-                success: false,
-                models: [],
-                lastUpdated: Date.now(),
-                error: `API error: ${response.status}`,
-            };
-        }
-        const data = (await response.json());
-        const models = [];
-        if (data.models && typeof data.models === 'object') {
-            for (const [modelId, modelData] of Object.entries(data.models)) {
-                const quotaInfo = modelData.quotaInfo || modelData.quota_info;
-                if (!quotaInfo)
-                    continue;
-                // Extract remaining fraction (0-1 range)
-                const remaining = quotaInfo.remainingFraction ?? quotaInfo.remaining_fraction ?? quotaInfo.remaining;
-                // Extract reset time
-                const resetTime = quotaInfo.resetTime || quotaInfo.reset_time || null;
-                // If remaining is not a valid number but resetTime exists, treat as exhausted (0%)
-                // This happens when Claude models hit quota limit - API returns resetTime but no fraction
-                let percentage;
-                if (typeof remaining === 'number' && isFinite(remaining)) {
-                    percentage = Math.max(0, Math.min(100, Math.round(remaining * 100)));
-                }
-                else if (resetTime) {
-                    // Model is exhausted but has reset time - show as 0%
-                    percentage = 0;
-                }
-                else {
-                    // No valid data, skip this model
-                    continue;
-                }
-                models.push({
-                    name: modelId,
-                    displayName: modelData.displayName,
-                    percentage,
-                    resetTime,
-                });
-            }
-        }
+    const response = await performAntigravityRequest(accountId, accessToken, url, FETCHMODELS_HEADERS, JSON.stringify({}));
+    if (response.status < 200 || response.status >= 300) {
         return {
-            success: true,
-            models,
+            success: false,
+            models: [],
             lastUpdated: Date.now(),
+            ...buildAntigravityFailure(response.status, response.bodyText),
         };
     }
-    catch (err) {
-        clearTimeout(timeoutId);
+    const data = response.json;
+    if (!data) {
         return {
             success: false,
             models: [],
             lastUpdated: Date.now(),
-            error: err instanceof Error ? err.message : 'Unknown error',
+            error: 'Invalid quota response from provider',
+            errorCode: 'provider_unavailable',
+            retryable: true,
         };
     }
+    const models = [];
+    if (data.models && typeof data.models === 'object') {
+        for (const [modelId, modelData] of Object.entries(data.models)) {
+            const quotaInfo = modelData.quotaInfo || modelData.quota_info;
+            if (!quotaInfo)
+                continue;
+            const remaining = quotaInfo.remainingFraction ?? quotaInfo.remaining_fraction ?? quotaInfo.remaining;
+            const resetTime = quotaInfo.resetTime || quotaInfo.reset_time || null;
+            let percentage;
+            if (typeof remaining === 'number' && isFinite(remaining)) {
+                percentage = Math.max(0, Math.min(100, Math.round(remaining * 100)));
+            }
+            else if (resetTime) {
+                percentage = 0;
+            }
+            else {
+                continue;
+            }
+            models.push({
+                name: modelId,
+                displayName: modelData.displayName,
+                percentage,
+                resetTime,
+            });
+        }
+    }
+    return {
+        success: true,
+        models,
+        lastUpdated: Date.now(),
+    };
 }
 /**
  * Fetch quota for an Antigravity account
@@ -400,56 +495,44 @@ async function fetchAccountQuota(provider, accountId, verbose = false) {
             models: [],
             lastUpdated: Date.now(),
             error,
+            errorCode: 'auth_file_missing',
+            actionHint: 'Reconnect this account so CCS can read a current auth token.',
         };
     }
-    // Determine which access token to use
-    // File-based token is often stale (CLIProxyAPIPlus refreshes at runtime but doesn't persist)
-    // Proactive refresh: refresh 5 minutes before expiry (matches CLIProxyAPIPlus behavior)
-    let accessToken = authData.accessToken;
-    const REFRESH_LEAD_TIME_MS = 5 * 60 * 1000; // 5 minutes
-    let tokenRefreshed = false;
-    if (authData.refreshToken) {
-        const shouldRefresh = authData.isExpired || // Already expired
-            !authData.expiresAt || // No expiry info - refresh to be safe
-            new Date(authData.expiresAt).getTime() - Date.now() < REFRESH_LEAD_TIME_MS; // Expiring soon
-        if (shouldRefresh) {
-            const refreshResult = await refreshAccessToken(authData.refreshToken, verbose);
-            if (refreshResult.accessToken) {
-                accessToken = refreshResult.accessToken;
-                tokenRefreshed = true;
-            }
-            // If refresh fails, fall back to existing token (might still work)
-        }
-    }
-    if (verbose && !tokenRefreshed) {
-        console.error('[i] Token refresh: skipped');
+    const accessToken = authData.accessToken;
+    if (verbose) {
+        const expiryState = authData.isExpired
+            ? 'expired'
+            : authData.expiresAt
+                ? `expires ${authData.expiresAt}`
+                : 'expiry unknown';
+        console.error(`[i] Auth token state: ${expiryState}`);
     }
     // Get project ID and tier - prefer stored project ID, but always call API for tier
     let projectId = authData.projectId;
     let apiTier = 'unknown';
-    // Always call loadCodeAssist to get accurate tier from API
-    let lastProjectResult = await getProjectId(accessToken);
+    // Always call loadCodeAssist to get accurate tier from API.
+    // If the file token is stale, the helper retries through CLIProxy management auth.
+    const lastProjectResult = await getProjectId(accountId, accessToken);
     if (!lastProjectResult.projectId && !projectId) {
-        // If project ID fetch fails, it might be token issue - try refresh if we haven't
-        if (authData.refreshToken && accessToken === authData.accessToken) {
-            const refreshResult = await refreshAccessToken(authData.refreshToken, verbose);
-            if (refreshResult.accessToken) {
-                accessToken = refreshResult.accessToken;
-                lastProjectResult = await getProjectId(accessToken);
-            }
-        }
-        if (!lastProjectResult.projectId) {
-            const error = lastProjectResult.error || 'Failed to retrieve project ID';
-            if (verbose)
-                console.error(`[!] Error: ${error}`);
-            return {
-                success: false,
-                models: [],
-                lastUpdated: Date.now(),
-                error,
-                isUnprovisioned: lastProjectResult.isUnprovisioned,
-            };
-        }
+        const error = lastProjectResult.error || 'Failed to retrieve project ID';
+        if (verbose)
+            console.error(`[!] Error: ${error}`);
+        return {
+            success: false,
+            models: [],
+            lastUpdated: Date.now(),
+            error,
+            errorCode: lastProjectResult.errorCode,
+            errorDetail: lastProjectResult.errorDetail,
+            actionHint: lastProjectResult.actionHint,
+            retryable: lastProjectResult.retryable,
+            httpStatus: lastProjectResult.httpStatus,
+            needsReauth: lastProjectResult.needsReauth,
+            isUnprovisioned: lastProjectResult.isUnprovisioned,
+            isExpired: authData.isExpired,
+            expiresAt: authData.expiresAt || undefined,
+        };
     }
     // Use API project ID if available, else fallback to stored
     projectId = lastProjectResult.projectId || projectId;
@@ -457,38 +540,23 @@ async function fetchAccountQuota(provider, accountId, verbose = false) {
     if (verbose)
         console.error(`[i] Project ID: ${projectId || 'not found'}`);
     // Fetch models with quota
-    const result = await fetchAvailableModels(accessToken, projectId);
+    const result = await fetchAvailableModels(accountId, accessToken, projectId);
     if (verbose)
         console.error(`[i] Models found: ${result.models.length}`);
-    // If quota fetch fails with auth error and we haven't refreshed yet, try refresh
-    if (!result.success && result.error?.includes('expired') && authData.refreshToken) {
-        const refreshResult = await refreshAccessToken(authData.refreshToken, verbose);
-        if (refreshResult.accessToken) {
-            const retryResult = await fetchAvailableModels(refreshResult.accessToken, projectId);
-            // Determine tier from API response only (model inference is unreliable)
-            if (retryResult.success) {
-                const finalTier = apiTier !== 'unknown' ? apiTier : 'unknown';
-                retryResult.tier = finalTier;
-                retryResult.accountId = accountId;
-                if (finalTier !== 'unknown') {
-                    (0, account_manager_1.setAccountTier)(provider, accountId, finalTier);
-                }
-                if (verbose && retryResult.error) {
-                    console.log(`[!] Error: ${retryResult.error}`);
-                }
-            }
-            return retryResult;
-        }
-    }
+    result.accountId = accountId;
+    result.projectId = projectId || undefined;
     // Determine tier from API response only
     if (result.success) {
         const finalTier = apiTier !== 'unknown' ? apiTier : 'unknown';
         result.tier = finalTier;
-        result.accountId = accountId;
         if (finalTier !== 'unknown') {
             (0, account_manager_1.setAccountTier)(provider, accountId, finalTier);
         }
     }
+    else {
+        result.isExpired = authData.isExpired;
+        result.expiresAt = authData.expiresAt || undefined;
+    }
     if (verbose && result.error) {
         console.log(`[!] Error: ${result.error}`);
     }