mirror of
https://github.com/Wei-Shaw/sub2api.git
synced 2026-11-17 14:57:27 +00:00
319 lines
13 KiB
Go
319 lines
13 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"log/slog"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
infraerrors "github.com/Wei-Shaw/sub2api/internal/pkg/errors"
|
|
)
|
|
|
|
// Endpoints used by the OpenAI/ChatGPT/Codex quota query and reset feature.
|
|
const (
|
|
chatGPTUsageURL = "https://chatgpt.com/backend-api/wham/usage"
|
|
chatGPTRateLimitResetURL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume"
|
|
openaiQuotaUpstreamTimeout = 20 * time.Second
|
|
openaiQuotaCodexOriginator = "Codex Desktop"
|
|
openaiQuotaCodexLanguageTag = "zh-CN"
|
|
openaiQuotaSecFetchSite = "none"
|
|
openaiQuotaSecFetchMode = "no-cors"
|
|
openaiQuotaSecFetchDest = "empty"
|
|
)
|
|
|
|
// OpenAIRateLimitWindow describes a single rate-limit window returned by
|
|
// /wham/usage. The upstream returns an explicit `null` window when the slot
|
|
// is unused, so consumers should treat a nil pointer as "no data".
|
|
type OpenAIRateLimitWindow struct {
|
|
UsedPercent float64 `json:"used_percent"`
|
|
LimitWindowSeconds int64 `json:"limit_window_seconds"`
|
|
ResetAfterSeconds int64 `json:"reset_after_seconds"`
|
|
ResetAt int64 `json:"reset_at"`
|
|
}
|
|
|
|
// OpenAIRateLimit is a rate-limit envelope (primary + optional secondary window).
|
|
type OpenAIRateLimit struct {
|
|
Allowed bool `json:"allowed"`
|
|
LimitReached bool `json:"limit_reached"`
|
|
PrimaryWindow *OpenAIRateLimitWindow `json:"primary_window,omitempty"`
|
|
SecondaryWindow *OpenAIRateLimitWindow `json:"secondary_window,omitempty"`
|
|
}
|
|
|
|
// OpenAIAdditionalRateLimit describes a per-feature rate limit (e.g. Codex Spark).
|
|
type OpenAIAdditionalRateLimit struct {
|
|
LimitName string `json:"limit_name"`
|
|
MeteredFeature string `json:"metered_feature"`
|
|
RateLimit *OpenAIRateLimit `json:"rate_limit,omitempty"`
|
|
}
|
|
|
|
// OpenAIRateLimitResetCredits captures the "available_count" surfaced for the
|
|
// rate_limit_reset_credit grant type, which the reset action consumes.
|
|
type OpenAIRateLimitResetCredits struct {
|
|
AvailableCount int `json:"available_count"`
|
|
}
|
|
|
|
// OpenAIQuotaUsage is the typed projection of /wham/usage we expose to the UI.
|
|
// Fields not relevant to the quota card are intentionally omitted to keep the
|
|
// surface narrow; full upstream payload preservation is unnecessary.
|
|
type OpenAIQuotaUsage struct {
|
|
UserID string `json:"user_id,omitempty"`
|
|
AccountID string `json:"account_id,omitempty"`
|
|
Email string `json:"email,omitempty"`
|
|
PlanType string `json:"plan_type,omitempty"`
|
|
RateLimit *OpenAIRateLimit `json:"rate_limit,omitempty"`
|
|
AdditionalRateLimits []OpenAIAdditionalRateLimit `json:"additional_rate_limits,omitempty"`
|
|
RateLimitResetCredits *OpenAIRateLimitResetCredits `json:"rate_limit_reset_credits,omitempty"`
|
|
FetchedAt int64 `json:"fetched_at"`
|
|
}
|
|
|
|
// OpenAIQuotaResetCredit captures the redeemed credit metadata returned by the
|
|
// reset endpoint.
|
|
type OpenAIQuotaResetCredit struct {
|
|
ID string `json:"id,omitempty"`
|
|
ResetType string `json:"reset_type,omitempty"`
|
|
Status string `json:"status,omitempty"`
|
|
GrantedAt string `json:"granted_at,omitempty"`
|
|
ExpiresAt string `json:"expires_at,omitempty"`
|
|
RedeemStartedAt string `json:"redeem_started_at,omitempty"`
|
|
RedeemedAt string `json:"redeemed_at,omitempty"`
|
|
}
|
|
|
|
// OpenAIQuotaResetResult is the typed projection of /wham/rate-limit-reset-credits/consume.
|
|
// The inner Credit also carries `redeemed_at` (RFC3339 string); we deliberately do
|
|
// NOT add a top-level redeemed_at to avoid ambiguity with the nested field.
|
|
type OpenAIQuotaResetResult struct {
|
|
Code string `json:"code"`
|
|
Credit *OpenAIQuotaResetCredit `json:"credit,omitempty"`
|
|
WindowsReset int `json:"windows_reset"`
|
|
}
|
|
|
|
// OpenAIQuotaService queries and consumes ChatGPT/Codex rate-limit reset credits
|
|
// for OpenAI OAuth accounts. It reuses the privacy client factory so all calls
|
|
// flow through the impersonated HTTP client (Cloudflare-friendly TLS fingerprint).
|
|
type OpenAIQuotaService struct {
|
|
accountRepo AccountRepository
|
|
proxyRepo ProxyRepository
|
|
tokenProvider *OpenAITokenProvider
|
|
privacyClientFactory PrivacyClientFactory
|
|
}
|
|
|
|
// NewOpenAIQuotaService constructs a quota service. token provider is required —
|
|
// it ensures we always invoke upstream with a valid (refreshed-if-needed)
|
|
// access_token, sharing the same refresh/locking machinery used by the gateway.
|
|
func NewOpenAIQuotaService(
|
|
accountRepo AccountRepository,
|
|
proxyRepo ProxyRepository,
|
|
tokenProvider *OpenAITokenProvider,
|
|
privacyClientFactory PrivacyClientFactory,
|
|
) *OpenAIQuotaService {
|
|
return &OpenAIQuotaService{
|
|
accountRepo: accountRepo,
|
|
proxyRepo: proxyRepo,
|
|
tokenProvider: tokenProvider,
|
|
privacyClientFactory: privacyClientFactory,
|
|
}
|
|
}
|
|
|
|
// QueryUsage fetches the latest rate-limit/usage snapshot for the given OpenAI
|
|
// OAuth account. Returns infraerrors so the handler layer can map them to
|
|
// stable error codes / HTTP statuses.
|
|
func (s *OpenAIQuotaService) QueryUsage(ctx context.Context, accountID int64) (*OpenAIQuotaUsage, error) {
|
|
accessToken, chatGPTAccountID, proxyURL, fedRAMP, err := s.prepareUpstreamCall(ctx, accountID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
client, err := s.privacyClientFactory(proxyURL)
|
|
if err != nil {
|
|
return nil, infraerrors.Newf(http.StatusBadGateway, "OPENAI_QUOTA_CLIENT_ERROR", "failed to build upstream client: %v", err)
|
|
}
|
|
|
|
callCtx, cancel := context.WithTimeout(ctx, openaiQuotaUpstreamTimeout)
|
|
defer cancel()
|
|
|
|
var payload OpenAIQuotaUsage
|
|
resp, err := client.R().
|
|
SetContext(callCtx).
|
|
SetHeaders(buildCodexCommonHeaders(accessToken, chatGPTAccountID, fedRAMP)).
|
|
SetSuccessResult(&payload).
|
|
Get(chatGPTUsageURL)
|
|
if err != nil {
|
|
return nil, infraerrors.Newf(http.StatusBadGateway, "OPENAI_QUOTA_REQUEST_FAILED", "upstream request failed: %v", err)
|
|
}
|
|
if !resp.IsSuccessState() {
|
|
status := resp.StatusCode
|
|
body := truncate(resp.String(), 240)
|
|
slog.Warn("openai_quota_query_failed", "account_id", accountID, "status", status, "body", body)
|
|
return nil, infraerrors.Newf(mapUpstreamStatus(status), "OPENAI_QUOTA_UPSTREAM_ERROR", "upstream returned %d: %s", status, body)
|
|
}
|
|
|
|
payload.FetchedAt = time.Now().Unix()
|
|
return &payload, nil
|
|
}
|
|
|
|
// ResetCredit consumes one rate_limit_reset_credit for the given OpenAI account.
|
|
// The redeem_request_id is auto-generated (uuid-like) — upstream uses it for
|
|
// idempotency. Returns the consumed credit metadata so the UI can refresh.
|
|
func (s *OpenAIQuotaService) ResetCredit(ctx context.Context, accountID int64) (*OpenAIQuotaResetResult, error) {
|
|
accessToken, chatGPTAccountID, proxyURL, fedRAMP, err := s.prepareUpstreamCall(ctx, accountID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
redeemRequestID, err := generateRedeemRequestID()
|
|
if err != nil {
|
|
return nil, infraerrors.Newf(http.StatusInternalServerError, "OPENAI_QUOTA_REDEEM_ID_FAILED", "failed to generate redeem id: %v", err)
|
|
}
|
|
|
|
client, err := s.privacyClientFactory(proxyURL)
|
|
if err != nil {
|
|
return nil, infraerrors.Newf(http.StatusBadGateway, "OPENAI_QUOTA_CLIENT_ERROR", "failed to build upstream client: %v", err)
|
|
}
|
|
|
|
callCtx, cancel := context.WithTimeout(ctx, openaiQuotaUpstreamTimeout)
|
|
defer cancel()
|
|
|
|
headers := buildCodexCommonHeaders(accessToken, chatGPTAccountID, fedRAMP)
|
|
headers["content-type"] = "application/json"
|
|
|
|
var payload OpenAIQuotaResetResult
|
|
resp, err := client.R().
|
|
SetContext(callCtx).
|
|
SetHeaders(headers).
|
|
SetBody(map[string]string{"redeem_request_id": redeemRequestID}).
|
|
SetSuccessResult(&payload).
|
|
Post(chatGPTRateLimitResetURL)
|
|
if err != nil {
|
|
return nil, infraerrors.Newf(http.StatusBadGateway, "OPENAI_QUOTA_RESET_REQUEST_FAILED", "upstream request failed: %v", err)
|
|
}
|
|
if !resp.IsSuccessState() {
|
|
status := resp.StatusCode
|
|
body := truncate(resp.String(), 240)
|
|
slog.Warn("openai_quota_reset_failed", "account_id", accountID, "status", status, "body", body)
|
|
return nil, infraerrors.Newf(mapUpstreamStatus(status), "OPENAI_QUOTA_RESET_UPSTREAM_ERROR", "upstream returned %d: %s", status, body)
|
|
}
|
|
|
|
slog.Info("openai_quota_reset_success",
|
|
"account_id", accountID,
|
|
"code", payload.Code,
|
|
"windows_reset", payload.WindowsReset,
|
|
)
|
|
return &payload, nil
|
|
}
|
|
|
|
// prepareUpstreamCall loads the account, validates it, obtains a fresh access
|
|
// token via the shared TokenProvider, and resolves the chatgpt-account-id and
|
|
// proxy URL. Centralized so QueryUsage / ResetCredit share validation.
|
|
func (s *OpenAIQuotaService) prepareUpstreamCall(ctx context.Context, accountID int64) (accessToken, chatGPTAccountID, proxyURL string, fedRAMP bool, err error) {
|
|
if s == nil || s.accountRepo == nil || s.tokenProvider == nil || s.privacyClientFactory == nil {
|
|
return "", "", "", false, infraerrors.New(http.StatusInternalServerError, "OPENAI_QUOTA_NOT_CONFIGURED", "openai quota service is not configured")
|
|
}
|
|
|
|
account, err := s.accountRepo.GetByID(ctx, accountID)
|
|
if err != nil {
|
|
return "", "", "", false, infraerrors.Newf(http.StatusNotFound, "OPENAI_QUOTA_ACCOUNT_NOT_FOUND", "account not found: %v", err)
|
|
}
|
|
if account == nil {
|
|
return "", "", "", false, infraerrors.New(http.StatusNotFound, "OPENAI_QUOTA_ACCOUNT_NOT_FOUND", "account not found")
|
|
}
|
|
if account.Platform != PlatformOpenAI {
|
|
return "", "", "", false, infraerrors.New(http.StatusBadRequest, "OPENAI_QUOTA_INVALID_PLATFORM", "account is not an OpenAI account")
|
|
}
|
|
if account.Type != AccountTypeOAuth {
|
|
return "", "", "", false, infraerrors.New(http.StatusBadRequest, "OPENAI_QUOTA_INVALID_TYPE", "account is not an OAuth account")
|
|
}
|
|
|
|
chatGPTAccountID = strings.TrimSpace(account.GetCredential("chatgpt_account_id"))
|
|
if chatGPTAccountID == "" {
|
|
// Fall back to organization_id — some legacy accounts only persisted poid.
|
|
chatGPTAccountID = strings.TrimSpace(account.GetCredential("organization_id"))
|
|
}
|
|
if chatGPTAccountID == "" {
|
|
return "", "", "", false, infraerrors.New(http.StatusBadRequest, "OPENAI_QUOTA_MISSING_ACCOUNT_ID", "chatgpt_account_id is missing; please re-authorize this account")
|
|
}
|
|
|
|
accessToken, err = s.tokenProvider.GetAccessToken(ctx, account)
|
|
if err != nil {
|
|
return "", "", "", false, infraerrors.Newf(http.StatusBadGateway, "OPENAI_QUOTA_TOKEN_UNAVAILABLE", "failed to acquire access token: %v", err)
|
|
}
|
|
if strings.TrimSpace(accessToken) == "" {
|
|
return "", "", "", false, infraerrors.New(http.StatusBadGateway, "OPENAI_QUOTA_TOKEN_UNAVAILABLE", "access token is empty")
|
|
}
|
|
fedRAMP = account.IsChatGPTAccountFedRAMP()
|
|
|
|
// account.Proxy is eager-loaded by accountRepo.GetByID (see
|
|
// repository.accountsToService), so we can read the proxy URL directly
|
|
// instead of round-tripping the DB again. Fall back to proxyRepo only
|
|
// when Proxy isn't pre-populated (defensive — e.g. callers that built
|
|
// the Account by hand).
|
|
if account.ProxyID != nil {
|
|
switch {
|
|
case account.Proxy != nil:
|
|
proxyURL = account.Proxy.URL()
|
|
case s.proxyRepo != nil:
|
|
if proxy, perr := s.proxyRepo.GetByID(ctx, *account.ProxyID); perr == nil && proxy != nil {
|
|
proxyURL = proxy.URL()
|
|
}
|
|
}
|
|
}
|
|
|
|
return accessToken, chatGPTAccountID, proxyURL, fedRAMP, nil
|
|
}
|
|
|
|
// buildCodexCommonHeaders sets the request headers expected by the chatgpt.com
|
|
// backend so calls succeed past Cloudflare/WASM checks.
|
|
func buildCodexCommonHeaders(accessToken, chatGPTAccountID string, fedRAMP bool) map[string]string {
|
|
headers := map[string]string{
|
|
"authorization": "Bearer " + accessToken,
|
|
"chatgpt-account-id": chatGPTAccountID,
|
|
"oai-language": openaiQuotaCodexLanguageTag,
|
|
"originator": openaiQuotaCodexOriginator,
|
|
"accept": "application/json",
|
|
"sec-fetch-site": openaiQuotaSecFetchSite,
|
|
"sec-fetch-mode": openaiQuotaSecFetchMode,
|
|
"sec-fetch-dest": openaiQuotaSecFetchDest,
|
|
"priority": "u=4, i",
|
|
}
|
|
if fedRAMP {
|
|
headers["x-openai-fedramp"] = "true"
|
|
}
|
|
return headers
|
|
}
|
|
|
|
// generateRedeemRequestID produces a UUID-v4-shaped string without pulling in a
|
|
// new dependency. ChatGPT uses this as an idempotency key for the consume call.
|
|
func generateRedeemRequestID() (string, error) {
|
|
b := make([]byte, 16)
|
|
if _, err := rand.Read(b); err != nil {
|
|
return "", err
|
|
}
|
|
// Set version (4) and variant (RFC 4122) bits.
|
|
b[6] = (b[6] & 0x0f) | 0x40
|
|
b[8] = (b[8] & 0x3f) | 0x80
|
|
hexStr := hex.EncodeToString(b)
|
|
return fmt.Sprintf("%s-%s-%s-%s-%s", hexStr[0:8], hexStr[8:12], hexStr[12:16], hexStr[16:20], hexStr[20:]), nil
|
|
}
|
|
|
|
// mapUpstreamStatus collapses upstream HTTP statuses into a stable set we
|
|
// surface from the admin handler. 4xx upstream errors are surfaced as 502
|
|
// (BadGateway) so callers can distinguish "your input is bad" (400) from
|
|
// "upstream said no" (502); 401/403 are bubbled directly to hint at re-auth.
|
|
func mapUpstreamStatus(status int) int {
|
|
switch {
|
|
case status == http.StatusUnauthorized || status == http.StatusForbidden:
|
|
return status
|
|
case status == http.StatusTooManyRequests:
|
|
return http.StatusTooManyRequests
|
|
case status >= 400 && status < 500:
|
|
return http.StatusBadGateway
|
|
case status >= 500:
|
|
return http.StatusBadGateway
|
|
default:
|
|
return http.StatusBadGateway
|
|
}
|
|
}
|