feat: 新增支持codex转发

backend/internal/repository/account_repo.go

@@ -222,6 +222,38 @@ func (r *AccountRepository) ListSchedulableByGroupID(ctx context.Context, groupI
 	return accounts, err
 }
 
+// ListSchedulableByPlatform 按平台获取可调度的账号
+func (r *AccountRepository) ListSchedulableByPlatform(ctx context.Context, platform string) ([]model.Account, error) {
+	var accounts []model.Account
+	now := time.Now()
+	err := r.db.WithContext(ctx).
+		Where("platform = ?", platform).
+		Where("status = ? AND schedulable = ?", model.StatusActive, true).
+		Where("(overload_until IS NULL OR overload_until <= ?)", now).
+		Where("(rate_limit_reset_at IS NULL OR rate_limit_reset_at <= ?)", now).
+		Preload("Proxy").
+		Order("priority ASC").
+		Find(&accounts).Error
+	return accounts, err
+}
+
+// ListSchedulableByGroupIDAndPlatform 按组和平台获取可调度的账号
+func (r *AccountRepository) ListSchedulableByGroupIDAndPlatform(ctx context.Context, groupID int64, platform string) ([]model.Account, error) {
+	var accounts []model.Account
+	now := time.Now()
+	err := r.db.WithContext(ctx).
+		Joins("JOIN account_groups ON account_groups.account_id = accounts.id").
+		Where("account_groups.group_id = ?", groupID).
+		Where("accounts.platform = ?", platform).
+		Where("accounts.status = ? AND accounts.schedulable = ?", model.StatusActive, true).
+		Where("(accounts.overload_until IS NULL OR accounts.overload_until <= ?)", now).
+		Where("(accounts.rate_limit_reset_at IS NULL OR accounts.rate_limit_reset_at <= ?)", now).
+		Preload("Proxy").
+		Order("account_groups.priority ASC, accounts.priority ASC").
+		Find(&accounts).Error
+	return accounts, err
+}
+
 // SetRateLimited 标记账号为限流状态(429)
 func (r *AccountRepository) SetRateLimited(ctx context.Context, id int64, resetAt time.Time) error {
 	now := time.Now()

backend/internal/repository/http_upstream.go

@@ -6,15 +6,18 @@ import (
 	"time"
 
 	"sub2api/internal/config"
-	"sub2api/internal/service"
+	"sub2api/internal/service/ports"
 )
 
-type claudeUpstreamService struct {
+// httpUpstreamService is a generic HTTP upstream service that can be used for
+// making requests to any HTTP API (Claude, OpenAI, etc.) with optional proxy support.
+type httpUpstreamService struct {
 	defaultClient *http.Client
 	cfg           *config.Config
 }
 
-func NewClaudeUpstream(cfg *config.Config) service.ClaudeUpstream {
+// NewHTTPUpstream creates a new generic HTTP upstream service
+func NewHTTPUpstream(cfg *config.Config) ports.HTTPUpstream {
 	responseHeaderTimeout := time.Duration(cfg.Gateway.ResponseHeaderTimeout) * time.Second
 	if responseHeaderTimeout == 0 {
 		responseHeaderTimeout = 300 * time.Second
@@ -27,13 +30,13 @@ func NewClaudeUpstream(cfg *config.Config) service.ClaudeUpstream {
 		ResponseHeaderTimeout: responseHeaderTimeout,
 	}
 
-	return &claudeUpstreamService{
+	return &httpUpstreamService{
 		defaultClient: &http.Client{Transport: transport},
 		cfg:           cfg,
 	}
 }
 
-func (s *claudeUpstreamService) Do(req *http.Request, proxyURL string) (*http.Response, error) {
+func (s *httpUpstreamService) Do(req *http.Request, proxyURL string) (*http.Response, error) {
 	if proxyURL == "" {
 		return s.defaultClient.Do(req)
 	}
@@ -41,7 +44,7 @@ func (s *claudeUpstreamService) Do(req *http.Request, proxyURL string) (*http.Re
 	return client.Do(req)
 }
 
-func (s *claudeUpstreamService) createProxyClient(proxyURL string) *http.Client {
+func (s *httpUpstreamService) createProxyClient(proxyURL string) *http.Client {
 	parsedURL, err := url.Parse(proxyURL)
 	if err != nil {
 		return s.defaultClient

backend/internal/repository/openai_oauth_service.go

@@ -0,0 +1,92 @@
+package repository
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"time"
+
+	"sub2api/internal/pkg/openai"
+	"sub2api/internal/service/ports"
+
+	"github.com/imroc/req/v3"
+)
+
+type openaiOAuthService struct{}
+
+// NewOpenAIOAuthClient creates a new OpenAI OAuth client
+func NewOpenAIOAuthClient() ports.OpenAIOAuthClient {
+	return &openaiOAuthService{}
+}
+
+func (s *openaiOAuthService) ExchangeCode(ctx context.Context, code, codeVerifier, redirectURI, proxyURL string) (*openai.TokenResponse, error) {
+	client := createOpenAIReqClient(proxyURL)
+
+	if redirectURI == "" {
+		redirectURI = openai.DefaultRedirectURI
+	}
+
+	formData := url.Values{}
+	formData.Set("grant_type", "authorization_code")
+	formData.Set("client_id", openai.ClientID)
+	formData.Set("code", code)
+	formData.Set("redirect_uri", redirectURI)
+	formData.Set("code_verifier", codeVerifier)
+
+	var tokenResp openai.TokenResponse
+
+	resp, err := client.R().
+		SetContext(ctx).
+		SetFormDataFromValues(formData).
+		SetSuccessResult(&tokenResp).
+		Post(openai.TokenURL)
+
+	if err != nil {
+		return nil, fmt.Errorf("request failed: %w", err)
+	}
+
+	if !resp.IsSuccessState() {
+		return nil, fmt.Errorf("token exchange failed: status %d, body: %s", resp.StatusCode, resp.String())
+	}
+
+	return &tokenResp, nil
+}
+
+func (s *openaiOAuthService) RefreshToken(ctx context.Context, refreshToken, proxyURL string) (*openai.TokenResponse, error) {
+	client := createOpenAIReqClient(proxyURL)
+
+	formData := url.Values{}
+	formData.Set("grant_type", "refresh_token")
+	formData.Set("refresh_token", refreshToken)
+	formData.Set("client_id", openai.ClientID)
+	formData.Set("scope", openai.RefreshScopes)
+
+	var tokenResp openai.TokenResponse
+
+	resp, err := client.R().
+		SetContext(ctx).
+		SetFormDataFromValues(formData).
+		SetSuccessResult(&tokenResp).
+		Post(openai.TokenURL)
+
+	if err != nil {
+		return nil, fmt.Errorf("request failed: %w", err)
+	}
+
+	if !resp.IsSuccessState() {
+		return nil, fmt.Errorf("token refresh failed: status %d, body: %s", resp.StatusCode, resp.String())
+	}
+
+	return &tokenResp, nil
+}
+
+func createOpenAIReqClient(proxyURL string) *req.Client {
+	client := req.C().
+		SetTimeout(60 * time.Second)
+
+	if proxyURL != "" {
+		client.SetProxyURL(proxyURL)
+	}
+
+	return client
+}

backend/internal/repository/wire.go

@@ -36,7 +36,8 @@ var ProviderSet = wire.NewSet(
 	NewProxyExitInfoProber,
 	NewClaudeUsageFetcher,
 	NewClaudeOAuthClient,
-	NewClaudeUpstream,
+	NewHTTPUpstream,
+	NewOpenAIOAuthClient,
 
 	// Bind concrete repositories to service port interfaces
 	wire.Bind(new(ports.UserRepository), new(*UserRepository)),