revert: completely remove all Sora functionality

backend/internal/service/account_test_service.go

@@ -13,18 +13,14 @@ import (
 	"log"
 	"net/http"
 	"net/http/httptest"
-	"net/url"
 	"regexp"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/Wei-Shaw/sub2api/internal/config"
 	"github.com/Wei-Shaw/sub2api/internal/pkg/claude"
 	"github.com/Wei-Shaw/sub2api/internal/pkg/geminicli"
 	"github.com/Wei-Shaw/sub2api/internal/pkg/openai"
-	"github.com/Wei-Shaw/sub2api/internal/pkg/tlsfingerprint"
-	"github.com/Wei-Shaw/sub2api/internal/util/soraerror"
 	"github.com/Wei-Shaw/sub2api/internal/util/urlvalidator"
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
@@ -37,11 +33,6 @@ var sseDataPrefix = regexp.MustCompile(`^data:\s*`)
 const (
 	testClaudeAPIURL   = "https://api.anthropic.com/v1/messages?beta=true"
 	chatgptCodexAPIURL = "https://chatgpt.com/backend-api/codex/responses"
-	soraMeAPIURL       = "https://sora.chatgpt.com/backend/me" // Sora 用户信息接口，用于测试连接
-	soraBillingAPIURL  = "https://sora.chatgpt.com/backend/billing/subscriptions"
-	soraInviteMineURL  = "https://sora.chatgpt.com/backend/project_y/invite/mine"
-	soraBootstrapURL   = "https://sora.chatgpt.com/backend/m/bootstrap"
-	soraRemainingURL   = "https://sora.chatgpt.com/backend/nf/check"
 )
 
 // TestEvent represents a SSE event for account testing
@@ -71,13 +62,8 @@ type AccountTestService struct {
 	httpUpstream              HTTPUpstream
 	cfg                       *config.Config
 	tlsFPProfileService       *TLSFingerprintProfileService
-	soraTestGuardMu           sync.Mutex
-	soraTestLastRun           map[int64]time.Time
-	soraTestCooldown          time.Duration
 }
 
-const defaultSoraTestCooldown = 10 * time.Second
-
 // NewAccountTestService creates a new AccountTestService
 func NewAccountTestService(
 	accountRepo AccountRepository,
@@ -94,8 +80,6 @@ func NewAccountTestService(
 		httpUpstream:              httpUpstream,
 		cfg:                       cfg,
 		tlsFPProfileService:       tlsFPProfileService,
-		soraTestLastRun:           make(map[int64]time.Time),
-		soraTestCooldown:          defaultSoraTestCooldown,
 	}
 }
 
@@ -197,10 +181,6 @@ func (s *AccountTestService) TestAccountConnection(c *gin.Context, accountID int
 		return s.routeAntigravityTest(c, account, modelID, prompt)
 	}
 
-	if account.Platform == PlatformSora {
-		return s.testSoraAccountConnection(c, account)
-	}
-
 	return s.testClaudeAccountConnection(c, account, modelID)
 }
 
@@ -634,697 +614,6 @@ func (s *AccountTestService) testGeminiAccountConnection(c *gin.Context, account
 	return s.processGeminiStream(c, resp.Body)
 }
 
-type soraProbeStep struct {
-	Name       string `json:"name"`
-	Status     string `json:"status"`
-	HTTPStatus int    `json:"http_status,omitempty"`
-	ErrorCode  string `json:"error_code,omitempty"`
-	Message    string `json:"message,omitempty"`
-}
-
-type soraProbeSummary struct {
-	Status string          `json:"status"`
-	Steps  []soraProbeStep `json:"steps"`
-}
-
-type soraProbeRecorder struct {
-	steps []soraProbeStep
-}
-
-func (r *soraProbeRecorder) addStep(name, status string, httpStatus int, errorCode, message string) {
-	r.steps = append(r.steps, soraProbeStep{
-		Name:       name,
-		Status:     status,
-		HTTPStatus: httpStatus,
-		ErrorCode:  strings.TrimSpace(errorCode),
-		Message:    strings.TrimSpace(message),
-	})
-}
-
-func (r *soraProbeRecorder) finalize() soraProbeSummary {
-	meSuccess := false
-	partial := false
-	for _, step := range r.steps {
-		if step.Name == "me" {
-			meSuccess = strings.EqualFold(step.Status, "success")
-			continue
-		}
-		if strings.EqualFold(step.Status, "failed") {
-			partial = true
-		}
-	}
-
-	status := "success"
-	if !meSuccess {
-		status = "failed"
-	} else if partial {
-		status = "partial_success"
-	}
-
-	return soraProbeSummary{
-		Status: status,
-		Steps:  append([]soraProbeStep(nil), r.steps...),
-	}
-}
-
-func (s *AccountTestService) emitSoraProbeSummary(c *gin.Context, rec *soraProbeRecorder) {
-	if rec == nil {
-		return
-	}
-	summary := rec.finalize()
-	code := ""
-	for _, step := range summary.Steps {
-		if strings.EqualFold(step.Status, "failed") && strings.TrimSpace(step.ErrorCode) != "" {
-			code = step.ErrorCode
-			break
-		}
-	}
-	s.sendEvent(c, TestEvent{
-		Type:   "sora_test_result",
-		Status: summary.Status,
-		Code:   code,
-		Data:   summary,
-	})
-}
-
-func (s *AccountTestService) acquireSoraTestPermit(accountID int64) (time.Duration, bool) {
-	if accountID <= 0 {
-		return 0, true
-	}
-	s.soraTestGuardMu.Lock()
-	defer s.soraTestGuardMu.Unlock()
-
-	if s.soraTestLastRun == nil {
-		s.soraTestLastRun = make(map[int64]time.Time)
-	}
-	cooldown := s.soraTestCooldown
-	if cooldown <= 0 {
-		cooldown = defaultSoraTestCooldown
-	}
-
-	now := time.Now()
-	if lastRun, ok := s.soraTestLastRun[accountID]; ok {
-		elapsed := now.Sub(lastRun)
-		if elapsed < cooldown {
-			return cooldown - elapsed, false
-		}
-	}
-	s.soraTestLastRun[accountID] = now
-	return 0, true
-}
-
-func ceilSeconds(d time.Duration) int {
-	if d <= 0 {
-		return 1
-	}
-	sec := int(d / time.Second)
-	if d%time.Second != 0 {
-		sec++
-	}
-	if sec < 1 {
-		sec = 1
-	}
-	return sec
-}
-
-// testSoraAPIKeyAccountConnection 测试 Sora apikey 类型账号的连通性。
-// 向上游 base_url 发送轻量级 prompt-enhance 请求验证连通性和 API Key 有效性。
-func (s *AccountTestService) testSoraAPIKeyAccountConnection(c *gin.Context, account *Account) error {
-	ctx := c.Request.Context()
-
-	apiKey := account.GetCredential("api_key")
-	if apiKey == "" {
-		return s.sendErrorAndEnd(c, "Sora apikey 账号缺少 api_key 凭证")
-	}
-
-	baseURL := account.GetBaseURL()
-	if baseURL == "" {
-		return s.sendErrorAndEnd(c, "Sora apikey 账号缺少 base_url")
-	}
-
-	// 验证 base_url 格式
-	normalizedBaseURL, err := s.validateUpstreamBaseURL(baseURL)
-	if err != nil {
-		return s.sendErrorAndEnd(c, fmt.Sprintf("base_url 无效: %s", err.Error()))
-	}
-	upstreamURL := strings.TrimSuffix(normalizedBaseURL, "/") + "/sora/v1/chat/completions"
-
-	// 设置 SSE 头
-	c.Writer.Header().Set("Content-Type", "text/event-stream")
-	c.Writer.Header().Set("Cache-Control", "no-cache")
-	c.Writer.Header().Set("Connection", "keep-alive")
-	c.Writer.Header().Set("X-Accel-Buffering", "no")
-	c.Writer.Flush()
-
-	if wait, ok := s.acquireSoraTestPermit(account.ID); !ok {
-		msg := fmt.Sprintf("Sora 账号测试过于频繁，请 %d 秒后重试", ceilSeconds(wait))
-		return s.sendErrorAndEnd(c, msg)
-	}
-
-	s.sendEvent(c, TestEvent{Type: "test_start", Model: "sora-upstream"})
-
-	// 构建轻量级 prompt-enhance 请求作为连通性测试
-	testPayload := map[string]any{
-		"model":    "prompt-enhance-short-10s",
-		"messages": []map[string]string{{"role": "user", "content": "test"}},
-		"stream":   false,
-	}
-	payloadBytes, _ := json.Marshal(testPayload)
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, upstreamURL, bytes.NewReader(payloadBytes))
-	if err != nil {
-		return s.sendErrorAndEnd(c, "构建测试请求失败")
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", "Bearer "+apiKey)
-
-	// 获取代理 URL
-	proxyURL := ""
-	if account.ProxyID != nil && account.Proxy != nil {
-		proxyURL = account.Proxy.URL()
-	}
-
-	resp, err := s.httpUpstream.Do(req, proxyURL, account.ID, account.Concurrency)
-	if err != nil {
-		return s.sendErrorAndEnd(c, fmt.Sprintf("上游连接失败: %s", err.Error()))
-	}
-	defer func() { _ = resp.Body.Close() }()
-
-	respBody, _ := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
-
-	if resp.StatusCode == http.StatusOK {
-		s.sendEvent(c, TestEvent{Type: "content", Text: fmt.Sprintf("上游连接成功 (%s)", upstreamURL)})
-		s.sendEvent(c, TestEvent{Type: "content", Text: fmt.Sprintf("API Key 有效 (HTTP %d)", resp.StatusCode)})
-		s.sendEvent(c, TestEvent{Type: "test_complete", Success: true})
-		return nil
-	}
-
-	if resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden {
-		return s.sendErrorAndEnd(c, fmt.Sprintf("上游认证失败 (HTTP %d)，请检查 API Key 是否正确", resp.StatusCode))
-	}
-
-	// 其他错误但能连通（如 400 参数错误）也算连通性测试通过
-	if resp.StatusCode == http.StatusBadRequest {
-		s.sendEvent(c, TestEvent{Type: "content", Text: fmt.Sprintf("上游连接成功 (%s)", upstreamURL)})
-		s.sendEvent(c, TestEvent{Type: "content", Text: fmt.Sprintf("API Key 有效（上游返回 %d，参数校验错误属正常）", resp.StatusCode)})
-		s.sendEvent(c, TestEvent{Type: "test_complete", Success: true})
-		return nil
-	}
-
-	return s.sendErrorAndEnd(c, fmt.Sprintf("上游返回异常 HTTP %d: %s", resp.StatusCode, truncateSoraErrorBody(respBody, 256)))
-}
-
-// testSoraAccountConnection 测试 Sora 账号的连接
-// OAuth 类型：调用 /backend/me 接口验证 access_token 有效性
-// APIKey 类型：向上游 base_url 发送轻量级 prompt-enhance 请求验证连通性
-func (s *AccountTestService) testSoraAccountConnection(c *gin.Context, account *Account) error {
-	// apikey 类型走独立测试流程
-	if account.Type == AccountTypeAPIKey {
-		return s.testSoraAPIKeyAccountConnection(c, account)
-	}
-
-	ctx := c.Request.Context()
-	recorder := &soraProbeRecorder{}
-
-	authToken := account.GetCredential("access_token")
-	if authToken == "" {
-		recorder.addStep("me", "failed", http.StatusUnauthorized, "missing_access_token", "No access token available")
-		s.emitSoraProbeSummary(c, recorder)
-		return s.sendErrorAndEnd(c, "No access token available")
-	}
-
-	// Set SSE headers
-	c.Writer.Header().Set("Content-Type", "text/event-stream")
-	c.Writer.Header().Set("Cache-Control", "no-cache")
-	c.Writer.Header().Set("Connection", "keep-alive")
-	c.Writer.Header().Set("X-Accel-Buffering", "no")
-	c.Writer.Flush()
-
-	if wait, ok := s.acquireSoraTestPermit(account.ID); !ok {
-		msg := fmt.Sprintf("Sora 账号测试过于频繁，请 %d 秒后重试", ceilSeconds(wait))
-		recorder.addStep("rate_limit", "failed", http.StatusTooManyRequests, "test_rate_limited", msg)
-		s.emitSoraProbeSummary(c, recorder)
-		return s.sendErrorAndEnd(c, msg)
-	}
-
-	// Send test_start event
-	s.sendEvent(c, TestEvent{Type: "test_start", Model: "sora"})
-
-	req, err := http.NewRequestWithContext(ctx, "GET", soraMeAPIURL, nil)
-	if err != nil {
-		recorder.addStep("me", "failed", 0, "request_build_failed", err.Error())
-		s.emitSoraProbeSummary(c, recorder)
-		return s.sendErrorAndEnd(c, "Failed to create request")
-	}
-
-	// 使用 Sora 客户端标准请求头
-	req.Header.Set("Authorization", "Bearer "+authToken)
-	req.Header.Set("User-Agent", "Sora/1.2026.007 (Android 15; 24122RKC7C; build 2600700)")
-	req.Header.Set("Accept", "application/json")
-	req.Header.Set("Accept-Language", "en-US,en;q=0.9")
-	req.Header.Set("Origin", "https://sora.chatgpt.com")
-	req.Header.Set("Referer", "https://sora.chatgpt.com/")
-
-	// Get proxy URL
-	proxyURL := ""
-	if account.ProxyID != nil && account.Proxy != nil {
-		proxyURL = account.Proxy.URL()
-	}
-	soraTLSProfile := s.resolveSoraTLSProfile()
-
-	resp, err := s.httpUpstream.DoWithTLS(req, proxyURL, account.ID, account.Concurrency, soraTLSProfile)
-	if err != nil {
-		recorder.addStep("me", "failed", 0, "network_error", err.Error())
-		s.emitSoraProbeSummary(c, recorder)
-		return s.sendErrorAndEnd(c, fmt.Sprintf("Request failed: %s", err.Error()))
-	}
-	defer func() { _ = resp.Body.Close() }()
-
-	body, _ := io.ReadAll(resp.Body)
-
-	if resp.StatusCode != http.StatusOK {
-		if isCloudflareChallengeResponse(resp.StatusCode, resp.Header, body) {
-			recorder.addStep("me", "failed", resp.StatusCode, "cf_challenge", "Cloudflare challenge detected")
-			s.emitSoraProbeSummary(c, recorder)
-			s.logSoraCloudflareChallenge(account, proxyURL, soraMeAPIURL, resp.Header, body)
-			return s.sendErrorAndEnd(c, formatCloudflareChallengeMessage(fmt.Sprintf("Sora request blocked by Cloudflare challenge (HTTP %d). Please switch to a clean proxy/network and retry.", resp.StatusCode), resp.Header, body))
-		}
-		upstreamCode, upstreamMessage := soraerror.ExtractUpstreamErrorCodeAndMessage(body)
-		switch {
-		case resp.StatusCode == http.StatusUnauthorized && strings.EqualFold(upstreamCode, "token_invalidated"):
-			recorder.addStep("me", "failed", resp.StatusCode, "token_invalidated", "Sora token invalidated")
-			s.emitSoraProbeSummary(c, recorder)
-			return s.sendErrorAndEnd(c, "Sora token 已失效（token_invalidated），请重新授权账号")
-		case strings.EqualFold(upstreamCode, "unsupported_country_code"):
-			recorder.addStep("me", "failed", resp.StatusCode, "unsupported_country_code", "Sora is unavailable in current egress region")
-			s.emitSoraProbeSummary(c, recorder)
-			return s.sendErrorAndEnd(c, "Sora 在当前网络出口地区不可用（unsupported_country_code），请切换到支持地区后重试")
-		case strings.TrimSpace(upstreamMessage) != "":
-			recorder.addStep("me", "failed", resp.StatusCode, upstreamCode, upstreamMessage)
-			s.emitSoraProbeSummary(c, recorder)
-			return s.sendErrorAndEnd(c, fmt.Sprintf("Sora API returned %d: %s", resp.StatusCode, upstreamMessage))
-		default:
-			recorder.addStep("me", "failed", resp.StatusCode, upstreamCode, "Sora me endpoint failed")
-			s.emitSoraProbeSummary(c, recorder)
-			return s.sendErrorAndEnd(c, fmt.Sprintf("Sora API returned %d: %s", resp.StatusCode, truncateSoraErrorBody(body, 512)))
-		}
-	}
-	recorder.addStep("me", "success", resp.StatusCode, "", "me endpoint ok")
-
-	// 解析 /me 响应，提取用户信息
-	var meResp map[string]any
-	if err := json.Unmarshal(body, &meResp); err != nil {
-		// 能收到 200 就说明 token 有效
-		s.sendEvent(c, TestEvent{Type: "content", Text: "Sora connection OK (token valid)"})
-	} else {
-		// 尝试提取用户名或邮箱信息
-		info := "Sora connection OK"
-		if name, ok := meResp["name"].(string); ok && name != "" {
-			info = fmt.Sprintf("Sora connection OK - User: %s", name)
-		} else if email, ok := meResp["email"].(string); ok && email != "" {
-			info = fmt.Sprintf("Sora connection OK - Email: %s", email)
-		}
-		s.sendEvent(c, TestEvent{Type: "content", Text: info})
-	}
-
-	// 追加轻量能力检查：订阅信息查询（失败仅告警，不中断连接测试）
-	subReq, err := http.NewRequestWithContext(ctx, "GET", soraBillingAPIURL, nil)
-	if err == nil {
-		subReq.Header.Set("Authorization", "Bearer "+authToken)
-		subReq.Header.Set("User-Agent", "Sora/1.2026.007 (Android 15; 24122RKC7C; build 2600700)")
-		subReq.Header.Set("Accept", "application/json")
-		subReq.Header.Set("Accept-Language", "en-US,en;q=0.9")
-		subReq.Header.Set("Origin", "https://sora.chatgpt.com")
-		subReq.Header.Set("Referer", "https://sora.chatgpt.com/")
-
-		subResp, subErr := s.httpUpstream.DoWithTLS(subReq, proxyURL, account.ID, account.Concurrency, soraTLSProfile)
-		if subErr != nil {
-			recorder.addStep("subscription", "failed", 0, "network_error", subErr.Error())
-			s.sendEvent(c, TestEvent{Type: "content", Text: fmt.Sprintf("Subscription check skipped: %s", subErr.Error())})
-		} else {
-			subBody, _ := io.ReadAll(subResp.Body)
-			_ = subResp.Body.Close()
-			if subResp.StatusCode == http.StatusOK {
-				recorder.addStep("subscription", "success", subResp.StatusCode, "", "subscription endpoint ok")
-				if summary := parseSoraSubscriptionSummary(subBody); summary != "" {
-					s.sendEvent(c, TestEvent{Type: "content", Text: summary})
-				} else {
-					s.sendEvent(c, TestEvent{Type: "content", Text: "Subscription check OK"})
-				}
-			} else {
-				if isCloudflareChallengeResponse(subResp.StatusCode, subResp.Header, subBody) {
-					recorder.addStep("subscription", "failed", subResp.StatusCode, "cf_challenge", "Cloudflare challenge detected")
-					s.logSoraCloudflareChallenge(account, proxyURL, soraBillingAPIURL, subResp.Header, subBody)
-					s.sendEvent(c, TestEvent{Type: "content", Text: formatCloudflareChallengeMessage(fmt.Sprintf("Subscription check blocked by Cloudflare challenge (HTTP %d)", subResp.StatusCode), subResp.Header, subBody)})
-				} else {
-					upstreamCode, upstreamMessage := soraerror.ExtractUpstreamErrorCodeAndMessage(subBody)
-					recorder.addStep("subscription", "failed", subResp.StatusCode, upstreamCode, upstreamMessage)
-					s.sendEvent(c, TestEvent{Type: "content", Text: fmt.Sprintf("Subscription check returned %d", subResp.StatusCode)})
-				}
-			}
-		}
-	}
-
-	// 追加 Sora2 能力探测（对齐 sora2api 的测试思路）：邀请码 + 剩余额度。
-	s.testSora2Capabilities(c, ctx, account, authToken, proxyURL, soraTLSProfile, recorder)
-
-	s.emitSoraProbeSummary(c, recorder)
-	s.sendEvent(c, TestEvent{Type: "test_complete", Success: true})
-	return nil
-}
-
-func (s *AccountTestService) testSora2Capabilities(
-	c *gin.Context,
-	ctx context.Context,
-	account *Account,
-	authToken string,
-	proxyURL string,
-	tlsProfile *tlsfingerprint.Profile,
-	recorder *soraProbeRecorder,
-) {
-	inviteStatus, inviteHeader, inviteBody, err := s.fetchSoraTestEndpoint(
-		ctx,
-		account,
-		authToken,
-		soraInviteMineURL,
-		proxyURL,
-		tlsProfile,
-	)
-	if err != nil {
-		if recorder != nil {
-			recorder.addStep("sora2_invite", "failed", 0, "network_error", err.Error())
-		}
-		s.sendEvent(c, TestEvent{Type: "content", Text: fmt.Sprintf("Sora2 invite check skipped: %s", err.Error())})
-		return
-	}
-
-	if inviteStatus == http.StatusUnauthorized {
-		bootstrapStatus, _, _, bootstrapErr := s.fetchSoraTestEndpoint(
-			ctx,
-			account,
-			authToken,
-			soraBootstrapURL,
-			proxyURL,
-			tlsProfile,
-		)
-		if bootstrapErr == nil && bootstrapStatus == http.StatusOK {
-			if recorder != nil {
-				recorder.addStep("sora2_bootstrap", "success", bootstrapStatus, "", "bootstrap endpoint ok")
-			}
-			s.sendEvent(c, TestEvent{Type: "content", Text: "Sora2 bootstrap OK, retry invite check"})
-			inviteStatus, inviteHeader, inviteBody, err = s.fetchSoraTestEndpoint(
-				ctx,
-				account,
-				authToken,
-				soraInviteMineURL,
-				proxyURL,
-				tlsProfile,
-			)
-			if err != nil {
-				if recorder != nil {
-					recorder.addStep("sora2_invite", "failed", 0, "network_error", err.Error())
-				}
-				s.sendEvent(c, TestEvent{Type: "content", Text: fmt.Sprintf("Sora2 invite retry failed: %s", err.Error())})
-				return
-			}
-		} else if recorder != nil {
-			code := ""
-			msg := ""
-			if bootstrapErr != nil {
-				code = "network_error"
-				msg = bootstrapErr.Error()
-			}
-			recorder.addStep("sora2_bootstrap", "failed", bootstrapStatus, code, msg)
-		}
-	}
-
-	if inviteStatus != http.StatusOK {
-		if isCloudflareChallengeResponse(inviteStatus, inviteHeader, inviteBody) {
-			if recorder != nil {
-				recorder.addStep("sora2_invite", "failed", inviteStatus, "cf_challenge", "Cloudflare challenge detected")
-			}
-			s.logSoraCloudflareChallenge(account, proxyURL, soraInviteMineURL, inviteHeader, inviteBody)
-			s.sendEvent(c, TestEvent{Type: "content", Text: formatCloudflareChallengeMessage(fmt.Sprintf("Sora2 invite check blocked by Cloudflare challenge (HTTP %d)", inviteStatus), inviteHeader, inviteBody)})
-			return
-		}
-		upstreamCode, upstreamMessage := soraerror.ExtractUpstreamErrorCodeAndMessage(inviteBody)
-		if recorder != nil {
-			recorder.addStep("sora2_invite", "failed", inviteStatus, upstreamCode, upstreamMessage)
-		}
-		s.sendEvent(c, TestEvent{Type: "content", Text: fmt.Sprintf("Sora2 invite check returned %d", inviteStatus)})
-		return
-	}
-	if recorder != nil {
-		recorder.addStep("sora2_invite", "success", inviteStatus, "", "invite endpoint ok")
-	}
-
-	if summary := parseSoraInviteSummary(inviteBody); summary != "" {
-		s.sendEvent(c, TestEvent{Type: "content", Text: summary})
-	} else {
-		s.sendEvent(c, TestEvent{Type: "content", Text: "Sora2 invite check OK"})
-	}
-
-	remainingStatus, remainingHeader, remainingBody, remainingErr := s.fetchSoraTestEndpoint(
-		ctx,
-		account,
-		authToken,
-		soraRemainingURL,
-		proxyURL,
-		tlsProfile,
-	)
-	if remainingErr != nil {
-		if recorder != nil {
-			recorder.addStep("sora2_remaining", "failed", 0, "network_error", remainingErr.Error())
-		}
-		s.sendEvent(c, TestEvent{Type: "content", Text: fmt.Sprintf("Sora2 remaining check skipped: %s", remainingErr.Error())})
-		return
-	}
-	if remainingStatus != http.StatusOK {
-		if isCloudflareChallengeResponse(remainingStatus, remainingHeader, remainingBody) {
-			if recorder != nil {
-				recorder.addStep("sora2_remaining", "failed", remainingStatus, "cf_challenge", "Cloudflare challenge detected")
-			}
-			s.logSoraCloudflareChallenge(account, proxyURL, soraRemainingURL, remainingHeader, remainingBody)
-			s.sendEvent(c, TestEvent{Type: "content", Text: formatCloudflareChallengeMessage(fmt.Sprintf("Sora2 remaining check blocked by Cloudflare challenge (HTTP %d)", remainingStatus), remainingHeader, remainingBody)})
-			return
-		}
-		upstreamCode, upstreamMessage := soraerror.ExtractUpstreamErrorCodeAndMessage(remainingBody)
-		if recorder != nil {
-			recorder.addStep("sora2_remaining", "failed", remainingStatus, upstreamCode, upstreamMessage)
-		}
-		s.sendEvent(c, TestEvent{Type: "content", Text: fmt.Sprintf("Sora2 remaining check returned %d", remainingStatus)})
-		return
-	}
-	if recorder != nil {
-		recorder.addStep("sora2_remaining", "success", remainingStatus, "", "remaining endpoint ok")
-	}
-	if summary := parseSoraRemainingSummary(remainingBody); summary != "" {
-		s.sendEvent(c, TestEvent{Type: "content", Text: summary})
-	} else {
-		s.sendEvent(c, TestEvent{Type: "content", Text: "Sora2 remaining check OK"})
-	}
-}
-
-func (s *AccountTestService) fetchSoraTestEndpoint(
-	ctx context.Context,
-	account *Account,
-	authToken string,
-	url string,
-	proxyURL string,
-	tlsProfile *tlsfingerprint.Profile,
-) (int, http.Header, []byte, error) {
-	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
-	if err != nil {
-		return 0, nil, nil, err
-	}
-	req.Header.Set("Authorization", "Bearer "+authToken)
-	req.Header.Set("User-Agent", "Sora/1.2026.007 (Android 15; 24122RKC7C; build 2600700)")
-	req.Header.Set("Accept", "application/json")
-	req.Header.Set("Accept-Language", "en-US,en;q=0.9")
-	req.Header.Set("Origin", "https://sora.chatgpt.com")
-	req.Header.Set("Referer", "https://sora.chatgpt.com/")
-
-	resp, err := s.httpUpstream.DoWithTLS(req, proxyURL, account.ID, account.Concurrency, tlsProfile)
-	if err != nil {
-		return 0, nil, nil, err
-	}
-	defer func() { _ = resp.Body.Close() }()
-
-	body, readErr := io.ReadAll(resp.Body)
-	if readErr != nil {
-		return resp.StatusCode, resp.Header, nil, readErr
-	}
-	return resp.StatusCode, resp.Header, body, nil
-}
-
-func parseSoraSubscriptionSummary(body []byte) string {
-	var subResp struct {
-		Data []struct {
-			Plan struct {
-				ID    string `json:"id"`
-				Title string `json:"title"`
-			} `json:"plan"`
-			EndTS string `json:"end_ts"`
-		} `json:"data"`
-	}
-	if err := json.Unmarshal(body, &subResp); err != nil {
-		return ""
-	}
-	if len(subResp.Data) == 0 {
-		return ""
-	}
-
-	first := subResp.Data[0]
-	parts := make([]string, 0, 3)
-	if first.Plan.Title != "" {
-		parts = append(parts, first.Plan.Title)
-	}
-	if first.Plan.ID != "" {
-		parts = append(parts, first.Plan.ID)
-	}
-	if first.EndTS != "" {
-		parts = append(parts, "end="+first.EndTS)
-	}
-	if len(parts) == 0 {
-		return ""
-	}
-	return "Subscription: " + strings.Join(parts, " | ")
-}
-
-func parseSoraInviteSummary(body []byte) string {
-	var inviteResp struct {
-		InviteCode    string `json:"invite_code"`
-		RedeemedCount int64  `json:"redeemed_count"`
-		TotalCount    int64  `json:"total_count"`
-	}
-	if err := json.Unmarshal(body, &inviteResp); err != nil {
-		return ""
-	}
-
-	parts := []string{"Sora2: supported"}
-	if inviteResp.InviteCode != "" {
-		parts = append(parts, "invite="+inviteResp.InviteCode)
-	}
-	if inviteResp.TotalCount > 0 {
-		parts = append(parts, fmt.Sprintf("used=%d/%d", inviteResp.RedeemedCount, inviteResp.TotalCount))
-	}
-	return strings.Join(parts, " | ")
-}
-
-func parseSoraRemainingSummary(body []byte) string {
-	var remainingResp struct {
-		RateLimitAndCreditBalance struct {
-			EstimatedNumVideosRemaining int64 `json:"estimated_num_videos_remaining"`
-			RateLimitReached            bool  `json:"rate_limit_reached"`
-			AccessResetsInSeconds       int64 `json:"access_resets_in_seconds"`
-		} `json:"rate_limit_and_credit_balance"`
-	}
-	if err := json.Unmarshal(body, &remainingResp); err != nil {
-		return ""
-	}
-	info := remainingResp.RateLimitAndCreditBalance
-	parts := []string{fmt.Sprintf("Sora2 remaining: %d", info.EstimatedNumVideosRemaining)}
-	if info.RateLimitReached {
-		parts = append(parts, "rate_limited=true")
-	}
-	if info.AccessResetsInSeconds > 0 {
-		parts = append(parts, fmt.Sprintf("reset_in=%ds", info.AccessResetsInSeconds))
-	}
-	return strings.Join(parts, " | ")
-}
-
-func (s *AccountTestService) resolveSoraTLSProfile() *tlsfingerprint.Profile {
-	if s == nil || s.cfg == nil || !s.cfg.Sora.Client.DisableTLSFingerprint {
-		// Sora TLS fingerprint enabled — use built-in default profile
-		return &tlsfingerprint.Profile{Name: "Built-in Default (Sora)"}
-	}
-	return nil // disabled
-}
-
-func isCloudflareChallengeResponse(statusCode int, headers http.Header, body []byte) bool {
-	return soraerror.IsCloudflareChallengeResponse(statusCode, headers, body)
-}
-
-func formatCloudflareChallengeMessage(base string, headers http.Header, body []byte) string {
-	return soraerror.FormatCloudflareChallengeMessage(base, headers, body)
-}
-
-func extractCloudflareRayID(headers http.Header, body []byte) string {
-	return soraerror.ExtractCloudflareRayID(headers, body)
-}
-
-func extractSoraEgressIPHint(headers http.Header) string {
-	if headers == nil {
-		return "unknown"
-	}
-	candidates := []string{
-		"x-openai-public-ip",
-		"x-envoy-external-address",
-		"cf-connecting-ip",
-		"x-forwarded-for",
-	}
-	for _, key := range candidates {
-		if value := strings.TrimSpace(headers.Get(key)); value != "" {
-			return value
-		}
-	}
-	return "unknown"
-}
-
-func sanitizeProxyURLForLog(raw string) string {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return ""
-	}
-	u, err := url.Parse(raw)
-	if err != nil {
-		return "<invalid_proxy_url>"
-	}
-	if u.User != nil {
-		u.User = nil
-	}
-	return u.String()
-}
-
-func endpointPathForLog(endpoint string) string {
-	parsed, err := url.Parse(strings.TrimSpace(endpoint))
-	if err != nil || parsed.Path == "" {
-		return endpoint
-	}
-	return parsed.Path
-}
-
-func (s *AccountTestService) logSoraCloudflareChallenge(account *Account, proxyURL, endpoint string, headers http.Header, body []byte) {
-	accountID := int64(0)
-	platform := ""
-	proxyID := "none"
-	if account != nil {
-		accountID = account.ID
-		platform = account.Platform
-		if account.ProxyID != nil {
-			proxyID = fmt.Sprintf("%d", *account.ProxyID)
-		}
-	}
-	cfRay := extractCloudflareRayID(headers, body)
-	if cfRay == "" {
-		cfRay = "unknown"
-	}
-	log.Printf(
-		"[SoraCFChallenge] account_id=%d platform=%s endpoint=%s path=%s proxy_id=%s proxy_url=%s cf_ray=%s egress_ip_hint=%s",
-		accountID,
-		platform,
-		endpoint,
-		endpointPathForLog(endpoint),
-		proxyID,
-		sanitizeProxyURLForLog(proxyURL),
-		cfRay,
-		extractSoraEgressIPHint(headers),
-	)
-}
-
-func truncateSoraErrorBody(body []byte, max int) string {
-	return soraerror.TruncateBody(body, max)
-}
 
 // routeAntigravityTest 路由 Antigravity 账号的测试请求。
 // APIKey 类型走原生协议（与 gateway_handler 路由一致），OAuth/Upstream 走 CRS 中转。